# Contexto, andamento e continuidade do curso

> Documento de transição para pessoas ou outras IAs continuarem o projeto sem
> depender do histórico da conversa original.

## 1. Identificação

- **Projeto:** Engenharia de IA Aplicada à Programação Web
- **Espaço de trabalho local:** `C:\xampp\htdocs\site\PosIA`
- **URL inicial:** `http://localhost/site/PosIA/`
- **Idioma do conteúdo:** português do Brasil
- **Público inicial:** pessoas sem conhecimento prévio de programação
- **Carga horária planejada:** 240 horas
- **Quantidade planejada de módulos:** 16
- **Data deste registro:** 5 de agosto de 2026
- **Estado geral:** módulos 1, 2, 3, 4 e 5 concluídos
- **Próxima entrega:** planejamento do Módulo 6 — MySQL e persistência

## 2. Como usar este documento

Uma nova pessoa ou IA deve começar por este arquivo e depois consultar, nesta
ordem:

1. [`README.md`](../README.md) — catálogo do material disponível;
2. [`docs/matriz-curricular.md`](matriz-curricular.md) — plano dos 16 módulos;
3. [`docs/arquitetura-tecnica.md`](arquitetura-tecnica.md) — decisões técnicas;
4. [`docs/PADRAO-LINGUISTICO-PT-BR.md`](PADRAO-LINGUISTICO-PT-BR.md) — padrão editorial;
5. o `README.md` do módulo que estiver em desenvolvimento;
6. a última aula fonte em `modulos/<modulo>/aulas/`;
7. `scripts/render-lessons.mjs` — cadastro e renderização das aulas.

Ao finalizar qualquer nova aula, este documento deve ser atualizado nas seções:

- **Estado atual verificável**;
- **Registro detalhado do que foi produzido**;
- **Trabalho pendente**;
- **Próxima ação recomendada**;
- **Histórico de continuidade**.

## 3. Pedido original e evolução do escopo

O projeto começou a partir da análise da ementa:

```text
C:\Users\willian.silva\Downloads\Ementa_Detalhada__Engenheria_de_IA_Aplicada_1763558262665605.pdf
```

O PDF está fora deste espaço de trabalho e não deve ser considerado parte versionada do
projeto. Caso outra máquina ou IA precise reanalisá-lo, o arquivo deverá estar
disponível novamente.

O pedido foi transformado em um curso detalhado de programação web. As decisões
posteriores foram:

- trocar PostgreSQL por **MySQL**;
- usar **TypeScript** como linguagem principal;
- usar **Angular** no front-end;
- usar **NestJS** na API;
- usar **Prisma ORM** para migrations e persistência;
- começar com um **monólito modular**;
- desenvolver uma plataforma de conhecimento chamada **Knowledge AI**;
- produzir aulas renderizadas que possam ser acessadas pelo navegador local;
- criar navegação por módulos e por aulas;
- escrever todas as introduções para quem ainda não conhece o assunto.

## 4. Objetivo do curso

Formar o aluno para projetar, implementar, testar, publicar e defender tecnicamente
um Micro-SaaS que combine:

- interface web responsiva e acessível;
- front-end Angular;
- API NestJS;
- autenticação e autorização;
- banco relacional MySQL;
- integração com modelos de IA;
- documentos e RAG;
- tools, function calling e MCP;
- agentes com aprovação humana;
- testes, segurança e observabilidade;
- controle de custos;
- CI/CD e publicação.

## 5. Projeto evolutivo

O aluno constrói a **Knowledge AI**, uma plataforma inteligente de conhecimento.
Ela começa como uma página estática e evolui até um Micro-SaaS.

| Marco | Capacidade adicionada |
|---|---|
| 1 | Página responsiva |
| 2 | Aplicação Angular |
| 3 | API NestJS |
| 4 | MySQL e autenticação |
| 5 | Chat com IA e streaming |
| 6 | Upload e processamento de documentos |
| 7 | RAG com fontes |
| 8 | Tools e servidor MCP |
| 9 | Agente com aprovação humana |
| 10 | Avaliações, observabilidade e custos |
| 11 | CI/CD e implantação |
| 12 | Micro-SaaS final |

## 6. Decisões técnicas que não devem ser alteradas silenciosamente

### 6.1 Stack principal

- TypeScript de ponta a ponta;
- Angular no front-end;
- NestJS no back-end;
- MySQL como banco relacional oficial;
- Prisma ORM;
- monólito modular inicialmente;
- workers para tarefas demoradas;
- camada independente de provedor para IA;
- adaptador substituível para recuperação semântica.

### 6.2 Banco de dados

PostgreSQL foi substituído por MySQL por decisão explícita do usuário. Uma nova IA
não deve reintroduzir PostgreSQL em exemplos, diagramas ou planejamento sem uma nova
solicitação.

Arquivos binários não devem ser gravados diretamente no MySQL. O banco deverá
armazenar metadados, propriedade, estado de processamento e localização.

### 6.3 Arquitetura

A API começará como monólito modular. Não separar serviços antecipadamente. Workers
e servidor MCP poderão ser separados quando existir uma justificativa técnica.

O domínio não deve chamar diretamente SDKs de provedores de IA. Usar uma porta como:

```ts
export interface LanguageModel {
  generate(input: GenerationInput): Promise<GenerationResult>;
  stream(input: GenerationInput): AsyncIterable<GenerationEvent>;
}
```

A recuperação de conhecimento também deverá ser acessada por uma abstração.

### 6.4 Segurança

- nunca colocar credenciais de IA no front-end;
- tratar entrada externa como `unknown` até validação;
- não usar `innerHTML` com dados fornecidos pelo usuário;
- preferir `textContent`, `replaceChildren` e criação explícita de elementos;
- não registrar dados sensíveis em registros;
- exigir aprovação humana para ações críticas;
- auditar ações de agentes e ferramentas;
- não incluir senhas, tokens, chaves ou arquivos `.env` reais nos exemplos.

## 7. Arquitetura pedagógica obrigatória

Cada aula deve começar pressupondo que o aluno não conhece o assunto.

### 7.1 Perguntas que a introdução deve responder

- O que é o assunto?
- Para que ele serve?
- Onde funciona ou é executado?
- Com quais conceitos costuma ser confundido?
- O que ele não é?
- É necessário instalar algo?
- O que o aluno precisa saber antes?
- Como o assunto se conecta ao projeto do curso?

Exemplo de orientação dada pelo usuário para Git:

> “Não sei o que é Git. Todo Git é do GitHub? Consigo ter um Git local?”

Esse nível de explicação deve ser repetido em **todas as aulas**, adaptado ao tema.

### 7.2 Estrutura mínima de uma aula

