@nodefony/http 10.0.0-beta.3 → 10.0.0-beta.4

package/docs/sse.md

@@ -70,12 +70,12 @@ ce que fait une porte MCP.
 >
 > Ce plafond vaut pour l'origine que **voit le navigateur**. Derrière nginx, HAProxy ou un
 > ingress qui termine le TLS, cette origine est le proxy : c'est **lui** qui doit servir HTTP/2,
-> et `proxy:generate` le pose déjà (`http2 on`, `generateProxyConfig.ts:270`). Nodefony reçoit
-> alors du HTTP/1.1 (`proxy_http_version 1.1`, `generateProxyConfig.ts:351`) — y activer HTTP/2
+> et `proxy:generate` le pose déjà (`http2 on`, `generateProxyConfig.ts#nginxServerBlock`). Nodefony reçoit
+> alors du HTTP/1.1 (`proxy_http_version 1.1`, `generateProxyConfig.ts#nginxServerBlock`) — y activer HTTP/2
 > n'y change rien. Sans proxy, c'est Nodefony qui sert HTTP/2.
 >
 > De chaque côté du proxy, un flux est une connexion qui se tait entre deux événements. Le
-> battement (`SSE_HEARTBEAT_MS`, 15 s, `SseStream.ts:77`) la garde vivante ; le délai
+> battement (`SSE_HEARTBEAT_MS`, 15 s, `SseStream.ts#SSE_HEARTBEAT_MS`) la garde vivante ; le délai
 > d'inactivité généré (300 s au moins) en tient vingt. Le seul piège réel : une action qui éteint
 > le battement (`heartbeat: false`) et se tait plus longtemps que ce délai se fait couper par le
 > proxy. Le guide [reverse-proxy](../../../../../docs/guides/reverse-proxy.md) détaille le reste.
@@ -142,23 +142,27 @@ data: {"step":"écriture"}
 
 - Les en-têtes partent dès `renderSse()` : `Content-Type: text/event-stream; charset=utf-8`,
   `Cache-Control: no-cache, no-transform`, `X-Accel-Buffering: no` (`openSseStream()`,
-  `SseStream.ts:427`).
+  `SseStream.ts#openSseStream`). Ce dernier demande à un proxy de type nginx de ne pas garder le
+  flux en tampon. À travers le frontal que génère `nodefony proxy:generate nginx`, chaque
+  événement arrive à son émission — mesuré par le scénario `edge` du banc de publication. La même
+  mesure, en-tête retiré, reste étalée sur nginx 1.30 : l'en-tête n'y est pas ce qui tient le
+  flux, il protège les proxys qui retiennent.
 - `await sse.send()` freine l'action si le client lit lentement — c'est la contre-pression.
 
 ## ⚙️ Les deux bouts de l'API
 
 ### Côté serveur — `this.renderSse()` et l'objet `SseStream`
 
-| Membre                          | Rôle                                                                                               |
-| ------------------------------- | -------------------------------------------------------------------------------------------------- |
-| `this.renderSse(options?)`      | ouvre le flux (`Controller.renderSse()`, `Controller.ts:665`) ; lève sur WebSocket                 |
-| `this.acceptsSse()`             | le client a-t-il demandé `text/event-stream` ? (`Controller.acceptsSse()`, `Controller.ts:649`)    |
-| `sse.send(data, { event, id })` | un événement ; texte tel quel, objet en JSON (`SseStream.send()`, `SseStream.ts:260`)              |
-| `sse.comment(text)`             | un commentaire, ignoré par le client                                                               |
-| `sse.retry(ms)`                 | impose le délai de reconnexion du client                                                           |
-| `sse.onClose(fn)`               | appelé à la fermeture, quel que soit le bout qui ferme (`SseStream.onClose()`, `SseStream.ts:306`) |
-| `sse.close()`                   | termine la requête, idempotent (`SseStream.close()`, `SseStream.ts:321`)                           |
-| `sse.closed`                    | le flux est-il fermé — à tester dans une boucle longue                                             |
+| Membre                          | Rôle                                                                                                              |
+| ------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `this.renderSse(options?)`      | ouvre le flux (`Controller.renderSse()`, `Controller.ts#Controller.renderSse`) ; lève sur WebSocket               |
+| `this.acceptsSse()`             | le client a-t-il demandé `text/event-stream` ? (`Controller.acceptsSse()`, `Controller.ts#Controller.acceptsSse`) |
+| `sse.send(data, { event, id })` | un événement ; texte tel quel, objet en JSON (`SseStream.send()`, `SseStream.ts#SseStream.send`)                  |
+| `sse.comment(text)`             | un commentaire, ignoré par le client                                                                              |
+| `sse.retry(ms)`                 | impose le délai de reconnexion du client                                                                          |
+| `sse.onClose(fn)`               | appelé à la fermeture, quel que soit le bout qui ferme (`SseStream.onClose()`, `SseStream.ts#SseStream.onClose`)  |
+| `sse.close()`                   | termine la requête, idempotent (`SseStream.close()`, `SseStream.ts#SseStream.close`)                              |
+| `sse.closed`                    | le flux est-il fermé — à tester dans une boucle longue                                                            |
 
 Options de `renderSse()` :
 
@@ -185,13 +189,13 @@ async runTask() {
 }
 ```
 
-`acceptsEventStream()` (`SseStream.ts:395`) ne retient `text/event-stream` que **nommé** avec un
+`acceptsEventStream()` (`SseStream.ts#acceptsEventStream`) ne retient `text/event-stream` que **nommé** avec un
 poids non nul : `*/*` ne suffit pas — un client qui ne nomme pas le flux ne sait pas le lire —, et
 `q=0` est un refus (RFC 9110 §12.4.2).
 
 ### Côté client — `NodefonySse`
 
-`NodefonySse` (`NodefonySse.ts:110`) reprend le vocabulaire d'`EventSource` — `onopen`,
+`NodefonySse` (`NodefonySse.ts#NodefonySse`) reprend le vocabulaire d'`EventSource` — `onopen`,
 `onmessage`, `onerror`, `addEventListener(type)`, `readyState`, `lastEventId`, `close()`,
 reconnexion avec `Last-Event-ID` — et ajoute ce que le natif refuse : `method`, `headers` (un
 `Authorization: Bearer`), `body`. Il est bâti sur `fetch`, donc tourne aussi sous Node, où
