flowingts 0.0.0 → 0.19.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 Caio Fernandes
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -1,5 +1,76 @@
-# Flowing
+# FlowingTS
 
-Framework de APIs em TypeScript com decorators, contratos por rota e o básico de produção pronto.
+Micro-framework HTTP para Node.js com **decorators nativos (TC39)**, **schema-first** e **seguro por padrão**.
 
-Esta versão `0.0.0` só reserva o nome. O projeto se chamava `sashiko`; a primeira versão funcional como `flowingts` sai em breve.
+> **Por que FlowingTS:** num projeto Express que passa por muitas mãos, cada pessoa declara rotas do seu jeito, e quem chega precisa reaprender cada pedaço. O NestJS resolve a padronização, mas traz junto uma estrutura que muitos projetos não precisam. O FlowingTS dá **uma forma só de declarar rotas**, que qualquer pessoa da equipe reconhece, com o contrato de cada rota validado como no Fastify e sem tirar a liberdade do Express. O código flui igual, não importa quem o escreveu.
+
+FlowingTS combina a flexibilidade do **Fastify** e do **Express** (middlewares simples, partes plugáveis, pouca cerimônia) com a organização em classes do **NestJS**, mantendo o núcleo pequeno: `node:http` direto e sete dependências de runtime.
+
+```ts
+import { type Context, createApp, Post, Router, type RouteSchemas, Type } from 'flowingts';
+
+const User = Type.Object({ id: Type.String(), name: Type.String() });
+const create = {
+  body: Type.Object({ name: Type.String({ minLength: 1 }) }, { additionalProperties: false }),
+  response: { 201: User },
+} satisfies RouteSchemas;
+
+@Router('/users')
+class UserRoutes {
+  @Post('/', create)
+  create(ctx: Context<typeof create>) {
+    return { id: crypto.randomUUID(), name: ctx.body.name }; // ctx.body tipado; responde 201
+  }
+}
+
+const app = createApp().mount(UserRoutes);
+await app.listen({ port: 3000 });
+```
+
+## Documentação
+
+**[code-cfernandes.github.io/flowing](https://code-cfernandes.github.io/flowing/)**
+
+|                                                                                                                                                                                                                            |                                                                            |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| [Introdução](https://code-cfernandes.github.io/flowing/guia/introducao) e [instalação](https://code-cfernandes.github.io/flowing/guia/instalacao)                                                                          | Princípios, requisitos e o primeiro app                                    |
+| [Rotas e composição](https://code-cfernandes.github.io/flowing/guia/rotas)                                                                                                                                                 | `@Router`, `app.mount()`, `app.group()`, virtual hosts e mapeamento manual |
+| [Schemas](https://code-cfernandes.github.io/flowing/guia/schemas) e [respostas](https://code-cfernandes.github.io/flowing/guia/respostas)                                                                                  | Validação, serialização, tipos do `ctx` e outros formatos                  |
+| [Middlewares e guards](https://code-cfernandes.github.io/flowing/guia/middlewares-e-guards), [hooks](https://code-cfernandes.github.io/flowing/guia/hooks) e [erros](https://code-cfernandes.github.io/flowing/guia/erros) | O pipeline da requisição                                                   |
+| [Estáticos e streaming](https://code-cfernandes.github.io/flowing/guia/estaticos-e-streaming)                                                                                                                              | Arquivos, SSE, NDJSON e `ctx.signal`                                       |
+| [OpenAPI](https://code-cfernandes.github.io/flowing/guia/openapi), [logs](https://code-cfernandes.github.io/flowing/guia/logs) e [observabilidade](https://code-cfernandes.github.io/flowing/guia/observabilidade)         | Documentação da API, logs correlacionados e OpenTelemetry                  |
+| [Segurança](https://code-cfernandes.github.io/flowing/guia/seguranca), [ciclo de vida](https://code-cfernandes.github.io/flowing/guia/ciclo-de-vida) e [deploy](https://code-cfernandes.github.io/flowing/guia/deploy)     | Defaults seguros, HTTPS, healthchecks, shutdown e produção                 |
+| [Referência](https://code-cfernandes.github.io/flowing/referencia/create-app)                                                                                                                                              | `createApp(options)` e a API completa, gerada do código                    |
+
+## Instalação
+
+- **Node.js 22+**
+- **TypeScript 5.2+**, com decorators **padrão**. **Não** use `experimentalDecorators` nem `emitDecoratorMetadata`: se estiverem ligados, o FlowingTS lança um erro dizendo como corrigir. Por isso ele não convive no mesmo projeto com bibliotecas que exigem decorators legados (NestJS, TypeORM…).
+- ESM (`"type": "module"`).
+
+```bash
+pnpm add flowingts
+```
+
+O `tsconfig.json` mínimo e os detalhes estão em [Instalação](https://code-cfernandes.github.io/flowing/guia/instalacao).
+
+## Desenvolvimento
+
+```bash
+pnpm install
+pnpm test            # node:test + tsx
+pnpm test:coverage   # com limites mínimos de cobertura
+pnpm typecheck
+pnpm check           # lint + formatação (Biome); pnpm format corrige a formatação
+pnpm build           # dist/
+```
+
+Para o `git blame` ignorar o commit de formatação: `git config blame.ignoreRevsFile .git-blame-ignore-revs`.
+
+**Publicação:** um push de tag de versão (`git tag v1.2.3 && git push origin v1.2.3`) dispara o workflow `release.yml`. Ele confere que a tag bate com o `package.json`, que o commit está na `main` e que o CHANGELOG tem a seção da versão. Depois roda as mesmas verificações do CI e envia o pacote ao npm em estágio, por Trusted Publishing, sem token e com provenance, além de criar a GitHub Release com as notas do CHANGELOG. A versão só fica pública depois da aprovação no npmjs.com, com o 2FA da conta.
+
+Mudanças notáveis estão no [CHANGELOG](CHANGELOG.md). Para reportar uma vulnerabilidade e conhecer a política de dependências, veja o [SECURITY.md](SECURITY.md).
+
+## Licença
+
+[ISC](LICENSE)

package/dist/core/abort.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Etapa em que a requisição estava quando um erro chegou ao `onError` (F-38). No modelo onion, um erro
+ * lançado depois do `await next()` de um middleware aparece com a etapa mais recente (`handler`, `response`).
+ * `validation` inclui a leitura do body (JSON inválido, limite de tamanho).
+ */
+export type ErrorPhase = 'middleware' | 'guard' | 'validation' | 'handler' | 'response';
+/** Por que o `ctx.signal` de uma requisição foi cancelado (F-38). */
+export type AbortCode = 'CLIENT_DISCONNECTED' | 'SHUTDOWN' | 'TIMEOUT';
+/**
+ * O `ctx.signal.reason` de uma requisição cancelada. Use o `code` para decidir em código:
+ *
+ * ```ts
+ * if (ctx.signal.reason?.code === 'SHUTDOWN') return; // o app está encerrando, não é erro
+ * ```
+ *
+ * `TIMEOUT` está reservado para um futuro timeout por rota.
+ */
+export declare class RequestAbortedError extends Error {
+    readonly code: AbortCode;
+    readonly name = "RequestAbortedError";
+    constructor(code: AbortCode);
+}
+//# sourceMappingURL=abort.d.ts.map

package/dist/core/abort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort.d.ts","sourceRoot":"","sources":["../../src/core/abort.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,OAAO,GAAG,YAAY,GAAG,SAAS,GAAG,UAAU,CAAC;AAExF,qEAAqE;AACrE,MAAM,MAAM,SAAS,GAAG,qBAAqB,GAAG,UAAU,GAAG,SAAS,CAAC;AAQvE;;;;;;;;GAQG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAEhC,QAAQ,CAAC,IAAI,EAAE,SAAS;IADpC,SAAkB,IAAI,yBAAyB;IAC/C,YAAqB,IAAI,EAAE,SAAS,EAEnC;CACF"}

package/dist/core/abort.js

@@ -0,0 +1,23 @@
+const MESSAGES = {
+    CLIENT_DISCONNECTED: 'client disconnected',
+    SHUTDOWN: 'server shutting down',
+    TIMEOUT: 'request timed out',
+};
+/**
+ * O `ctx.signal.reason` de uma requisição cancelada. Use o `code` para decidir em código:
+ *
+ * ```ts
+ * if (ctx.signal.reason?.code === 'SHUTDOWN') return; // o app está encerrando, não é erro
+ * ```
+ *
+ * `TIMEOUT` está reservado para um futuro timeout por rota.
+ */
+export class RequestAbortedError extends Error {
+    code;
+    name = 'RequestAbortedError';
+    constructor(code) {
+        super(MESSAGES[code]);
+        this.code = code;
+    }
+}
+//# sourceMappingURL=abort.js.map

package/dist/core/abort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort.js","sourceRoot":"","sources":["../../src/core/abort.ts"],"names":[],"mappings":"AAUA,MAAM,QAAQ,GAA8B;IAC1C,mBAAmB,EAAE,qBAAqB;IAC1C,QAAQ,EAAE,sBAAsB;IAChC,OAAO,EAAE,mBAAmB;CAC7B,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAEvB,IAAI;IADP,IAAI,GAAG,qBAAqB,CAAC;IAC/C,YAAqB,IAAe;QAClC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;oBADH,IAAI;IAEzB,CAAC;CACF"}

package/dist/core/app/core.d.ts

@@ -0,0 +1,35 @@
+import type { UploadSettings } from '../uploads/receive.ts';
+import type http from 'node:http';
+import type { Middleware } from '../compose.ts';
+import type { OnSendHook } from '../context.ts';
+import type { Logger } from '../logger.ts';
+import type { Telemetry } from '../telemetry.ts';
+import type { Serializer } from '../response/pipeline.ts';
+import type { AppOptions, OnCloseHook, OnErrorHook, OnRequestHook, OnResponseHook } from './options.ts';
+import type { Contracts } from '../contracts.ts';
+/**
+ * Estado compartilhado do app entre a fachada (`FlowingApp`) e os componentes internos (registro,
+ * servidor, pipeline da requisição). Só configuração e listas de hooks; nada por requisição.
+ */
+export interface AppCore {
+    readonly opts: AppOptions;
+    readonly log: Logger;
+    readonly middlewares: Middleware[];
+    readonly errorHandlers: OnErrorHook[];
+    readonly onSendHooks: OnSendHook[];
+    readonly onRequestHooks: OnRequestHook[];
+    /** O motor dos contratos (F-27): o do app, ou o nativo. */
+    readonly contracts: Contracts;
+    /** OpenTelemetry, quando `createApp({ telemetry })` (F-38). */
+    readonly telemetry: Telemetry | undefined;
+    readonly onResponseHooks: OnResponseHook[];
+    /** Rotas com `onResponse` de escopo (F-43): basta uma para o observer acompanhar o fim das requisições. */
+    scopedOnResponse: number;
+    readonly onCloseHooks: OnCloseHook[];
+    readonly serializers: ReadonlyMap<string, Serializer>;
+    /** Configuração de upload (F-46), resolvida na criação do app. */
+    readonly uploads: UploadSettings;
+    readonly allowedHosts: ((hostname: string, host: string) => boolean) | undefined;
+    readonly applySecurityHeaders: ((res: http.ServerResponse) => void) | undefined;
+}
+//# sourceMappingURL=core.d.ts.map

package/dist/core/app/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/core/app/core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACxG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,WAAW,EAAE,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,CAAC;IACnC,QAAQ,CAAC,cAAc,EAAE,aAAa,EAAE,CAAC;IACzC,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,eAAe,EAAE,cAAc,EAAE,CAAC;IAC3C,2GAA2G;IAC3G,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,WAAW,EAAE,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACtD,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;IACjF,QAAQ,CAAC,oBAAoB,EAAE,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CACjF"}

package/dist/core/app/core.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=core.js.map

package/dist/core/app/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/core/app/core.ts"],"names":[],"mappings":""}

package/dist/core/app/options.d.ts

@@ -0,0 +1,178 @@
+import type { UploadsOptions } from '../uploads/types.ts';
+import type { AbortCode, ErrorPhase } from '../abort.ts';
+import type { TelemetryApi } from '../telemetry.ts';
+import type { Context } from '../context.ts';
+import type { RouteInfo } from '../route-table.ts';
+import type { ErrorFormatter } from '../errors.ts';
+import type { Logger } from '../logger.ts';
+import type { Serializer } from '../response/pipeline.ts';
+import type { ShutdownOptions } from '../shutdown.ts';
+import type { TlsOptions } from '../../server/tls.ts';
+import type { ProtoPoisoning } from '../../utils/safe-json.ts';
+import type { SecurityHeadersOptions, SecurityPreset } from '../../middlewares/security-headers.ts';
+import type { QueryParser } from '../../utils/query.ts';
+import type { BodyParser } from '../body-parser.ts';
+import type { Contracts } from '../contracts.ts';
+/**
+ * Tratamento de erros (F-04). `phase` diz em que etapa a requisição estava: `middleware`, `guard`,
+ * `validation` (inclui a leitura do body), `handler` ou `response`.
+ */
+export type OnErrorHook = (err: unknown, ctx: Context, phase: ErrorPhase) => void | Promise<void>;
+/** Como a requisição terminou, no `onResponse` (F-04, F-38). */
+export interface ResponseInfo {
+    /** Status enviado (num cancelamento, o que estava definido quando a conexão caiu). */
+    status: number;
+    /** Duração total em milissegundos, até o fim da resposta ou o cancelamento. */
+    ms: number;
+    /** `completed`, `aborted` (cancelada antes do fim) ou `error` (respondida com 5xx). */
+    outcome: 'completed' | 'aborted' | 'error';
+    /** Por que foi cancelada, quando `outcome` é `aborted`. */
+    abortReason?: AbortCode;
+    /**
+     * Milissegundos até os headers saírem. Em SSE e NDJSON, é a latência real; `ms` mede a conexão inteira.
+     * Medido nos servidores do `listen()` e no `inject()`; ausente num servidor próprio (`callback()`).
+     */
+    ttfbMs?: number;
+    /** Resposta em stream: SSE, NDJSON, `Readable` ou arquivo. */
+    streaming: boolean;
+    /** A rota que atendeu; ausente em 404, 405, healthcheck e OpenAPI. */
+    route?: RouteInfo;
+    /** O erro lançado, quando a resposta veio do tratamento de erros. */
+    error?: unknown;
+    /** A etapa em que o erro chegou (a mesma do 3º argumento do `onError`). */
+    errorPhase?: ErrorPhase;
+}
+/**
+ * Depois que a requisição termina (F-04). Roda **exatamente uma vez** por requisição, em todos os caminhos:
+ * sucesso, erro, 404/405, `Host` inválido, cancelamento pelo cliente, shutdown, streams e `inject()`.
+ */
+export type OnResponseHook = (ctx: Context, info: ResponseInfo) => void | Promise<void>;
+/**
+ * No início de cada requisição, antes da validação do `Host` e de qualquer middleware (F-38). É síncrono:
+ * uma Promise devolvida não é esperada. Erros são logados e não interrompem a requisição.
+ */
+export type OnRequestHook = (ctx: Context) => void;
+/** No `close()` do app (F-04). */
+export type OnCloseHook = () => void | Promise<void>;
+export interface ListenOptions {
+    /** Padrão: 3000. Use 0 para uma porta livre aleatória. */
+    port?: number;
+    /** Padrão: `127.0.0.1`. Use `0.0.0.0` para aceitar conexões externas (ex.: em containers). */
+    host?: string;
+    /**
+     * Sobe em HTTPS, com os mesmos timeouts, encerramento gracioso e `close()` do HTTP. Atrás de um
+     * proxy que termina o TLS (Caddy, Nginx, load balancer), não use: fique em HTTP com `trustProxy`.
+     */
+    tls?: TlsOptions;
+}
+export interface ServerTimeouts {
+    /** Tempo máximo para receber a requisição inteira. Padrão: 30s. */
+    requestTimeout?: number;
+    /** Tempo máximo para receber os headers (mitiga Slowloris). Padrão: 10s. */
+    headersTimeout?: number;
+    /** Tempo de conexão keep-alive ociosa. Padrão: 5s. */
+    keepAliveTimeout?: number;
+}
+export interface AppOptions {
+    /**
+     * OpenTelemetry nativo (F-38): passe o `@opentelemetry/api` que a aplicação usa (`import * as otel`).
+     * Enriquece o span da auto-instrumentação HTTP (ou cria o span SERVER, se não houver), com o template da
+     * rota e os erros com a fase, e gera as métricas HTTP. Sem esta opção, nada é carregado.
+     */
+    telemetry?: TelemetryApi;
+    /** Tamanho máximo do body JSON em bytes. Padrão: 1 MiB. */
+    bodyLimit?: number;
+    /**
+     * Headers de segurança aplicados a toda resposta (S-04). Padrão: `'api'`.
+     * `'web'` libera recursos do próprio site (CSP `'self'`) para quem serve páginas; `false` desliga.
+     */
+    securityHeaders?: SecurityHeadersOptions | SecurityPreset | false;
+    /**
+     * Serializadores por content type, para responder em outros formatos (F-31):
+     * `{ 'application/yaml': (data) => YAML.stringify(data) }`. JSON e valores crus já são nativos.
+     */
+    serializers?: Record<string, Serializer>;
+    /** Upload de arquivos (F-46): limites globais, pasta dos temporários e detector de conteúdo. */
+    uploads?: UploadsOptions;
+    /** Timeouts do servidor HTTP (S-06). */
+    timeouts?: ServerTimeouts;
+    /**
+     * Modo estrito (S-07): exige schema de `body` em POST/PUT/PATCH e schema de `response`
+     * em toda rota, falhando no `app.mount()`. Padrão: `false`.
+     */
+    requireSchemas?: boolean;
+    /**
+     * Body JSON com `__proto__` ou `constructor.prototype` (S-08): `'error'` responde 400
+     * (`PROTO_POISONING`); `'remove'` descarta as chaves e segue. Padrão: `'error'`.
+     */
+    protoPoisoning?: ProtoPoisoning;
+    /** Máximo de pares chave/valor lidos da query string. Padrão: 1000 (S-06). */
+    queryMaxKeys?: number;
+    /**
+     * Parser de query próprio (F-26), para sintaxes aninhadas como `?filter[status]=ativo`:
+     * `createApp({ queryParser: (raw) => qs.parse(raw, { depth: 3, arrayLimit: 50, parameterLimit: 1000 }) })`.
+     * O retorno passa pelo filtro de chaves perigosas; se o parser lançar, a resposta é 400. Os limites ficam com o
+     * parser: o `queryMaxKeys` vale só para o padrão.
+     */
+    queryParser?: QueryParser;
+    /**
+     * O motor dos contratos das rotas (F-27), um para o app inteiro. Sem a opção, `contracts.native()` (schemas
+     * TypeBox). Para Zod, Valibot ou ArkType: `contracts.standard()`. Um schema de outro motor é recusado no registro.
+     */
+    contracts?: Contracts;
+    /**
+     * Parsers de body por tipo de mídia (F-12), além do JSON nativo:
+     * `createApp({ parsers: { 'application/yaml': (raw) => YAML.parse(raw.toString('utf8')) } })`.
+     * O `bodyLimit` e a proteção contra prototype pollution valem para todos, e o contrato da rota valida o resultado.
+     * Atenção: tipos que o navegador envia sem preflight (`application/x-www-form-urlencoded`, `text/plain`) abrem
+     * espaço para CSRF; use o `csrf()` em rotas com sessão por cookie.
+     */
+    parsers?: Readonly<Record<string, BodyParser>>;
+    /** Logger compatível com pino. Padrão: `consoleLogger()`; `false` desliga (F-06). */
+    logger?: Logger | false;
+    /** Loga cada requisição concluída (método, path, status, duração) em nível `info`. Padrão: `false`. */
+    logRequests?: boolean;
+    /** Request id (F-06). */
+    requestId?: RequestIdOptions;
+    /**
+     * Encerramento gracioso nos sinais do processo, ativado pelo `listen()` (F-07).
+     * Ligado por padrão (SIGINT/SIGTERM, 10s); `false` desliga.
+     */
+    shutdown?: ShutdownOptions | false;
+    /**
+     * Confia nos headers `X-Forwarded-For`, `-Host` e `-Proto` para `ctx.ip`, `ctx.host` e `ctx.protocol`
+     * (S-09). Padrão: `false`. Use `true` para confiar em toda a cadeia, ou o número de proxies à frente
+     * do app (ex.: `1` para um load balancer). Só ligue atrás de um proxy que reescreve esses headers.
+     */
+    trustProxy?: boolean | number;
+    /**
+     * Hosts aceitos (S-09). Requisições com outro `Host` (ou `X-Forwarded-Host` confiável) recebem 400.
+     * Protege contra host header injection e DNS rebinding. Padrão: qualquer host válido.
+     * - `'api.exemplo.com'` casa com o hostname (qualquer porta); `'api.exemplo.com:8443'` exige a porta;
+     * - `'*.exemplo.dev'` aceita só subdomínios;
+     * - uma RegExp precisa casar o hostname **inteiro** (como se tivesse `^…$`).
+     */
+    allowedHosts?: readonly (string | RegExp)[];
+    /**
+     * Rotas com `host` (virtual hosts) fora do `allowedHosts` nunca são alcançadas (F-35). `'error'` (padrão)
+     * falha no registro; `'warn'` só registra um aviso no log; `'off'` não confere.
+     */
+    unreachableHosts?: 'error' | 'warn' | 'off';
+    /**
+     * Personaliza o corpo de todos os erros do framework e dos `HttpError` (F-15). Padrão: Problem
+     * Details (RFC 9457) em `application/problem+json`. O retorno é enviado como `application/json`.
+     */
+    formatError?: ErrorFormatter;
+}
+export interface RequestIdOptions {
+    /** Header lido da requisição e devolvido na resposta. Padrão: `x-request-id`. `false` não envia. */
+    header?: string | false;
+    /**
+     * Reaproveita o id recebido no header (útil atrás de um gateway). Padrão: `true`.
+     * O valor só é aceito se tiver até 128 caracteres de `[A-Za-z0-9._:-]`, para evitar log injection.
+     */
+    trustIncoming?: boolean;
+    /** Gerador de ids. Padrão: `crypto.randomUUID()`. */
+    generate?: () => string;
+}
+//# sourceMappingURL=options.d.ts.map

package/dist/core/app/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/core/app/options.ts"],"names":[],"mappings":"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"}

package/dist/core/app/options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=options.js.map

package/dist/core/app/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../src/core/app/options.ts"],"names":[],"mappings":""}

package/dist/core/app.d.ts

@@ -0,0 +1,143 @@
+import type http from 'node:http';
+import type https from 'node:https';
+import '../shims/symbol-metadata.ts';
+import type { TlsOptions } from '../server/tls.ts';
+import { type GroupOptions, type MountOptions, type RouteScope, type RouterRef } from './compiler.ts';
+import { MountedGroup, RouteGroupScope } from './mounted-group.ts';
+import type { Middleware } from './compose.ts';
+import type { Context, OnSendHook } from './context.ts';
+import { type StaticOptions } from '../server/static.ts';
+import { type OpenAPIOptions } from '../openapi/generate.ts';
+import { type HealthOptions } from './health.ts';
+import { type InjectOptions, type InjectResponse } from './inject.ts';
+import { type Logger } from './logger.ts';
+import type { AppOptions, ListenOptions, OnCloseHook, OnErrorHook, OnRequestHook, OnResponseHook } from './app/options.ts';
+export type { AppOptions, ListenOptions, OnCloseHook, OnErrorHook, OnRequestHook, OnResponseHook, RequestIdOptions, ResponseInfo, ServerTimeouts, } from './app/options.ts';
+/**
+ * O app. É uma fachada (Facade) sobre o registro de rotas, as rotas do próprio framework (health, OpenAPI),
+ * o servidor e o pipeline da requisição: a API pública fica aqui, e o trabalho fica nesses componentes.
+ */
+export declare class FlowingApp {
+    readonly log: Logger;
+    private readonly core;
+    private readonly registry;
+    private readonly framework;
+    private readonly runtime;
+    private readonly requests;
+    constructor(opts?: AppOptions);
+    use(mw: Middleware): this;
+    onError(h: OnErrorHook): this;
+    /**
+     * Roda imediatamente antes de escrever uma resposta com corpo (exceto streams), inclusive em erros
+     * e 404. É síncrono: pode alterar headers (ETag, assinatura) ou devolver `{ body, contentType }`
+     * novos. Se lançar, o erro é logado e a resposta original é enviada (F-04).
+     */
+    onSend(hook: OnSendHook): this;
+    /**
+     * Roda no início de cada requisição, antes da validação do `Host` e dos middlewares: abrir um span, contar
+     * requisições ativas. Toda requisição que passa por aqui também passa pelo `onResponse`. É síncrono; erros
+     * são só logados (F-38).
+     */
+    onRequest(hook: OnRequestHook): this;
+    /**
+     * Roda exatamente uma vez quando a requisição termina, com status, duração, `outcome` (`completed`,
+     * `aborted`, `error`), motivo do cancelamento, tempo até os headers, rota e se foi stream: métricas,
+     * tracing, auditoria. Pode ser assíncrono; erros são só logados (F-04, F-38).
+     */
+    onResponse(hook: OnResponseHook): this;
+    /**
+     * Roda no `close()`, depois que o servidor fecha, qualquer que seja a origem (sinal, teste, código),
+     * e antes do `shutdown.onShutdown`. Erros são logados e fazem o `close()` rejeitar ao final (F-04).
+     */
+    onClose(hook: OnCloseHook): this;
+    /**
+     * Registra uma classe com `@Router` (F-28). Aceita a classe (construtor sem argumentos) ou uma
+     * instância pronta (B-10), e opções aplicadas no ponto de composição:
+     *
+     * ```ts
+     * app
+     *   .mount(HealthRoutes)
+     *   .mount(new UserRoutes(repo), { prefix: '/v2/users', middlewares: [auth], except: (r) => [r.remove] })
+     *   .get('/legacy/:id', (r) => r.getUser);      // mapeamento manual (F-30)
+     * ```
+     */
+    mount<T extends object>(ref: new () => T, options?: MountOptions<T>): MountedGroup<T>;
+    mount<T extends object>(ref: T extends abstract new (...args: never) => unknown ? never : T, options?: MountOptions<T>): MountedGroup<T>;
+    /**
+     * Agrupa `mount()`s sob um prefixo, middlewares e guards comuns. Não é um container: é só composição,
+     * com a mesma semântica do `mount()`. Grupos podem ser aninhados.
+     *
+     * ```ts
+     * app.group({ prefix: '/v2', middlewares: [authenticate], guards: [isAdmin] }, (g) =>
+     *   g.mount(UserRoutes).mount(new OrderRoutes(db)),
+     * );
+     * ```
+     * Ordem de execução: middlewares dos grupos (de fora para dentro) → do `mount()` → da classe → do método.
+     */
+    group(options: GroupOptions, define: (group: RouteGroupScope) => unknown): this;
+    /** @internal */
+    groupIn(parent: RouteScope, options: GroupOptions, define: (group: RouteGroupScope) => unknown): void;
+    /**
+     * Serve os arquivos de `root` em `GET prefix/*` (F-13). É uma rota como as outras: vale `group()`
+     * (host, guards, middlewares), 404/405 e a checagem de conflitos. Não entra no OpenAPI.
+     *
+     * ```ts
+     * app.static('/assets', './public', { maxAge: '7d', immutable: true });
+     * app.static('/', './dist', { fallback: 'index.html' }); // SPA
+     * ```
+     * Caminhos que saem da raiz (`..`, symlinks), arquivos ocultos e diretórios sem índice respondem 404.
+     */
+    static(prefix: string, root: string, opts?: StaticOptions): this;
+    /** @internal */
+    staticIn(scope: RouteScope, prefix: string, root: string, opts: StaticOptions): void;
+    /** @internal */
+    mountIn(scope: RouteScope, ref: RouterRef, options?: MountOptions): MountedGroup<object>;
+    /**
+     * Serve o documento OpenAPI 3.1 gerado das rotas (`/openapi.json`) e, com `docs`, o Swagger UI (F-16).
+     * As duas rotas passam pelos middlewares globais e pelos `middlewares`/`guards` informados aqui:
+     * `app.openapi({ guards: [isAdmin] })`. O documento é gerado na primeira requisição, depois dos `mount()`.
+     */
+    openapi(opts?: OpenAPIOptions): this;
+    /**
+     * Healthchecks para load balancers e orquestradores (Kubernetes, ECS…).
+     * - `GET /livez`: o processo está de pé (200 sempre).
+     * - `GET /readyz`: pronto para receber tráfego. Roda os `checks` (banco, fila…) e responde 503 se algum
+     *   falhar ou estourar o tempo, e também durante o encerramento.
+     *
+     * As rotas são servidas **antes** dos middlewares globais (sondas não têm credenciais nem devem
+     * consumir rate limit); use `guards`/`middlewares` aqui para restringir.
+     */
+    health(opts?: HealthOptions): this;
+    /**
+     * Documento OpenAPI 3.1 das rotas registradas até agora, para gravar em arquivo ou testar (F-16).
+     * Com virtual hosts, é por host (F-35): `{ host: 'api.exemplo.com' }` traz as rotas desse host e as sem
+     * host; sem `host`, só as sem host. Domínios diferentes nunca se misturam num mesmo documento.
+     */
+    openapiDocument(opts?: OpenAPIOptions): Record<string, unknown>;
+    /** Executa o pipeline completo para um contexto já criado. */
+    handle(ctx: Context): Promise<void>;
+    /**
+     * Listener `(req, res)` do app, para usar com qualquer servidor do Node:
+     * `https.createServer(opts, app.callback())`, `http2` em modo compat, testes etc. (F-09).
+     */
+    callback(): (req: http.IncomingMessage, res: http.ServerResponse) => void;
+    /** Sobe o servidor HTTP (ou HTTPS, com `tls`) e resolve quando ele está aceitando conexões (F-09, F-33). */
+    listen(options: ListenOptions & {
+        tls: TlsOptions;
+    }): Promise<https.Server>;
+    listen(options?: number | ListenOptions): Promise<http.Server>;
+    /**
+     * Troca os certificados sem reiniciar nem derrubar conexões (renovação, ACME externo). Conexões novas
+     * usam os novos; as abertas seguem com os antigos. Um certificado inválido lança erro e mantém os atuais.
+     */
+    reloadTLS(tls: TlsOptions): void;
+    /**
+     * Para de aceitar conexões, encerra as ociosas e espera as requisições em andamento terminarem.
+     * Depois de `graceMs`, força o fechamento das restantes.
+     */
+    close(graceMs?: number): Promise<void>;
+    /** Executa uma requisição em memória, sem rede. Ideal para testes (F-09). */
+    inject(opts: InjectOptions | string): Promise<InjectResponse>;
+}
+export declare function createApp(opts?: AppOptions): FlowingApp;
+//# sourceMappingURL=app.d.ts.map

package/dist/core/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../src/core/app.ts"],"names":[],"mappings":"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"}