1. Identificação;
2. Introdução para iniciantes;
3. Objetivos mensuráveis;
4. Pré-requisitos;
5. Pergunta orientadora;
6. Roteiro sugerido;
7. Explicações conceituais progressivas;
8. Exemplos de código;
9. Laboratório guiado;
10. Erros comuns;
11. Boas práticas;
12. Exercícios;
13. Desafio individual;
14. Lista de verificação de conclusão;
15. Critérios de avaliação;
16. Resumo;
17. Próxima aula.

### 7.3 Ciclo pedagógico

```text
Entender → observar → implementar → testar → corrigir → publicar
```

### 7.4 Estilo do texto

- português claro e direto;
- explicar termos em inglês quando aparecem pela primeira vez;
- não pressupor experiência com terminal, Git, frameworks ou banco;
- comparar conceitos parecidos;
- explicar onde o código roda;
- mostrar consequências práticas, não somente definições;
- incluir exemplos corretos e exemplos de erros;
- evitar depender de serviços externos nos primeiros laboratórios.

## 8. Estrutura do espaço de trabalho

```text
PosIA/
├── index.html
├── README.md
├── assets/
│   └── css/
│       ├── course-index.css
│       └── lesson-reader.css
├── docs/
│   ├── arquitetura-tecnica.md
│   ├── matriz-curricular.md
│   └── CONTEXTO-E-ANDAMENTO.md
├── modulos/
│   ├── 01-fundamentos-web/
│   ├── 02-javascript-moderno/
│   └── 03-typescript-git-qualidade/
└── scripts/
    └── render-lessons.mjs
```

Cada módulo segue, quando aplicável:

```text
modulos/<numero>-<nome>/
├── README.md
├── aulas/          # fontes Markdown, editadas manualmente
├── exemplos/       # laboratórios executáveis
├── materiais/      # rubricas, checklists e roteiros, quando necessário
└── renderizadas/   # HTML gerado; não editar manualmente
```

## 9. Estado atual verificável

Levantamento atualizado em 5 de agosto de 2026:

| Item | Quantidade |
|---|---:|
| Aulas fonte em Markdown | 38 |
| Aulas renderizadas em HTML | 38 |
| Laboratórios com `index.html` | 33 |
| Documentos principais renderizados | 3 |
| Módulos com material implementado | 5 |
| Módulos totalmente concluídos | 5 |
| Próximo módulo a desenvolver | 6 — MySQL e persistência |

### 9.1 Resumo por módulo

| Módulo | Estado | Aulas prontas | Total planejado | Próxima ação |
|---|---|---:|---:|---|
| 1 — Fundamentos da Web | Concluído | 6 | 6 | Nenhuma |
| 2 — JavaScript moderno | Concluído | 8 | 8 | Nenhuma |
| 3 — TypeScript, Git e qualidade | Concluído | 6 | 6 | Nenhuma |
| 4 — Angular | Concluído | 10 | 10 | Nenhuma |
| 5 — Node.js, NestJS e APIs | Concluído | 8 | 8 | Nenhuma |
| 6 — MySQL e persistência | Planejado | 0 | A definir | Planejar o módulo e criar a Aula 6.1 |
| 7 — Autenticação, segurança e testes | Planejado | 0 | A definir | Futuro |
| 8 a 16 | Planejados | 0 | A definir | Futuro |

## 10. Registro detalhado do que foi produzido

### 10.1 Infraestrutura do curso

- página inicial em [`index.html`](../index.html);
- identidade visual do índice em [`assets/css/course-index.css`](../assets/css/course-index.css);
- leitor de aulas em [`assets/css/lesson-reader.css`](../assets/css/lesson-reader.css);
- renderizador Markdown → HTML em [`scripts/render-lessons.mjs`](../scripts/render-lessons.mjs);
- navegação lateral por módulos;
- navegação por aulas dentro do módulo;
- sumário automático da aula;
- navegação anterior/próxima;
- progresso da aula no módulo;
- navegação adaptada para telas menores;
- links para a fonte Markdown;
- índice com cartões “Disponível” e “Planejada”.

### 10.2 Módulo 1 — Fundamentos da Web

**Estado:** concluído, 6 de 6 aulas.

| Aula | Tema | Entrega principal |
|---|---|---|
| 1.1 | Como a Web funciona | Introdução à Web, requisição e resposta |
| 1.2 | HTML semântico | Landing page Knowledge AI |
| 1.3 | CSS responsivo | Interface adaptável |
| 1.4 | JavaScript no navegador | Interação com formulário |
| 1.5 | DevTools e segurança | Auditoria guiada |
| 1.6 | Git, publicação e apresentação | Entrega e defesa da página |

Materiais adicionais:

- lista de verificação de auditoria web;
- rubrica do projeto;
- roteiro de apresentação;
- relatório de auditoria;
- projeto executável da landing page.

Observação importante: embora Git apareça na aula 1.6 como introdução à publicação,
a explicação aprofundada sobre Git local, GitHub, branches e PRs foi criada na Aula
3.5.

### 10.3 Módulo 2 — JavaScript moderno

**Estado:** concluído, 8 de 8 aulas e 8 laboratórios.

| Aula | Tema | Laboratório |
|---|---|---|
| 2.1 | Valores, variáveis e tipos | Explorador de tipos |
| 2.2 | Condições e repetições | Classificador de tarefas |
| 2.3 | Funções, escopo e closures | Biblioteca de regras |
| 2.4 | Arrays e transformação | Painel de métricas |
| 2.5 | Objetos, JSON e modelagem | Modelador de tarefas |
| 2.6 | Módulos e tratamento de erros | Aplicação modular |
| 2.7 | Promises, async/await e Fetch | Cliente de API |
| 2.8 | Armazenamento, testes e projeto | Painel final de tarefas |

O projeto do módulo é um painel de tarefas com filtros, métricas, importação e
exportação JSON, consumo assíncrono, armazenamento de preferências e testes básicos.

### 10.4 Módulo 3 — TypeScript, Git e qualidade

**Estado:** concluído, 6 de 6 aulas.

#### Aula 3.1 — Introdução ao TypeScript

- tipos estáticos;
- inferência;
- compilação e apagamento dos tipos;
- diferença entre compilação e ambiente de execução;
- validação de dados externos;
- laboratório com fonte TypeScript, erros intencionais e JavaScript executável.

#### Aula 3.2 — Interfaces, aliases e contratos

- diferença entre interface TypeScript e interface visual;
- aliases;
- opcionais, `undefined` e `null`;
- `readonly`;
- tipagem estrutural;
- `Record`, `Pick`, `Omit` e `Partial`;
- validação em ambiente de execução;
- laboratório de modelagem de tarefas.

#### Aula 3.3 — Unions, narrowing e generics

- unions e literal unions;
- diferença entre union e array;
- narrowing com `typeof`, igualdade, `in` e `instanceof`;
- predicates e assertion functions;
- discriminated unions;
- estados impossíveis;
- exaustividade com `never`;
- generics, constraints e `keyof`;
- laboratório com estados `idle`, `loading`, `success`, `empty` e `error`.