@@ -205,7 +209,7 @@ reconnexion avec `Last-Event-ID` — et ajoute ce que le natif refuse : `method`
 | autre statut (204 compris), autre type      | `error`, `CLOSED`, **sans** reconnexion (WHATWG §9.2.3)                             |
 | événement au-delà de `maxEventSize` (4 Mi)  | `CLOSED` sans reconnexion                                                           |
 
-L'analyseur du format est `SseParser` (`SseParser.ts:61`), exporté par `nodefony/client` : c'est
+L'analyseur du format est `SseParser` (`SseParser.ts#SseParser`), exporté par `nodefony/client` : c'est
 le même qui relit le flux dans les tests du serveur.
 
 ## 🏗️ Architecture interne — ce que fait l'ouverture
@@ -213,20 +217,20 @@ le même qui relit le flux dans les tests du serveur.
 1. **La réponse est prise** (`context.sended`) : plus rien ne peut répondre à la place du flux.
 2. **La session est sauvée** s'il y en a une — ses cookies partent avec les en-têtes.
 3. **Le transport se constate** : flux HTTP/2, ou réponse HTTP/1.1 ; ni l'un ni l'autre → 500,
-   avant d'avoir rien écrit (`startSseStream()`, `SseStream.ts:485`).
+   avant d'avoir rien écrit (`startSseStream()`, `SseStream.ts#startSseStream`).
 4. **Les en-têtes partent** — `respond()` en HTTP/2, `flushHeaders()` en HTTP/1.1 — et le délai
    d'inactivité de la requête est **désarmé** : sans cela, le flux vivant prendrait un 408 au bout
    de 30 s.
 5. **Le battement démarre** sur un minuteur `unref()`.
 
-La fin, quel que soit le bout qui ferme, passe par **un seul** nettoyage (`SseStream.ts:254`) :
+La fin, quel que soit le bout qui ferme, passe par **un seul** nettoyage (`SseStream.ts#SseStream.send`) :
 minuteur arrêté, écouteurs `close` et `drain` retirés, attente de `drain` libérée, puis les
 écouteurs `onClose`.
 
 ## 🔐 Sécurité
 
 - **Injection de flux** : `event` et `id` sont refusés s'ils contiennent CR, LF ou NUL
-  (`singleLine()`, `SseStream.ts:105`) — une valeur venue d'un utilisateur ne peut pas clore
+  (`singleLine()`, `SseStream.ts#singleLine`) — une valeur venue d'un utilisateur ne peut pas clore
   l'événement pour en forger un autre. Les `data` sur plusieurs lignes sont découpés en autant de
   champs, jamais recopiés tels quels.
 - **Client** : un serveur qui n'envoie jamais de fin de ligne ferait grossir la mémoire du client

package/docs/upload.md

@@ -42,7 +42,7 @@ coverageFiles: context/http/Request.ts,context/http/parser.ts,service/upload/upl
 
 Le corps d'une requête n'est **jamais** interprété par le serveur ni par le routeur : c'est
 `HttpRequest` qui, selon le `Content-Type`, choisit **un** parser et remplit deux emplacements que ton
-contrôleur consomme — `queryPost` (les champs) et `queryFile` (les fichiers).
+contrôleur consomme — `body` (les champs) et `files` (les fichiers).
 
 ```mermaid
 flowchart TD
@@ -51,21 +51,25 @@ flowchart TD
   RT -->|"x-www-form-urlencoded"| Q["ParserQs"]
   RT -->|"application/xml · text/xml"| X["ParserXml"]
   RT -->|"multipart/form-data"| M["busboy → disque (temp)"]
-  RT -->|"autre / brut"| B["Parser brut"]
-  J --> QP["queryPost<br/>@Body() · this.queryPost"]
+  RT -->|"text/* · autre · sans Content-Type"| B["ParserRaw"]
+  J --> QP["body<br/>@Body() · this.body"]
   Q --> QP
   X --> QP
-  M --> QF["queryFile<br/>@UploadedFiles() · this.queryFile"]
+  M --> QF["files<br/>@UploadedFiles() · this.files"]
   M --> QP
-  B --> DATA["request.data (Buffer)"]
+  B --> RAW["body : chaîne (text/*)<br/>ou octets Uint8Array (le reste)"]
 ```
 
 Trois idées portent tout le reste :
 
-1. **Le `Content-Type` décide, pas la méthode.** `parseRequest()` (`context/http/Request.ts:502`)
-   aiguille vers `ParserJson` / `ParserQs` / `ParserXml` / **busboy** / parser brut selon l'en-tête.
+1. **Le `Content-Type` décide, pas la méthode.** `parseRequest()` (`context/http/Request.ts#HttpRequest.parseRequest`)
+   aiguille vers `ParserJson` / `ParserQs` / `ParserXml` / **busboy** / `ParserRaw` selon l'en-tête.
+   Ce dernier livre un corps qu'il ne décode pas **tel qu'il est reçu** : une chaîne pour `text/*`
+   (au `charset` déclaré), des **octets** (`Uint8Array`, sans copie) pour tout autre type et pour un
+   corps sans `Content-Type` (RFC 9110 §8.3 → `application/octet-stream`) — jamais un `{}` qui
+   mentirait. Un corps vide laisse `body` inchangé (`context/http/parser.ts#ParserRaw`).
 2. **Seul le multipart écrit sur disque.** Les fichiers sont **streamés** au fil de l'eau vers un