#### Aula 3.4 — Configuração, lint e formatação

- `package.json` e dependências locais;
- `tsconfig.json` estrito;
- compilação versus typecheck;
- ESLint versus Prettier;
- scripts reproduzíveis;
- porta única de qualidade;
- fluxo local e CI;
- laboratório que simula falhas de tipo, lint, formatação e teste.

#### Aula 3.5 — Git, branches e pull requests

- Git não é GitHub;
- Git pode ser totalmente local;
- working tree, staging e commits;
- `HEAD` e branches;
- repositórios remotos;
- `fetch`, `pull` e `push`;
- `git pull` não é pull request;
- revisão, merge e conflitos;
- `.gitignore` e proteção de segredos;
- laboratório que bloqueia ações fora de ordem e diferencia local, rede e
  plataforma.

Correção realizada durante QA visual: o histórico do laboratório 3.5 agora mostra
somente o commit mais recente como `main · HEAD`; o anterior aparece como commit
ancestral.

#### Aula 3.6 — Testes, documentação e projeto final

- diferença entre teste manual e automatizado;
- testes unitários, de integração e E2E;
- Arrange, Act e Assert;
- casos felizes, limites, falhas e regressão;
- testes determinísticos e independentes;
- dublês de teste, mocks e cobertura;
- Node Test Runner;
- README reproduzível;
- decisões, limitações e evidências de entrega;
- laboratório que executa quatro testes e audita oito seções obrigatórias;
- exemplo de projeto com `package.json`, `tsconfig.json`, fonte TypeScript e testes.

### 10.5 Módulo 4 — Angular

**Estado:** concluído, 10 de 10 aulas.

#### Plano do módulo

- 4.1: introdução ao Angular e componentes;
- 4.2: templates, bindings e control flow;
- 4.3: composição, inputs e outputs;
- 4.4: serviços e injeção de dependência;
- 4.5: rotas, layouts e navegação;
- 4.6: formulários e validação;
- 4.7: HTTP, APIs e RxJS;
- 4.8: signals e estado da interface;
- 4.9: interceptors, erros e acessibilidade;
- 4.10: testes, compilação e projeto final.

#### Aula 4.1 — Introdução ao Angular e componentes

- Angular como framework, não linguagem;
- diferença entre Angular e AngularJS;
- framework, SPA, CLI, espaço de trabalho e aplicação;
- estrutura moderna criada pelo Angular CLI;
- nomes concisos atuais como `app.ts` e existência do estilo antigo
  `app.component.ts`;
- anatomia de componente: classe, decorator, seletor, template e estilos;
- componentes standalone como padrão atual para código novo;
- contexto de projetos antigos com `NgModule`;
- host element, view e árvore de componentes;
- arquitetura segura Angular → API NestJS → Prisma → MySQL;
- laboratório estático com fonte Angular equivalente e visualização interativa da
  anatomia do componente.

Decisões verificadas na documentação oficial do Angular em julho de 2026:

- componentes novos são standalone por padrão;
- `ng new` utiliza standalone e modo estrito por padrão;
- o guia de nomes atual usa arquivos concisos por padrão;
- projetos existentes podem continuar utilizando `NgModule`.

#### Aula 4.2 — Templates, bindings e control flow

- template Angular como HTML compilado com sintaxes adicionais;
- interpolação de texto;
- property, attribute, ARIA, class e style bindings;
- diferenças entre propriedades DOM e atributos HTML;
- event binding e uso seguro de `$event`;
- uso introdutório de signals para estado reativo;
- `@if`, `@else if`, `@else` e aliases;
- `@for`, variáveis contextuais e identidade estável;
- obrigatoriedade e escolha correta de `track`;
- fallback de coleção vazia com `@empty`;
- `@switch` sem fallthrough;
- estado derivado fora do template;
- laboratório com filtro, conclusão, remoção, estado vazio e mapa de bindings;
- fonte Angular equivalente em `src/app/task-list.*`;
- laboratório sem `innerHTML` para dados dinâmicos.

#### Aula 4.3 — Composição, inputs e outputs

- árvore de componentes e relação entre pai e filho;
- separação de responsabilidades entre componente de lista e cartão;
- modelo `Task` compartilhado e propriedades somente para leitura;
- API atual `input()`, `input.required()` e valores padrão;
- leitura de `InputSignal` e diferença entre input e atributo HTML;
- fluxo unidirecional de dados do pai para o filho;
- API atual `output<T>()`, `emit()` e payload recebido em `$event`;
- diferença entre evento DOM e output Angular;
- outputs personalizados não fazem bubbling no DOM;
- atualização imutável realizada pelo componente dono do estado;
- contexto de compatibilidade com `@Input()`, `@Output()` e `EventEmitter`;
- laboratório com filtro no pai, três instâncias filhas e registro visual do fluxo;
- fonte Angular equivalente separada em modelo, `TaskList` e `TaskCard`;
- simulação estática sem `innerHTML`, usando `textContent` e `replaceChildren`.

#### Aula 4.4 — Serviços e injeção de dependência

- introdução a serviço, dependência, injector, provider e token;
- diferença entre serviço Angular, servidor back-end e função utilitária;
- separação entre apresentação do componente e estado compartilhado;
- API `@Service()` introduzida como padrão conciso do Angular 22;
- `@Injectable({ providedIn: "root" })` mantido para compatibilidade e casos avançados;
- preferência atual por `inject()` e contexto válido de injeção;
- motivo para não criar dependências gerenciadas com `new` no componente;
- signal gravável privado e leitura pública com `asReadonly()`;
- operações de domínio e estado derivado encapsulados em `TaskStore`;
- providers raiz, de componente e hierarquia de resolução;
- classe como token, sintaxe `useClass` e introdução a `InjectionToken`;
- laboratório comparando uma instância `ROOT-1` compartilhada com `LOCAL-A` e
  `LOCAL-B` isoladas;
- fonte equivalente com `TaskStore`, `TaskPanel` e exemplo legado compatível;
- simulação acessível construída sem `innerHTML`.

#### Aula 4.5 — Rotas, layouts e navegação

- introdução a URL, caminho, rota, SPA, Router, outlet e layout;
- diferença entre página HTML e página lógica de uma aplicação Angular;
- três peças essenciais: `Routes`, `RouterOutlet` e `RouterLink`;
- registro moderno com `provideRouter` em `ApplicationConfig`;
- shell persistente com cabeçalho, navegação e conteúdo principal;
- link ativo com `RouterLinkActive` e `ariaCurrentWhenActive`;
- parâmetros `:id`, criação de links por array e validação numérica;
- `withComponentInputBinding()` para entregar parâmetros a inputs tipados;
- alternativa tradicional com `ActivatedRoute` e limitações do snapshot;
- diferença entre route params e query params;
- redirect inicial com `pathMatch: "full"`;
- rota coringa `**`, títulos e estratégia *first match wins*;
- navegação programática, rotas filhas e layouts aninhados;
- base href, fallback do servidor e separação entre navegação e autorização;
- laboratório com shell persistente, URL didática, histórico, detalhe e 404;
- fonte Angular equivalente separada em configuração, shell e páginas;
- renderização estática sem `innerHTML`.

#### Aula 4.6 — Formulários e validação

- introdução a formulário, campo, label, valor, envio e validação;
- camadas complementares de validação em HTML, Angular, API NestJS e MySQL;
- comparação entre Signal Forms, Reactive Forms e Template-driven Forms;
- Signal Forms estáveis no Angular 22 como abordagem principal da aula;
- modelo tipado em signal como fonte de verdade e árvore criada com `form()`;
- bindings com `FormField` e submissão com `FormRoot`;
- schema centralizado com `required`, `minLength`, `maxLength` e `validate`;
- estados `valid`, `invalid`, `errors`, `touched`, `dirty` e `submitting`;
- mensagens após interação ou tentativa de envio;
- `aria-describedby`, `aria-invalid`, resumo focável e regiões vivas;
- prevenção de envio duplicado e preservação dos valores após erro da API;
- introdução equivalente a Reactive Forms tipados com `FormControl` e `FormGroup`;
- segurança: front-end não substitui validação do servidor nem acessa MySQL;
- laboratório com quatro campos, contador, data, erro simulado e estado observável;
- implementação equivalente em `src/app/task-form` sem `innerHTML`.

#### Aula 4.7 — HTTP, APIs e RxJS

- introdução a HTTP, API, cliente, servidor, requisição, resposta, JSON e status;
- arquitetura Angular → HTTP → NestJS → Prisma → MySQL;
- diferença entre serviço Angular, API e banco de dados;
- métodos GET, POST, PUT, PATCH e DELETE e status comuns;
- configuração explícita com `provideHttpClient()` e injeção de `HttpClient`;
- DTOs distintos de leitura e criação;
- Observables, Observers, Subscriptions, notificações e execução fria;
- operadores `map`, `startWith`, `catchError`, `switchMap` e `finalize`;
- conversão para signal com `toSignal` e limpeza com `takeUntilDestroyed`;
- union discriminada para loading, success, empty e error;
- tratamento de `HttpErrorResponse`, status 0, 404 e 500;
- cancelamento de requisições obsoletas e retry consciente;
- distinção entre generics TypeScript e validação ambiente de execução do JSON;
- `httpResource` estável no Angular 22 para GET reativo, não mutações;
- laboratório com cenários controlados, latência, cancelamento, GET e POST 201;
- implementação equivalente em `src/app` com TaskApi, DTOs e TaskPage;
- simulação local sem requisições externas e sem `innerHTML`.

#### Aula 4.8 — Signals e estado da interface

- introdução a estado, reatividade, fonte de verdade e grafo de dependências;
- distinção entre estado de domínio, remoto, visual, de formulário e derivado;
- diferença entre variável comum, signal e Observable;
- writable signals, leitura por chamada, `set`, `update` e `asReadonly`;
- atualização imutável de arrays e igualdade referencial padrão com `Object.is`;
- `computed` somente leitura, lazy, memoizado e com dependências dinâmicas;
- `linkedSignal` gravável para preservar uma seleção válida quando a fonte muda;
- `effect` reservado a APIs não reativas, sem propagação de estado derivável;
- leitura incidental com `untracked` e uso criterioso de igualdade personalizada;
- store por página com escrita privada e API pública orientada ao domínio;
- escolha do menor proprietário adequado para o estado;
- interoperação com RxJS por `toSignal` e `toObservable` sem subscriptions duplicadas;
- laboratório com grafo reativo, contadores de recomputação e seleção autorrecuperável;
- fonte Angular equivalente em `src/app`, simulação estática sem `innerHTML`.

#### Aula 4.9 — Interceptors, erros e acessibilidade

- introdução a interceptor, middleware, cadeia e limites de segurança no front-end;
- distinção entre interceptor Angular, middleware NestJS, API e banco MySQL;
- interceptors funcionais configurados com `withInterceptors`;
- ordem previsível na ida da requisição e retorno inverso da resposta;
- imutabilidade de `HttpRequest`, clonagem e cuidado com mutação profunda do corpo;
- correlação, autenticação restrita ao destino, telemetria e metadados em `HttpContext`;
- classificação de rede, timeout, 401, 403, 404, 409, 422 e 5xx;
- preservação do canal de erro e separação entre falha e lista vazia;
- retry limitado por método, falha transitória e idempotência;
- renovação de sessão sem concorrência descontrolada ou ciclo recursivo;
- indicador global baseado em contador para requisições concorrentes;
- separação de responsabilidades entre interceptor, serviço e componente;
- retorno com `role="status"`, `role="alert"`, região viva e foco consciente;
- distinção entre erro HTTP esperado e `ErrorHandler` global;
- privacidade, redaction e testes de interceptors;
- laboratório com sete cenários, ordem visual da cadeia e retry seguro para GET;
- fonte Angular equivalente em `src/app`, sem requisição externa e sem `innerHTML`.

#### Aula 4.10 — Testes, compilação e projeto final

- introdução a teste automatizado, suíte, caso, expectativa, compilação e publicação;
- distinção entre teste unitário, componente, integração e ponta a ponta;
- Vitest como runner padrão nos projetos Angular CLI atuais;
- padrão Arrange, Act, Assert e nomes orientados ao comportamento;
- testes de funções puras, serviços, stores, signals e dependências substituídas;
- `TestBed`, `ComponentFixture`, componente standalone, DOM e interação;
- testes HTTP com `provideHttpClientTesting` e `HttpTestingController`;
- ordem correta ao testar interceptors e verificação de requisições pendentes;
- estados assíncronos, erros controlados e acessibilidade essencial;
- cobertura de código interpretada como indicador, não garantia de qualidade;
- execução local, modo CI e gate de qualidade;
- `ng build`, AOT, otimização, budgets, source maps, cache e hashing;
- auditoria de segredos no bundle e separação Angular → NestJS → MySQL;
- fallback SPA, deep links, base href e requisitos de hospedagem;
- README reproduzível, roteiro de apresentação e rubrica de 100 pontos;
- laboratório com perfis de entrega, seis testes, cinco etapas de compilação e parecer;
- exemplos Angular/Vitest em `src/app`, simulação determinística sem `innerHTML`.

### 10.6 Módulo 5 — Node.js, NestJS e APIs

**Estado:** concluído, 8 de 8 aulas.

#### Plano do módulo