-   fichier temporaire (`parseMultipart()`, `context/http/Request.ts:574`) — jamais bufferisés en RAM.
+   fichier temporaire (`parseMultipart()`, `context/http/Request.ts#HttpRequest.parseMultipart`) — jamais bufferisés en RAM.
    JSON / urlencoded / XML restent en mémoire (petits corps).
 3. **Deux budgets distincts, jamais confondus.** Le corps **non-multipart** est borné par `maxBodySize`
    (défaut **1 MiB**) ; le multipart a **ses propres** limites busboy (`maxFileSize`, `maxTotalFileSize`,
@@ -80,7 +84,7 @@ Trois idées portent tout le reste :
 | `multipart/form-data`       | Format d'un formulaire qui contient des **fichiers** : le corps est découpé en _parts_ séparées (RFC 7578).        |
 | Boundary                    | Chaîne-séparateur (`--…`) qui délimite chaque _part_ d'un corps multipart.                                         |
 | Part                        | Un bloc d'un corps multipart : soit un **champ texte** (`field`), soit un **fichier** (`file`).                    |
-| Field / File                | Champ texte (→ `queryPost`) vs fichier uploadé (→ `queryFile`), les deux issus du même corps multipart.            |
+| Field / File                | Champ texte (→ `body`) vs fichier uploadé (→ `files`), les deux issus du même corps multipart.                     |
 | busboy                      | La bibliothèque de parsing multipart **en flux** (`@fastify/busboy`) : elle lit le corps sans le charger en RAM.   |
 | Streaming (au fil de l'eau) | Écrire le fichier sur disque **pendant** sa réception, octet par octet — au lieu d'attendre le corps entier.       |
 | Fichier temporaire (temp)   | Le fichier écrit par busboy dans `uploadDir`, nommé par un UUID. Le contrôleur le déplace ou le laisse expirer.    |
@@ -99,13 +103,13 @@ Imagine un **guichet de dépôt**. Le client arrive avec une enveloppe (`Content
 formulaire à plat (JSON, urlencodé, XML) que le guichetier **recopie sur une fiche** en mémoire, soit un
 **colis** (multipart) qu'il pose **directement dans une consigne** (le disque) sans jamais le tenir à
 bout de bras. Dans les deux cas, ton contrôleur ne voit pas l'enveloppe : il reçoit la fiche
-(`queryPost`) et le bordereau de consigne (`queryFile`).
+(`body`) et le bordereau de consigne (`files`).
 
 Concrètement, la couche a quatre responsabilités, et rien d'autre :
 
 1. **Choisir le parser** d'après le `Content-Type`.
-2. **Décoder les champs** (JSON, urlencoded, XML) → `queryPost`, lus par `@Body()`.
-3. **Streamer les fichiers** multipart vers le disque, sans pic RAM → `queryFile`, lus par
+2. **Décoder les champs** (JSON, urlencoded, XML) → `body`, lus par `@Body()`.
+3. **Streamer les fichiers** multipart vers le disque, sans pic RAM → `files`, lus par
    `@UploadedFiles()`.
 4. **Borner la taille** — rejeter en `413` un corps qui menace la mémoire ou le disque.
 
@@ -117,23 +121,23 @@ Trois choix structurent l'implémentation, et chacun a une raison de sécurité
 
 **Le multipart ne touche jamais la RAM.** Là où l'ancien chemin bufferisait le corps entier, busboy lit
 le flux et écrit chaque fichier au fil de l'eau dans le dossier temporaire (`streamMultipart()`,
-`context/http/Request.ts:615`). Un upload de 1 Go ne coûte donc pas 1 Go de heap — seuls les petits
+`context/http/Request.ts#HttpRequest.streamMultipart`). Un upload de 1 Go ne coûte donc pas 1 Go de heap — seuls les petits
 champs texte restent en mémoire. C'est ce qui rend un endpoint d'upload public tenable.
 
 **Le nom du fichier temporaire n'est jamais celui du client.** Chaque fichier reçu est écrit sous un nom
-`randomUUID()` + extension d'origine (`context/http/Request.ts:672`) : un nom malveillant
+`randomUUID()` + extension d'origine (`context/http/Request.ts#HttpRequest.streamMultipart`) : un nom malveillant
 (`../../etc/passwd`) ne peut pas influencer le **chemin** d'écriture. Le nom d'origine est conservé en
 **métadonnée** (`filename`), pas dans le chemin.
 
 **Deux budgets, secure-by-default.** Le corps non-multipart est plafonné à **1 MiB** par défaut
-(`maxBodySize`, `http/nodefony/config/config.ts:1208`) — un `POST` JSON géant est rejeté avant d'être bufferisé. Le
+(`maxBodySize`, `http/nodefony/config/config.ts#httpConfigSchema`) — un `POST` JSON géant est rejeté avant d'être bufferisé. Le
 multipart, lui, a ses propres bornes busboy (par fichier, cumul, nombre) qui coupent le flux et
-nettoient les temporaires déjà posés au moindre dépassement (`context/http/Request.ts:481`).
+nettoient les temporaires déjà posés au moindre dépassement (`context/http/Request.ts#HttpRequest.enforceBodyLimit`).
 
 > [!IMPORTANT]
 > `@nodefony/http` ne peut pas importer `@nodefony/framework` (cycle). Les **décorateurs**
 > (`@Body`, `@UploadedFiles`…) vivent donc dans `@nodefony/framework`, mais ils lisent les emplacements
-> (`queryPost`, `queryFile`) remplis par `@nodefony/http`. Une page, deux modules — c'est le prix du
+> (`body`, `files`) remplis par `@nodefony/http`. Une page, deux modules — c'est le prix du
 > découplage.
 
 ## 🚀 Démarrage rapide
@@ -143,30 +147,29 @@ n'écris que tes bornes (si les défauts ne conviennent pas) et le contrôleur q
 
 ### 1. Les bornes de payload
 
-Réglées sur le module `@nodefony/http`, colocalisées dans le manifeste via `use()`. Toutes ces clés
-sont facultatives : ce sont les défauts du schéma, écrits ici pour les rendre visibles et les resserrer.
+Réglées sur le module `@nodefony/http`, dans son fragment `nodefony/config/http.ts` (que le manifeste
+passe à `use()`). Toutes ces clés sont facultatives : ce sont les défauts du schéma, écrits ici pour
+les rendre visibles et les resserrer.
 
 ```typescript
-// nodefony.config.ts — bornes de payload de l'application
-export default defineConfig(() => ({
-  modules: [
-    use("@nodefony/http", {
-      // Corps NON-multipart (JSON, urlencoded, XML, brut) : 1 MiB par défaut.
-      // Au-delà → 413 « Content Too Large ». 0 = illimité.
-      maxBodySize: 1_048_576,
-      upload: {
-        // Chaque fichier (busboy limits.fileSize) — dépassement → 413.
-        maxFileSize: 10 * 1024 * 1024, // 10 MiB
-        // Cumul de TOUS les fichiers d'une même requête (compteur Nodefony).
-        maxTotalFileSize: 30 * 1024 * 1024, // 30 MiB
-        maxFiles: 10, // nombre de fichiers — anti-DoS
-        // Intégrité optionnelle : hash calculé PENDANT le stream (0 relecture).
-        hashAlgorithm: "sha256",
-      },
-    }),
-    "@nodefony/framework",
-  ],
-}));
+// nodefony/config/http.ts — bornes de payload de l'application
+import type { IHttpConfigInput } from "@nodefony/http";
+
+export const httpConfig = () =>
+  ({
+    // Corps NON-multipart (JSON, urlencoded, XML, brut) : 1 MiB par défaut.
+    // Au-delà → 413 « Content Too Large ». 0 = illimité.
+    maxBodySize: 1_048_576,
+    upload: {
+      // Chaque fichier (busboy limits.fileSize) — dépassement → 413.
+      maxFileSize: 10 * 1024 * 1024, // 10 MiB
+      // Cumul de TOUS les fichiers d'une même requête (compteur Nodefony).
+      maxTotalFileSize: 30 * 1024 * 1024, // 30 MiB
+      maxFiles: 10, // nombre de fichiers — anti-DoS
+      // Intégrité optionnelle : hash calculé PENDANT le stream (0 relecture).
+      hashAlgorithm: "sha256",
+    },
+  }) satisfies IHttpConfigInput;
 ```
 
 ### 2. Le contrôleur qui reçoit l'upload
@@ -232,7 +235,7 @@ curl -k -X POST -H "content-type: application/json" \
 ## 🏗️ Architecture interne — le trajet d'un corps multipart
 
 Une requête multipart traverse `HttpRequest` → busboy → disque → `UploadService`, puis atterrit dans le
-contrôleur avec `queryFile`/`queryPost` déjà remplis.
+contrôleur avec `files`/`body` déjà remplis.
 
 ```mermaid
 sequenceDiagram
@@ -246,30 +249,30 @@ sequenceDiagram
   R->>R: parseRequest() — content-type = multipart
   R->>B: request.pipe(busboy)
   B->>D: chaque fichier → <uuid>.<ext> (au fil de l'eau)
-  B-->>R: field (texte) → queryPost
+  B-->>R: field (texte) → body
   Note over B,D: limites fileSize / total / files → 413 + cleanup des temp
   B->>R: finish
   R->>U: createUploadFile() → UploadedFile (stat async)
-  R->>Ctrl: onRequestEnd — queryFile / queryPost prêts
+  R->>Ctrl: onRequestEnd — files / body prêts
   Ctrl->>D: file.moveAsync(dest)
 ```
 
 Les points d'implémentation qui expliquent des comportements surprenants :
 
 1. **L'aiguillage lit le `Content-Type`, pas la méthode** — `parseRequest()`
-   (`context/http/Request.ts:502`). `PATCH` porte un corps comme `POST`/`PUT` : il figure dans la table
-   des méthodes parsées (`context/http/Request.ts:94`) — l'oubli laissait tout `PATCH` avec un corps vide.
+   (`context/http/Request.ts#HttpRequest.parseRequest`). `PATCH` porte un corps comme `POST`/`PUT` : il figure dans la table
+   des méthodes parsées (`context/http/Request.ts#parse`) — l'oubli laissait tout `PATCH` avec un corps vide.
 2. **Le multipart draine sur un `finish`, après flush de tous les writes** — `streamMultipart()`
-   (`context/http/Request.ts:615`) accumule les `Promise` d'écriture disque et ne résout `{ fields, files }`
-   qu'une fois tous les fichiers fermés (`bb.on("finish")`, `context/http/Request.ts:707`).
+   (`context/http/Request.ts#HttpRequest.streamMultipart`) accumule les `Promise` d'écriture disque et ne résout `{ fields, files }`
+   qu'une fois tous les fichiers fermés (`bb.on("finish")`, `context/http/Request.ts#HttpRequest.streamMultipart`).
 3. **Une limite dépassée nettoie les temporaires déjà posés** — `abort()`
-   (`context/http/Request.ts:646`) délie le flux, détruit les write-streams ouverts et `unlink` les temp
-   déjà écrits (`context/http/Request.ts:64`) avant de rejeter en `413` : pas d'orphelins sur le disque.
+   (`context/http/Request.ts#HttpRequest.streamMultipart`) délie le flux, détruit les write-streams ouverts et `unlink` les temp
+   déjà écrits (`context/http/Request.ts#unlinkQuiet`) avant de rejeter en `413` : pas d'orphelins sur le disque.
 4. **Les autres formats drainent AVANT de concaténer** — la base `Parser.parse()` attend `end`
-   (`context/http/parser.ts:111`) avant `Buffer.concat` : sans ce drain, `ParserQs`/`ParserXml`
-   lisaient un corps partiel → `queryPost` vide (bug de régression, cf tests).
+   (`context/http/parser.ts#Parser.parse`) avant `Buffer.concat` : sans ce drain, `ParserQs`/`ParserXml`
+   lisaient un corps partiel → `body` vide (bug de régression, cf tests).
 5. **Un multipart sans boundary exploitable ne crashe pas** — `new Busboy()` lève **synchroniquement** ;
-   c'est rattrapé et on bascule sur le `Parser` brut (`context/http/Request.ts:417`).
+   c'est rattrapé et on bascule sur le `Parser` brut (`context/http/Request.ts#HttpRequest.parser`).
 
 ## ⚙️ Configuration — deux budgets, jamais confondus
 
@@ -283,10 +286,10 @@ non-multipart n'écoute pas `upload.*`.
 | `maxBodySize` | octets | `1_048_576` (1 MiB) | Plafond d'un corps **JSON / urlencoded / XML / brut** → `413`. `0` = illimité. |
 
 Deux rideaux, tous deux `runtimeMutable` (éditable à chaud) : un **pré-check** sur `Content-Length`
-qui rejette **avant** de lire (`enforceBodyLimit()`, `context/http/Request.ts:479`), puis un **compteur
+qui rejette **avant** de lire (`enforceBodyLimit()`, `context/http/Request.ts#HttpRequest.enforceBodyLimit`), puis un **compteur
 en streaming** qui coupe le socket si le corps déborde sans `Content-Length` honnête — chunked ou
-menteur (`Parser.write()`, `context/http/parser.ts:33`, dépassement `context/http/parser.ts:33`).
-Champ `maxBodySize` du schéma : `config/config.ts:1208`.
+menteur (`Parser.write()`, `context/http/parser.ts#Parser.write`, dépassement `context/http/parser.ts#Parser.write`).
+Champ `maxBodySize` du schéma : `config/config.ts#httpConfigSchema`.
 
 **Par requête** : `maxBodySize` et les limites `upload.*` (hors `uploadDir`) sont sur la liste blanche
 du calque de configuration — une application peut les changer pour une requête
@@ -296,22 +299,22 @@ sont lus au moment de lire le corps (`Request.readBodyLimits()`), donc un calque
 
 ### Fichiers multipart — `upload.*`
 
-Table dérivée de `uploadSchema` (`config/config.ts:159`). Toutes les bornes sont `runtimeMutable`.
+Table dérivée de `uploadSchema` (`config/config.ts#uploadSchema`). Toutes les bornes sont `runtimeMutable`.
 
-| Option             | Type                             | Défaut                 | Effet                                                                                               |
-| ------------------ | -------------------------------- | ---------------------- | --------------------------------------------------------------------------------------------------- |
-| `uploadDir`        | chemin                           | `""` → `kernel.tmpDir` | Dossier de dépôt des temporaires. Vide = temp du kernel (`config/config.ts:162`).                   |
-| `maxFileSize`      | octets                           | `524_288_000` (500 MB) | Taille max d'**UN** fichier (busboy `limits.fileSize`) → `413` (`config/config.ts:171`).            |
-| `maxTotalFileSize` | octets                           | `524_288_000` (500 MB) | Taille **CUMULÉE** des fichiers d'une requête (compteur Nodefony) → `413` (`config/config.ts:183`). |
-| `maxFiles`         | entier                           | `1000`                 | Nombre max de fichiers (busboy `limits.files`) → `413` (`config/config.ts:195`).                    |
-| `maxFields`        | entier                           | `1000`                 | Nombre max de champs texte (busboy `limits.fields`) → `413` (`config/config.ts:206`).               |
-| `maxFieldsSize`    | octets                           | `2_097_152` (2 MB)     | Taille max d'un champ texte (busboy `limits.fieldSize`) (`config/config.ts:217`).                   |
-| `hashAlgorithm`    | `false` \| `sha256`/`sha1`/`md5` | `false`                | Hash calculé pendant le stream (intégrité) (`config/config.ts:228`).                                |
-| `encoding`         | chaîne                           | `"utf-8"`              | Encodage par défaut des champs texte (busboy `defCharset`) (`config/config.ts:235`).                |
+| Option             | Type                             | Défaut                 | Effet                                                                                                        |
+| ------------------ | -------------------------------- | ---------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `uploadDir`        | chemin                           | `""` → `kernel.tmpDir` | Dossier de dépôt des temporaires. Vide = temp du kernel (`config/config.ts#uploadSchema`).                   |
+| `maxFileSize`      | octets                           | `524_288_000` (500 MB) | Taille max d'**UN** fichier (busboy `limits.fileSize`) → `413` (`config/config.ts#uploadSchema`).            |
+| `maxTotalFileSize` | octets                           | `524_288_000` (500 MB) | Taille **CUMULÉE** des fichiers d'une requête (compteur Nodefony) → `413` (`config/config.ts#uploadSchema`). |
+| `maxFiles`         | entier                           | `1000`                 | Nombre max de fichiers (busboy `limits.files`) → `413` (`config/config.ts#uploadSchema`).                    |
+| `maxFields`        | entier                           | `1000`                 | Nombre max de champs texte (busboy `limits.fields`) → `413` (`config/config.ts#uploadSchema`).               |
+| `maxFieldsSize`    | octets                           | `2_097_152` (2 MB)     | Taille max d'un champ texte (busboy `limits.fieldSize`) (`config/config.ts#uploadSchema`).                   |
+| `hashAlgorithm`    | `false` \| `sha256`/`sha1`/`md5` | `false`                | Hash calculé pendant le stream (intégrité) (`config/config.ts#uploadSchema`).                                |
+| `encoding`         | chaîne                           | `"utf-8"`              | Encodage par défaut des champs texte (busboy `defCharset`) (`config/config.ts#uploadSchema`).                |
 
 > [!WARNING]
 > `uploadDir` vide est **résolu au boot** sur le répertoire temporaire du kernel par le builder de config
-> (`defineModuleConfig.ts:43`) : un défaut vide n'est jamais un chemin vide en runtime. Ne dérérérence
+> (`defineModuleConfig.ts#applyKernelDefaults`) : un défaut vide n'est jamais un chemin vide en runtime. Ne dérérérence
 > **jamais** le kernel au top-level d'un `config.ts` — c'est la raison du champ marqué `kernelDerived`.
 
 ## 🧰 API — accéder aux champs et aux fichiers
@@ -320,34 +323,34 @@ Depuis un contrôleur, deux surfaces équivalentes : les **décorateurs de param
 recommandé) et les **getters** de `Controller` (impératif). Les signatures exactes vivent dans
 `.ai/symbols.json` — jamais recopiées ici.
 
-| Accès                                              | Source lue                           | Ancrage                                                             |
-| -------------------------------------------------- | ------------------------------------ | ------------------------------------------------------------------- |
-| `@UploadedFiles() f: IUploadedFile[]`              | tous les fichiers (`queryFile`)      | `resolveParamArg` `"files"` (`routerDecorators.ts:1312`)            |
-| `@UploadedFile() f: IUploadedFile`                 | le **premier** fichier               | `resolveParamArg` `"file"` (`routerDecorators.ts:1311`)             |
-| `@Body() body`                                     | tous les champs parsés (`queryPost`) | `resolveParamArg` `"body"` (`routerDecorators.ts:1232`)             |
-| `@Body("label") v`                                 | un seul champ du body                | même source, clé (`routerDecorators.ts:1279`)                       |
-| `@Body({ stream: true }) s: NodeJS.ReadableStream` | le **flux brut**, parse **sauté**    | `resolveParamArg` stream (`routerDecorators.ts:1358`)               |
-| `this.queryFile`                                   | équivalent getter des fichiers       | `Controller.queryFile` (`framework/nodefony/src/Controller.ts:354`) |
-| `this.queryPost`                                   | équivalent getter des champs         | `Controller.queryPost` (`framework/nodefony/src/Controller.ts:364`) |
+| Accès                                              | Source lue                        | Ancrage                                                                      |
+| -------------------------------------------------- | --------------------------------- | ---------------------------------------------------------------------------- |
+| `@UploadedFiles() f: IUploadedFile[]`              | tous les fichiers (`files`)       | `resolveParamArg` `"files"` (`routerDecorators.ts#UploadedFiles`)            |
+| `@UploadedFile() f: IUploadedFile`                 | le **premier** fichier            | `resolveParamArg` `"file"` (`routerDecorators.ts#UploadedFile`)              |
+| `@Body() body`                                     | tous les champs parsés (`body`)   | `resolveParamArg` `"body"` (`routerDecorators.ts#Body`)                      |
+| `@Body("label") v`                                 | un seul champ du body             | même source, clé (`routerDecorators.ts#Body`)                                |
+| `@Body({ stream: true }) s: NodeJS.ReadableStream` | le **flux brut**, parse **sauté** | `resolveParamArg` stream (`routerDecorators.ts#resolveParamArg`)             |
+| `this.files`                                       | équivalent getter des fichiers    | `Controller.files` (`framework/nodefony/src/Controller.ts#Controller.files`) |
+| `this.body`                                        | équivalent getter des champs      | `Controller.body` (`framework/nodefony/src/Controller.ts#Controller.body`)   |
 
 Les décorateurs `@UploadedFile` / `@UploadedFiles` sont des fabriques de paramètre
-(`routerDecorators.ts:1312`), exportées par `@nodefony/framework` ; leurs interfaces `IUploadedFile` /
-`IParsedUploadFile` viennent de `@nodefony/http` (`interfaces/IUpload.ts:49`, `interfaces/IUpload.ts:7`).
+(`routerDecorators.ts#UploadedFiles`), exportées par `@nodefony/framework` ; leurs interfaces `IUploadedFile` /
+`IParsedUploadFile` viennent de `@nodefony/http` (`interfaces/IUpload.ts#IUploadedFile`, `interfaces/IUpload.ts#IParsedUploadFile`).
 
 ### Un fichier uploadé — `UploadedFile`
 
-Chaque entrée de `queryFile` est un `UploadedFile` (`service/upload/upload-service.ts:96`), déjà écrit
+Chaque entrée de `files` est un `UploadedFile` (`service/upload/upload-service.ts#UploadedFile`), déjà écrit
 sur disque. Ses membres utiles :
 
-| Membre                   | Ce qu'il donne                                                          | Ancrage                                                    |
-| ------------------------ | ----------------------------------------------------------------------- | ---------------------------------------------------------- |
-| `filename`               | Nom **d'origine** déclaré par le client (métadonnée, jamais le chemin). | `realName()` (`service/upload/upload-service.ts:147`)      |
-| `size`                   | Taille réellement écrite (octets).                                      | `getSize()` (`service/upload/upload-service.ts:139`)       |
-| `prettySize`             | Taille lisible (`« 1.2 MB »`).                                          | `getPrettySize()` (`service/upload/upload-service.ts:143`) |
-| `mimeType`               | Type MIME déclaré (`image/png`…), sinon deviné de l'extension.          | `getMimeType()` (`service/upload/upload-service.ts:153`)   |
-| `hash` / `hashAlgorithm` | Empreinte d'intégrité si `upload.hashAlgorithm` est réglé.              | `interfaces/IUpload.ts:55`                                 |
-| `moveAsync(target)`      | Déplace le temp — **non bloquant, recommandé** dans le pipeline.        | `moveAsync()` (`service/upload/upload-service.ts:218`)     |
-| `move(target)`           | Variante **synchrone** (compat) — bloque l'event-loop.                  | `move()` (`service/upload/upload-service.ts:186`)          |
+| Membre                   | Ce qu'il donne                                                          | Ancrage                                                                           |
+| ------------------------ | ----------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| `filename`               | Nom **d'origine** déclaré par le client (métadonnée, jamais le chemin). | `realName()` (`service/upload/upload-service.ts#UploadedFile.realName`)           |
+| `size`                   | Taille réellement écrite (octets).                                      | `getSize()` (`service/upload/upload-service.ts#UploadedFile.getSize`)             |
+| `prettySize`             | Taille lisible (`« 1.2 MB »`).                                          | `getPrettySize()` (`service/upload/upload-service.ts#UploadedFile.getPrettySize`) |
+| `mimeType`               | Type MIME déclaré (`image/png`…), sinon deviné de l'extension.          | `getMimeType()` (`service/upload/upload-service.ts#UploadedFile.getMimeType`)     |
+| `hash` / `hashAlgorithm` | Empreinte d'intégrité si `upload.hashAlgorithm` est réglé.              | `interfaces/IUpload.ts#IUploadedFile.hashAlgorithm`                               |
+| `moveAsync(target)`      | Déplace le temp — **non bloquant, recommandé** dans le pipeline.        | `moveAsync()` (`service/upload/upload-service.ts#UploadedFile.moveAsync`)         |
+| `move(target)`           | Variante **synchrone** (compat) — bloque l'event-loop.                  | `move()` (`service/upload/upload-service.ts#UploadedFile.move`)                   |
 
 `move`/`moveAsync` acceptent un **fichier cible** ou un **dossier existant** : sur un dossier, la
 destination est bâtie avec `filename` — d'où l'avertissement de sécurité ci-dessous.
@@ -357,7 +360,7 @@ destination est bâtie avec `filename` — d'où l'avertissement de sécurité c
 Pour piper directement un très gros corps (vidéo, backup) vers le disque ou S3 sans passer par busboy ni
 par la RAM, `@Body({ stream: true })` court-circuite le parse et injecte l'`IncomingMessage` brut (un
 `Readable`). Le pipeline sait le sauter en amont via `routeExpectsBodyStream()`
-(`routerDecorators.ts:1509`), mémoïsé sur la route.
+(`routerDecorators.ts#routeExpectsBodyStream`), mémoïsé sur la route.
 
 ```ts
 // fragment — le contrôleur pipe le flux lui-même (0 parse, 0 pic RAM)
@@ -376,15 +379,15 @@ piégé. Les défenses en place, et **ce qui reste à ta charge**.
 <!-- prettier-ignore -->
 | Menace | Défense côté framework | À ta charge |
 | --- | --- | --- |
-| **Path traversal** (chemin d'écriture) | Le temp est nommé `randomUUID()` + extension — jamais le nom client (`context/http/Request.ts:672`). | La **destination** de `move()` (voir avertissement). |
+| **Path traversal** (chemin d'écriture) | Le temp est nommé `randomUUID()` + extension — jamais le nom client (`context/http/Request.ts#HttpRequest.streamMultipart`). | La **destination** de `move()` (voir avertissement). |
 | **Saturation RAM** | Multipart streamé (jamais bufferisé) ; corps non-multipart borné (`maxBodySize`). | Resserrer `maxBodySize` selon l'endpoint. |
-| **Saturation disque** | `maxFileSize` + `maxTotalFileSize` + `maxFiles` ; `abort()` nettoie les temp à l'abandon (`context/http/Request.ts:646`). | Purger les temp non déplacés (TTL / cron). |
-| **DoS par quantité** | `maxFields` / `maxFiles` / `parts` → `413` (`context/http/Request.ts:754`). | — |
+| **Saturation disque** | `maxFileSize` + `maxTotalFileSize` + `maxFiles` ; `abort()` nettoie les temp à l'abandon (`context/http/Request.ts#HttpRequest.streamMultipart`). | Purger les temp non déplacés (TTL / cron). |
+| **DoS par quantité** | `maxFields` / `maxFiles` / `parts` → `413` (`context/http/Request.ts#HttpRequest.streamMultipart`). | — |
 | **Type de fichier hostile** | `mimeType` **déclaré** est exposé tel quel. | Valider le type/contenu réel (le MIME client est déclaratif). |
 
 > [!WARNING]
 > **Path traversal sur la destination.** `move(dir)` / `moveAsync(dir)` vers un **dossier** construit le
-> chemin final avec `file.filename` — le nom **client** (`service/upload/upload-service.ts:101`). Un nom
+> chemin final avec `file.filename` — le nom **client** (`service/upload/upload-service.ts#UploadedFile.filename`). Un nom
 > `../../etc/cron.d/x` s'échapperait du dossier. Le framework protège le chemin du **temporaire**, pas
 > celui que **tu** choisis. Règle : passe une **cible complète** que tu contrôles, ou assainis toujours
 > avec `path.basename(file.filename)` — exactement le `safeName` du Démarrage rapide.
@@ -394,14 +397,14 @@ piégé. Les défenses en place, et **ce qui reste à ta charge**.
 Le parsing du corps est sur le chemin de chaque requête écrivante — les choix visibles dans le code :
 
 - **Multipart en flux pur** — plus de double-bufferisation : busboy écrit sur disque au fil de l'eau,
-  seuls les champs texte restent en mémoire (`context/http/Request.ts:400`).
+  seuls les champs texte restent en mémoire (`context/http/Request.ts#HttpRequest.initialize`).
 - **Rejet AVANT lecture** — le pré-check `Content-Length` renvoie `413` sans lire un octet
-  (`context/http/Request.ts:466`) ; le compteur streaming **libère immédiatement** la RAM déjà
-  bufferisée au dépassement (`context/http/parser.ts:43`).
+  (`context/http/Request.ts#HttpRequest.readBodyLimits`) ; le compteur streaming **libère immédiatement** la RAM déjà
+  bufferisée au dépassement (`context/http/parser.ts#Parser.write`).
 - **`stat` non bloquant** — `UploadedFile.create()` résout les stats du fichier en async
-  (`service/upload/upload-service.ts:130`), plus de `lstatSync` par fichier uploadé.
+  (`service/upload/upload-service.ts#UploadedFile.create`), plus de `lstatSync` par fichier uploadé.
 - **Listeners jumeaux nettoyés** — le drain de fin de corps retire ses écouteurs `end`/`error`/overflow
-  à la main (`once` n'auto-détache que celui qui fire) (`context/http/parser.ts:78`).
+  à la main (`once` n'auto-détache que celui qui fire) (`context/http/parser.ts#Parser.ended`).
 - **Hash opt-in** — `hashAlgorithm: false` par défaut : zéro coût CPU tant que l'intégrité n'est pas
   demandée.
 
@@ -410,28 +413,28 @@ pipeline : `npm run test:memory` (skill `nodefony-check-memory-health`).
 
 ## 📜 Normes appliquées
 
-| Domaine                            | Norme                            | Ancrage                                                       |
-| ---------------------------------- | -------------------------------- | ------------------------------------------------------------- |
-| Formulaire avec fichiers           | RFC 7578 (`multipart/form-data`) | `parseMultipart()` via busboy (`context/http/Request.ts:574`) |
-| Corps trop gros → 413              | RFC 9110 §15.5.14                | `enforceBodyLimit()` (`context/http/Request.ts:479`)          |
-| 413 en streaming (chunked/menteur) | RFC 9110 §15.5.14                | `Parser.write()` (`context/http/parser.ts:33`)                |
-| Bornes multipart → 413             | RFC 9110 §15.5.14                | `stream.on("limit")` (`context/http/Request.ts:481`)          |
-| Défense path traversal (nom temp)  | OWASP — File Upload              | `randomUUID()` (`context/http/Request.ts:672`)                |
-| Charset du corps honoré            | RFC 9110 (Content-Type)          | `getCharset()` (`context/http/Request.ts:875`)                |
+| Domaine                            | Norme                            | Ancrage                                                                              |
+| ---------------------------------- | -------------------------------- | ------------------------------------------------------------------------------------ |
+| Formulaire avec fichiers           | RFC 7578 (`multipart/form-data`) | `parseMultipart()` via busboy (`context/http/Request.ts#HttpRequest.parseMultipart`) |
+| Corps trop gros → 413              | RFC 9110 §15.5.14                | `enforceBodyLimit()` (`context/http/Request.ts#HttpRequest.enforceBodyLimit`)        |
+| 413 en streaming (chunked/menteur) | RFC 9110 §15.5.14                | `Parser.write()` (`context/http/parser.ts#Parser.write`)                             |
+| Bornes multipart → 413             | RFC 9110 §15.5.14                | `stream.on("limit")` (`context/http/Request.ts#HttpRequest.enforceBodyLimit`)        |
+| Défense path traversal (nom temp)  | OWASP — File Upload              | `randomUUID()` (`context/http/Request.ts#HttpRequest.streamMultipart`)               |
+| Charset du corps honoré            | RFC 9110 (Content-Type)          | `getCharset()` (`context/http/Request.ts#HttpRequest.getCharset`)                    |
 
 ## ⚠️ Pièges
 
-| Symptôme                                                | Cause                                                               | Correction                                                                                         |
-| ------------------------------------------------------- | ------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
-| `@Body()` est vide sur un upload de fichier             | Les fichiers vont dans `queryFile`, **pas** dans `queryPost`        | Lire les fichiers avec `@UploadedFiles()` / `this.queryFile` ; `@Body()` = champs texte            |
-| Un `POST` JSON de 1,5 Mo est refusé en `413`            | `maxBodySize` vaut **1 MiB** par défaut                             | Augmenter `maxBodySize` (pas `upload.maxFileSize`)                                                 |
-| Un gros fichier passe alors que `maxBodySize` est petit | Le multipart **n'écoute pas** `maxBodySize`                         | Régler `upload.maxFileSize` / `maxTotalFileSize`                                                   |
-| `413` sur upload sans message clair                     | Une borne busboy atteinte en streaming (fichier, cumul, nombre)     | Vérifier les bornes `upload.*` — 413 émis sur `stream.on("limit")` (`context/http/Request.ts:481`) |
-| Un fichier écrit `../../etc/…` après un `move`          | `move(dossier)` utilise le nom **client** (`upload-service.ts:197`) | Passer une cible complète, ou `path.basename(file.filename)`                                       |
-| Des fichiers temporaires s'accumulent dans `uploadDir`  | Le contrôleur ne déplace jamais le temp                             | Appeler `moveAsync()` (ou purger l'ancien temp par TTL)                                            |
-| `queryPost` vide sur `PATCH`                            | Déjà géré : `PATCH` est dans la table des méthodes parsées          | Aucune — corps `PATCH` parsé comme `POST` (`context/http/Request.ts:93`)                           |
-| Corps `latin1` mal décodé                               | Déjà géré : le `charset=` du `Content-Type` est honoré              | Aucune — `getCharset()` normalise (`context/http/Request.ts:875`)                                  |
-| `multipart` sans boundary fait planter                  | `new Busboy()` throw synchrone                                      | Déjà géré : bascule sur le parser brut (`context/http/Request.ts:521`)                             |
+| Symptôme                                                | Cause                                                                             | Correction                                                                                                                  |
+| ------------------------------------------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| `@Body()` est vide sur un upload de fichier             | Les fichiers vont dans `files`, **pas** dans `body`                               | Lire les fichiers avec `@UploadedFiles()` / `this.files` ; `@Body()` = champs texte                                         |
+| Un `POST` JSON de 1,5 Mo est refusé en `413`            | `maxBodySize` vaut **1 MiB** par défaut                                           | Augmenter `maxBodySize` (pas `upload.maxFileSize`)                                                                          |
+| Un gros fichier passe alors que `maxBodySize` est petit | Le multipart **n'écoute pas** `maxBodySize`                                       | Régler `upload.maxFileSize` / `maxTotalFileSize`                                                                            |
+| `413` sur upload sans message clair                     | Une borne busboy atteinte en streaming (fichier, cumul, nombre)                   | Vérifier les bornes `upload.*` — 413 émis sur `stream.on("limit")` (`context/http/Request.ts#HttpRequest.enforceBodyLimit`) |
+| Un fichier écrit `../../etc/…` après un `move`          | `move(dossier)` utilise le nom **client** (`upload-service.ts#UploadedFile.move`) | Passer une cible complète, ou `path.basename(file.filename)`                                                                |
+| Des fichiers temporaires s'accumulent dans `uploadDir`  | Le contrôleur ne déplace jamais le temp                                           | Appeler `moveAsync()` (ou purger l'ancien temp par TTL)                                                                     |
+| `body` vide sur `PATCH`                                 | Déjà géré : `PATCH` est dans la table des méthodes parsées                        | Aucune — corps `PATCH` parsé comme `POST` (`context/http/Request.ts#parse`)                                                 |
+| Corps `latin1` mal décodé                               | Déjà géré : le `charset=` du `Content-Type` est honoré                            | Aucune — `getCharset()` normalise (`context/http/Request.ts#HttpRequest.getCharset`)                                        |
+| `multipart` sans boundary fait planter                  | `new Busboy()` throw synchrone                                                    | Déjà géré : bascule sur le parser brut (`context/http/Request.ts#HttpRequest.parseRequest`)                                 |
 
 ## 🧪 Tests & couverture
 
@@ -443,7 +446,7 @@ dans le Markdown).
 | Unitaires — `UploadedFile`  | `unit/UploadedFile.test.ts` — `create()` async, `move`/`moveAsync`, `mimeType`, `realName`                          |
 | Unitaires — `@Body` stream  | `framework` `unit/BodyStream.test.ts` — `@Body({ stream })`, `resolveParamArg`, `routeExpectsBodyStream`            |
 | Intégration — multipart     | `http/upload.test.ts` — upload simple, multi-fichiers, mime non-octet, champ + fichier, `413` par fichier et cumulé |