- 5.1: introdução ao Node.js e NestJS;
- 5.2: módulos, controladores e provedores;
- 5.3: REST, rotas e respostas HTTP;
- 5.4: DTOs, pipes e validação;
- 5.5: erros, filtros e configuração;
- 5.6: OpenAPI e documentação;
- 5.7: registros, interceptadores e testes;
- 5.8: compilação e projeto final.

#### Aula 5.1 — Introdução ao Node.js e NestJS

- introdução para quem ainda não conhece back-end;
- Node.js como ambiente de execução JavaScript multiplataforma;
- processo, porta, servidor, localhost e variável de ambiente;
- npm, `package.json` e scripts locais;
- NestJS como framework e Express/Fastify como adaptadores HTTP;
- comparação de responsabilidades entre Angular e NestJS;
- relação com XAMPP: Apache pode servir as páginas, enquanto Node executa a API;
- inicialização com `NestFactory`, prefixo global e porta validada;
- `AppModule` e `HealthModule`;
- controller para receber HTTP e provider para executar a regra;
- injeção de dependência pelo construtor;
- endpoint `GET /api/health` com resposta JSON;
- distinção inicial entre liveness e readiness;
- chamada pelo navegador, curl, PowerShell e Angular;
- CORS, event loop, shutdown e scripts de execução;
- laboratório estático que simula processo, porta, requisição, roteamento, controller,
  provider, resposta 200 e erro 404;
- fonte NestJS equivalente com configuração mínima e execução independente do
  simulador visual.

O Módulo 5 foi cadastrado no renderizador e aparece na navegação lateral de todas as
aulas. O índice mostra cinco módulos criados e concluídos, com 38 de 38 aulas
disponíveis no recorte já detalhado.

#### Aula 5.2 — Módulos, controladores e provedores

- diferença entre pasta e módulo NestJS;
- módulo raiz, feature module e organização por capacidade de negócio;
- metadados de `@Module()`: `imports`, `controllers`, `providers` e `exports`;
- diferença entre `import` TypeScript e `imports` do contêiner;
- controller como adaptador HTTP com delegação de regras;
- provider como dependência gerenciada pelo contêiner;
- injeção de dependência e inversão de controle;
- tokens de classe, string e `Symbol`;
- explicação sobre interfaces TypeScript apagadas em ambiente de execução;
- contrato `TasksRepository` e implementação em memória substituível;
- `TasksService` com validação inicial e `TasksController` fino;
- encapsulamento, interface pública de módulos e providers globais;
- escopos default, requisição e transient;
- diagnóstico de token ausente e dependência circular;
- comparação entre DI no Angular e no NestJS;
- laboratório com inicialização correto, provider ausente, ciclo, escopos, contadores de
  instâncias e requisições GET/POST;
- exemplo NestJS executável com `TasksModule`, controller, service, token e repositório.

#### Aula 5.3 — REST, rotas e respostas HTTP

- introdução a API, REST, recurso, representação, rota, endpoint e URL;
- URLs orientadas a recursos e uso de substantivos;
- anatomia completa de requisições e respostas HTTP;
- métodos GET, POST, PUT, PATCH e DELETE;
- parâmetros de rota, cadeia de consulta, corpo e cabeçalhos;
- diferença entre substituição completa e atualização parcial;
- métodos seguros e idempotência;
- status 200, 201, 204, 400, 404, 409 e 500;
- exceções HTTP e resposta padrão do NestJS;
- contratos de coleção simples e com envelope;
- distinção entre CRUD e REST;
- ampliação do controller, service e repositório em memória;
- segurança inicial para dados externos;
- laboratório com console de requisições, fluxo de roteamento, estado em memória,
  filtros, criação, busca, atualização, remoção e respostas de erro;
- exemplo NestJS executável com os endpoints REST de tarefas.

#### Aula 5.4 — DTOs, pipes e validação

- diferença entre tipagem TypeScript e validação em ambiente de execução;
- DTO como contrato de transferência, separado da entidade persistida;
- classes concretas e risco de `import type` em DTOs validados;
- pipes de transformação e validação antes do controller;
- decorators do `class-validator` e transformações do `class-transformer`;
- `ValidationPipe` global com `transform`, `whitelist` e `forbidNonWhitelisted`;
- conversão explícita e segura de booleanos externos;
- `CreateTaskDto`, `UpdateTaskDto`, `ListTasksQueryDto` e `TaskParamsDto`;
- `PartialType()` e diferença para `Partial<T>`;
- pipes prontos para inteiros, booleanos, UUIDs, enums e arrays;
- validação estrutural separada de regra de negócio;
- validação aninhada, arrays e atualizações vazias;
- mensagens 400 seguras e redução de dados refletidos;
- laboratório com entrada bruta, transformação, lista de permissões, validação e bloqueio do controller;
- exemplo NestJS executável com DTOs e configuração global.

#### Aula 5.5 — Erros, filtros e configuração

- classificação entre entrada inválida, regra de negócio, ausência, dependência externa
  e defeito inesperado;
- exceções HTTP prontas e continuidade do processo após falhas de uma requisição;
- contrato de erro com status, código, mensagem, path, timestamp e correlação;
- exception filter global com `ArgumentsHost` e `HttpAdapterHost`;
- registro com `APP_FILTER` para preservar injeção de dependência;
- normalização de `HttpException` e resposta genérica para erros desconhecidos;
- diferenças entre middleware, guard, interceptor, pipe e filter;
- configuração por ambiente e valores recebidos como strings;
- `ConfigModule`, validação customizada e falha rápida na inicialização;
- configuração pública, segredos, `.env`, `.env.example` e rotação após vazamento;
- uso centralizado do `ConfigService` e configuração por namespace;
- proteção contra segredos em registros, respostas e código Angular;
- laboratório com validação de ambiente, porta e senha, cenários 400, 404, 409, 503
  e 500, resposta pública, registro interno e correlation ID;
- exemplo NestJS executável com filter global e configuração validada.

#### Aula 5.6 — OpenAPI e documentação

- introdução ao contrato OpenAPI e à interface Swagger para quem nunca os utilizou;
- configuração de `DocumentBuilder`, `SwaggerModule` e rota de documentação;
- tags, operações, parâmetros, corpos, respostas, erros e exemplos realistas;
- schemas derivados de DTOs e cuidados para evitar contratos duplicados;
- autenticação bearer documentada e separação entre documentação pública e interna;
- exportação do documento JSON para clientes, validação e automação;
- explicação do plug-in da CLI e de seus limites;
- distinção entre documentação interativa e testes automatizados;
- laboratório que permite inspecionar operações, metadados, schemas, exemplos e o
  documento OpenAPI gerado.

#### Aula 5.7 — Registros, interceptadores e testes

- introdução à observabilidade e diferença entre registro, métrica e rastreamento;
- `Logger` do NestJS, níveis, contexto e registros estruturados em JSON;
- proteção de senhas, tokens e outros dados sensíveis;
- identificador de correlação criado por middleware e propagado na resposta;
- interceptador de duração com RxJS e registro do término da requisição;
- registro global com `APP_INTERCEPTOR` e preservação da injeção de dependência;
- testes unitários de provedores, testes de controladores e testes HTTP;
- `TestingModule`, dependências substitutas, regressão, cobertura e modo de integração
  contínua;
- laboratório que simula requisições, registros seguros e uma suíte de testes com
  cenário de regressão.

#### Aula 5.8 — Compilação e projeto final

- diferença entre desenvolvimento, compilação, execução e implantação;
- comandos para Windows, conteúdo de `dist` e execução da versão compilada;
- porta de qualidade com formatação, análise estática, testes e compilação;
- configuração por ambiente, segredos, documentação e evidências de entrega;
- execução completa local no Windows com Angular, NestJS e MySQL;
- esclarecimento de que uma VPS não é obrigatória para concluir o curso;
- considerações sobre hospedagem compartilhada e necessidade de suporte a processos
  Node.js para publicar a API;
- projeto final do módulo com contrato OpenAPI, tratamento de erros, registros,
  interceptador, testes, README e apresentação;
- laboratório de auditoria com perfis, evidências, pontuação e parecer final.

## 11. Laboratórios TypeScript: detalhe operacional importante

Os laboratórios do módulo 3 possuem:

```text
exemplos/aula-3.x/
├── index.html
├── assets/styles.css
├── src/app.ts
├── dist/app.js
└── tsconfig.json
```

Alguns também possuem `src/type-errors.ts` com erros propositais para ensino.

### Limitação atual

Não existe TypeScript instalado no espaço de trabalho e não há `package.json` na raiz. Por
isso, nas aulas 3.1 a 3.6, o `dist/app.js` foi mantido manualmente como equivalente
executável de `src/app.ts`.

Ao alterar `src/app.ts`, é obrigatório:

1. atualizar `dist/app.js` com comportamento equivalente;
2. executar `node --check` no JavaScript;
3. abrir o laboratório no navegador;
4. testar todos os estados interativos;
5. verificar o console.

Uma continuidade futura pode instalar TypeScript localmente e automatizar a compilação,
mas isso deve ser feito conscientemente e documentado, pois altera o fluxo atual.

## 12. Renderização das aulas

### 12.1 Fonte da verdade

As fontes são os arquivos em `modulos/<modulo>/aulas/*.md`. Os arquivos em
`renderizadas/*.html` são gerados e não devem ser editados manualmente.

### 12.2 Cadastro

Uma aula só será renderizada e aparecerá na navegação do leitor quando for
cadastrada no array `courseModules` de `scripts/render-lessons.mjs`.

Para cadastrar uma nova aula, informar:

```js
{
  source: "06-testes-documentacao-projeto.md",
  output: "aula-06.html",
  shortTitle: "Testes, documentação e projeto",
  number: "3.6",
  type: "Oficina integradora",
}
```

### 12.3 Comando usado neste ambiente

O script exige o caminho de um `node_modules` que contenha `marked`:

```powershell
$node = 'C:\Users\willian.silva\.cache\codex-runtimes\codex-primary-runtime\dependencies\node\bin\node.exe'
$modules = 'C:\Users\willian.silva\.cache\codex-runtimes\codex-primary-runtime\dependencies\node\node_modules'
& $node 'scripts\render-lessons.mjs' $modules
```

Esse caminho pertence ao ambiente atual e pode não existir em outra máquina. Nesse
caso, instalar Node.js e `marked` localmente ou adaptar o comando sem modificar a
lógica pedagógica.

### 12.4 O que o renderizador produz

- título e metadados;
- sumário baseado em headings `##`;
- slugs sem acentos;
- navegação por módulos;
- navegação por aulas;
- progresso;
- links anterior/próximo;
- link para a fonte;
- conversão de links entre aulas `.md` para `.html` quando cadastradas.

### 12.5 Cache de CSS

O leitor utiliza atualmente:

```text
../../../assets/css/lesson-reader.css?v=20260730-modules
```

O parâmetro foi incluído para evitar que o navegador mantivesse uma versão antiga
do CSS após a implementação da navegação por módulos. Se houver alteração visual
significativa, atualizar a versão no renderizador e regenerar todas as aulas.

### 12.6 Renderização dos documentos principais

As fontes continuam sendo:

```text
README.md
docs/matriz-curricular.md
docs/arquitetura-tecnica.md
```

O script `scripts/render-docs.mjs` gera:

```text
docs/renderizadas/visao-geral.html
docs/renderizadas/matriz-curricular.html
docs/renderizadas/arquitetura-tecnica.html
```

Ele cria sumário, navegação anterior/próximo, link para a fonte e recalcula caminhos
relativos. As páginas usam `assets/css/lesson-reader.css` e o complemento
`assets/css/document-reader.css`. Para regenerar, utilizar o mesmo ambiente de execução com
`marked` empregado no renderizador de aulas:

```powershell
$node = 'C:\Users\willian.silva\.cache\codex-runtimes\codex-primary-runtime\dependencies\node\bin\node.exe'
$modules = 'C:\Users\willian.silva\.cache\codex-runtimes\codex-primary-runtime\dependencies\node\node_modules'
& $node 'scripts\render-docs.mjs' $modules
```

Não editar os três HTMLs gerados manualmente.

## 13. Navegação por módulos

A navegação solicitada pelo usuário foi implementada no leitor de aulas:

- seção “Curso / Navegar por módulos”;
- módulo atual destacado com `aria-current="location"`;
- lista das aulas do módulo atual;
- aula atual destacada com `aria-current="page"`;
- versão móvel dentro de `<details>`;
- links calculados entre diretórios de módulos.

Somente os módulos cadastrados em `courseModules` aparecem nessa navegação. Ao
iniciar o módulo 4, adicionar o módulo ao renderizador mesmo antes de criar todas as
aulas, desde que os links cadastrados existam.

## 14. Página inicial

O arquivo [`index.html`](../index.html) é um índice manual. Ao concluir uma aula:

1. atualizar o texto “X de Y aulas” do módulo;
2. transformar o cartão de planejado em `lesson-card--ready`;
3. trocar o badge para `badge--ready` e “Disponível”;
4. trocar a metadata “Planejada” pelo tipo real;
5. adicionar link para a aula renderizada;
6. manter as próximas aulas como planejadas.

O índice não é gerado automaticamente pelo renderizador.

O resumo do topo é acumulado e calculado por `assets/js/course-index.js`. Cada seção
de módulo criada no índice deve possuir:

```html
data-course-module
data-module-lessons="10"
data-module-status="complete|in-progress"
```