-| Intégration — content-types | `http/body-content-types.test.ts` — JSON, urlencoded, `@Body("champ")`, XML → `queryPost`                           |
+| Intégration — content-types | `http/body-content-types.test.ts` — JSON, urlencoded, `@Body("champ")`, XML → `body`                                |
 | Intégration — bornes        | `http/body-limit.test.ts` — sous la limite `200`, `Content-Length` > 1 MiB → `413`, chunked > 1 MiB refusé          |
 | Intégration — flux brut     | `integration/bodyStream.test.ts` — `@Body({ stream })` bout-en-bout (TLS + clair), non-régression `@Body()`         |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodefony/http",
-  "version": "10.0.0-beta.3",
+  "version": "10.0.0-beta.4",
   "description": "Serveurs HTTP, HTTPS, HTTP/2 et WebSocket natifs pour Nodefony : sessions, contextes de requête, certificats TLS",
   "author": "Christophe CAMENSULI <ccamensuli@gmail.com>",
   "main": "./dist/index.js",
@@ -27,7 +27,7 @@
   },
   "private": false,
   "engines": {
-    "node": ">=24.0.0"
+    "node": ">=24.14.0"
   },
   "keywords": [
     "nodefony",
@@ -51,12 +51,11 @@
     "test": "./nodefony/tests"
   },
   "dependencies": {
-    "@fastify/busboy": "3.2.3",
+    "@fastify/busboy": "3.2.4",
     "cookie": "2.0.1",
-    "http-terminator": "3.2.0",
     "mime-types": "3.0.2",
     "ms": "^2.1.3",
-    "qs": "^6.16.0",
+    "qs": "^6.16.1",
     "serve-static": "2.2.1",
     "tslib": "2.8.1",
     "ws": "8.22.0",
@@ -72,16 +71,16 @@
     "@types/websocket": "1.0.10",
     "@types/ws": "8.18.2",
     "@types/xml2js": "0.4.14",
-    "@vitest/coverage-v8": "5.0.4",
-    "nodefony": "^10.0.0-beta.3",
+    "@vitest/coverage-v8": "5.0.5",
+    "nodefony": "^10.0.0-beta.4",
     "tsx": "4.23.15",
-    "vitest": "5.0.4"
+    "vitest": "5.0.5"
   },
   "license": "Apache-2.0",
   "readmeFilename": "README.md",
   "contributors": [],
   "peerDependencies": {
-    "nodefony": "^10.0.0-beta.3",
+    "nodefony": "^10.0.0-beta.4",
     "zod": "^4.6.7"
   },
   "files": [

package/dist/_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js

@@ -1,6 +0,0 @@
-//#region \0@oxc-project+runtime@0.153.0/helpers/esm/decorateMetadata.js
-function __decorateMetadata(k, v) {
-	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-//#endregion
-export { __decorateMetadata as default };