O script conta os cartões `lesson-card--ready`, os módulos criados e seus estados.
Assim, o painel inicial deixa de representar apenas o Módulo 1 e cresce junto com o
curso. Os valores presentes no HTML são um fallback acessível e devem refletir o
estado atual mesmo antes da execução do JavaScript.

O índice também possui um mapa dos 16 módulos antes das seções de aulas. Os módulos
concluídos são links para seus respectivos cards de aula; módulos ainda não criados
aparecem como planejados, com carga horária e resultado resumido da matriz. Não criar
cards de aulas futuras antes de definir sua sequência no README do módulo.

## 15. Validação aplicada até agora

Para cada aula recente foram realizadas verificações proporcionais:

- renderização do Markdown;
- existência da introdução;
- link do laboratório;
- link para aula anterior;
- progresso correto;
- presença da fonte Markdown;
- sintaxe de `dist/app.js` com `node --check`;
- leitura válida do `tsconfig.json`;
- navegação real no servidor local;
- execução de todos os estados relevantes do laboratório;
- inspeção visual;
- consulta de erros do console.

Exemplos já testados:

- Aula 3.3: sucesso, vazio e erro;
- Aula 3.4: falha de typecheck, lint, formatação e teste, além de correção automática;
- Aula 3.5: tentativa de PR antes do push e fluxo completo até o merge.
- Aula 3.6: quatro testes unitários reais aprovados sem isolamento de processo;
  implementação correta 4/4, regressão 3/4, README completo 8/8, README incompleto
  1/8, porta de entrega e console validados no navegador.

## 16. Trabalho pendente imediato

### 16.1 Planejar o Módulo 6 — MySQL e persistência

- confirmar a divisão do módulo em aulas e a carga horária de cada etapa;
- introduzir banco de dados relacional, tabela, coluna, linha, chave e relacionamento;
- manter MySQL como banco de dados oficial do curso;
- integrar NestJS, Prisma e MySQL sem exigir uma VPS do aluno;
- definir um caminho de instalação local no Windows, preferencialmente compatível com
  o MySQL do XAMPP já utilizado no curso;
- planejar modelagem, SQL, Prisma, migrações, integridade, transações e testes;
- criar a Aula 6.1 com introdução para iniciantes e laboratório acessível.

## 17. Planejamento futuro completo

### Nível 1 — Fundamentos Web

- Módulo 1: Fundamentos da Web — concluído;
- Módulo 2: JavaScript moderno — concluído;
- Módulo 3: TypeScript, Git e qualidade — concluído;

### Nível 2 — Desenvolvimento Full-Stack

- Módulo 4: Angular — concluído, 20 h;
- Módulo 5: Node.js, NestJS e APIs — concluído, 16 h;
- Módulo 6: MySQL e persistência — 16 h;
- Módulo 7: Autenticação, segurança e testes — 12 h.

### Nível 3 — Aplicações Web com IA

- Módulo 8: Fundamentos de IA e LLMs — 16 h;
- Módulo 9: APIs generativas e prompts — 16 h;
- Módulo 10: Multimodalidade e documentos — 12 h;
- Módulo 11: Embeddings e RAG — 20 h.

### Nível 4 — Agentes e Arquitetura

- Módulo 12: Tools, function calling e MCP — 14 h;
- Módulo 13: Agentes e workflows — 18 h;
- Módulo 14: Arquitetura AI-first — 12 h.

### Nível 5 — Produção e Capstone

- Módulo 15: Entrega e operação — 12 h;
- Módulo 16: Micro-SaaS e defesa técnica — 16 h.

Detalhes de conteúdo e resultados esperados estão em
[`docs/matriz-curricular.md`](matriz-curricular.md).

## 18. Próxima ação recomendada para outra IA

Use esta instrução de continuidade:

> Continue o projeto em `C:\xampp\htdocs\site\PosIA`. Leia primeiro
> `docs/CONTEXTO-E-ANDAMENTO.md`, depois o README raiz, a matriz curricular, a
> arquitetura técnica e o README do Módulo 5. Os módulos 1 a 5 estão concluídos, com
> 38 aulas e 33 laboratórios. Planeje o Módulo 6 — MySQL e persistência — e depois crie
> a Aula 6.1 seguindo o padrão pedagógico anterior. Explique banco de dados relacional
> desde o início, inclua um laboratório acessível e preserve TypeScript, Angular,
> NestJS, Prisma e MySQL; não altere MySQL para PostgreSQL.

## 19. Lista de verificação de continuidade para qualquer nova aula

- [ ] Ler este documento e o README do módulo.
- [ ] Confirmar qual aula é a próxima.
- [ ] Criar a fonte Markdown com introdução para iniciantes.
- [ ] Criar laboratório acessível e responsivo.
- [ ] Evitar dependências externas quando desnecessárias.
- [ ] Tratar dados inseridos como não confiáveis.
- [ ] Manter `src/app.ts` e `dist/app.js` equivalentes enquanto não houver compilação.
- [ ] Criar ou atualizar `tsconfig.json`, quando aplicável.
- [ ] Cadastrar a aula no renderizador.
- [ ] Atualizar README do módulo.
- [ ] Atualizar README raiz.
- [ ] Atualizar `index.html`.
- [ ] Regenerar as páginas.
- [ ] Verificar sintaxe e JSON.
- [ ] Testar interações no navegador.
- [ ] Verificar console e layout.
- [ ] Atualizar este documento.

## 20. Limitações e riscos conhecidos

### 20.1 O espaço de trabalho não é um repositório Git

Na última verificação, `git status` indicou que o diretório não é um repositório ou
que Git não está disponível nesse contexto. Portanto:

- não assumir que existe histórico de commits;
- não executar comandos destrutivos de Git;
- inicializar um repositório somente se o usuário solicitar;
- considerar criar uma cópia de segurança antes de grandes alterações.

### 20.2 Dependência externa do renderizador

O renderizador depende de `marked` fornecido pelo ambiente de execução local. Outra máquina pode
precisar instalar dependências ou adaptar o comando.

### 20.3 Índice manual

O índice e o cadastro do renderizador podem divergir se apenas um deles for
atualizado. Sempre conferir os dois.

### 20.4 JavaScript manual no módulo TypeScript

Sem compilação automática, `src/app.ts` e `dist/app.js` podem divergir. Testar o
comportamento real e comparar mudanças.

### 20.5 PDF fora do espaço de trabalho

A ementa original não está dentro do projeto. Preservar a matriz curricular já
extraída e solicitar novamente o PDF somente se uma reanálise for necessária.

### 20.6 Conteúdo futuro ainda não detalhado aula por aula

Os módulos 6 a 16 possuem objetivos e tópicos na matriz, mas ainda não possuem
divisão final de aulas, fontes, laboratórios ou páginas renderizadas. O Módulo 5 está
concluído com oito aulas; a continuidade deve começar pelo planejamento do Módulo 6.

## 21. Arquivos que representam a fonte da verdade

| Assunto | Arquivo principal |
|---|---|
| Continuidade e andamento | `docs/CONTEXTO-E-ANDAMENTO.md` |
| Catálogo do que existe | `README.md` |
| Plano dos 16 módulos | `docs/matriz-curricular.md` |
| Stack e arquitetura | `docs/arquitetura-tecnica.md` |
| Padrão editorial em português | `docs/PADRAO-LINGUISTICO-PT-BR.md` |
| Plano de cada módulo | `modulos/<modulo>/README.md` |
| Conteúdo das aulas | `modulos/<modulo>/aulas/*.md` |
| Cadastro e renderização | `scripts/render-lessons.mjs` |
| Página visual do curso | `index.html` |
| Visual do leitor | `assets/css/lesson-reader.css` |

## 22. Histórico de continuidade

### 5 de agosto de 2026

- Aula 5.6 criada com contrato OpenAPI, Swagger, DTOs, respostas, segurança e
  exportação do documento JSON;
- Aula 5.7 criada com registros estruturados, correlação, interceptadores e testes;
- Aula 5.8 criada com compilação, implantação, auditoria, apresentação e projeto final;
- criados três laboratórios interativos e acessíveis para as aulas 5.6, 5.7 e 5.8;
- Módulo 5 concluído com oito aulas;
- totais atualizados para 38 fontes, 38 páginas renderizadas e 33 laboratórios;
- próxima ação atualizada para o planejamento do Módulo 6 — MySQL e persistência.

### 3 de agosto de 2026

- realizada auditoria linguística nas fontes Markdown, no índice e nos laboratórios;
- padronizados termos explicativos em português do Brasil, preservando comandos, nomes oficiais e identificadores de código;
- criado `docs/PADRAO-LINGUISTICO-PT-BR.md` com glossário e lista de verificação editorial;
- criado `scripts/normalize-pt-br.mjs` para apoiar futuras revisões sem alterar blocos de código, código em linha ou endereços de links;
- corrigidas mensagens e legendas dos laboratórios que misturavam português e inglês;
- mantida como próxima entrega a Aula 5.6 — OpenAPI e documentação.

### 1º de agosto de 2026

- Módulo 5 planejado com oito aulas e projeto de API REST documentada;
- Aula 5.1 criada com introdução ao back-end, Node.js, npm, processo, porta e NestJS;
- implementados inicialização, módulos, controller, provider, DI e `GET /api/health`;
- laboratório 5.1 criado com processo simulado, fluxo da requisição, 200, 404 e registros;
- adicionada fonte NestJS equivalente com `package.json`, TypeScript e configuração CLI;
- Módulo 5 integrado à navegação lateral e à página inicial;
- resumo atualizado para quatro módulos concluídos, um em andamento e 32 de 38 aulas;
- Aula 5.2 criada com módulos, controllers, providers, tokens, escopos e DI;
- laboratório 5.2 criado com grafo do contêiner, falhas de resolução e requisições;
- totais atualizados para 32 fontes, 32 páginas renderizadas e 27 laboratórios;
- próxima ação atualizada para Aula 5.3 — REST, rotas e respostas HTTP.
- Aula 5.3 criada com REST, métodos, parâmetros, status e idempotência;
- laboratório 5.3 criado com console HTTP, CRUD em memória e fluxo de roteamento;
- totais atualizados para 33 fontes, 33 páginas renderizadas e 28 laboratórios;
- próxima ação atualizada para Aula 5.4 — DTOs, pipes e validação.
- Aula 5.4 criada com DTOs, pipes, transformação, lista de permissões e validação em ambiente de execução;
- laboratório 5.4 criado com cinco etapas visíveis e comparação de políticas;
- totais atualizados para 34 fontes, 34 páginas renderizadas e 29 laboratórios;
- próxima ação atualizada para Aula 5.5 — Erros, filtros e configuração.
- Aula 5.5 criada com classificação de falhas, filter global, correlação e configuração;
- laboratório 5.5 criado com inicialização validada, respostas seguras e registros protegidos;
- totais atualizados para 35 fontes, 35 páginas renderizadas e 30 laboratórios;
- próxima ação atualizada para Aula 5.6 — OpenAPI e documentação.

### 31 de julho de 2026

- consolidado o contexto completo para migração entre IAs;
- registrados 20 fontes Markdown, 20 aulas renderizadas e 15 laboratórios;
- módulos 1, 2 e 3 marcados como concluídos;
- Aula 3.6 criada com testes, auditoria de README e projeto final;
- Aula 3.6 validada no navegador sem erros de console;
- Módulo 4 planejado com 10 aulas;
- Aula 4.1 criada e integrada à navegação;
- Aula 4.2 criada com lista dinâmica, bindings e control flow;
- Aula 4.3 criada com composição, inputs, outputs e fluxo pai-filho observável;
- Aula 4.4 criada com serviços, DI, escopos e comparação entre APIs Angular atuais;
- Aula 4.5 criada com Router, shell, parâmetros, histórico e página 404;
- Aula 4.6 criada com Signal Forms, Reactive Forms, validação e acessibilidade;
- Aula 4.7 criada com HttpClient, RxJS, estados, cancelamento e API simulada;
- Aula 4.8 criada com signals, computed, linkedSignal, effect e grafo reativo;
- laboratório 4.8 criado com dependências visíveis, contadores e seleção válida;
- Aula 4.9 criada com interceptors funcionais, erros, retry e retorno acessível;
- laboratório 4.9 criado com sete respostas, cadeia visual e inspeção segura;
- Aula 4.10 criada com Vitest, TestBed, HTTP testing, compilação e entrega final;
- laboratório 4.10 criado com auditoria, seis testes, compilação, score e parecer;
- Módulo 4 marcado como concluído com dez aulas;
- mapa dos 16 módulos incluído no índice, com links para os quatro concluídos e
  planejamento resumido dos módulos 5 a 16;
- Visão geral, Matriz curricular e Arquitetura técnica renderizadas em HTML;
- cards de documentos do índice alterados para abrir as páginas renderizadas;
- renderizador de documentos criado com sumário, pager e correção de links relativos;
- resumo inicial atualizado para 4 módulos concluídos e 30 de 30 aulas prontas;
- contagem acumulada do resumo automatizada a partir das seções e cartões do índice;
- totais atualizados para 30 fontes, 30 aulas renderizadas e 25 laboratórios;
- próxima ação definida como planejamento do Módulo 5 e Aula 5.1;
- documentada a decisão MySQL;
- documentados o renderizador, a navegação e o padrão pedagógico;
- registradas as limitações de Git, TypeScript e dependências locais.

---

**Regra de manutenção:** este arquivo deve acompanhar o projeto. Se o código, a
matriz, o andamento ou o próximo passo mudar, atualizar este documento na mesma
entrega.