@nodefony/framework 10.0.0-beta.4 → 10.0.0-beta.5

package/README.md

@@ -8,6 +8,21 @@ sert **HTTP et WebSocket dans le même contexte**, nativement.
 > (internals concis) · [`docs/`](./docs) (concepts). `@nodefony/http` ne peut PAS importer
 > ce module (dépendance circulaire) — l'accès se fait via `context.resolver`, typé par le contrat `IRouteResolver` (défini par http, implémenté par framework).
 
+## ⚡ Le geste — un contrôleur ne s'écrit pas à la main
+
+Dans une application, les générateurs posent le contrôleur, l'inscrivent dans `index.ts` et
+écrivent son test. Depuis la racine de l'application :
+
+```bash
+# une ressource REST adossée à une table : entité, service CRUD, contrôleur, tests, migration
+npx nodefony create entity Post title:string content:text --route /api/posts
+# un contrôleur seul : hello (GET + écho WebSocket, défaut), rest (CRUD) ou realtime (canal)
+npx nodefony create controller Facture --kind rest --route /api/factures
+```
+
+`--module <nom>` cible un module de l'application au lieu de sa racine. La suite de ce README
+décrit ce que ces fichiers contiennent — de quoi les lire et les retoucher.
+
 ## Rôle
 
 - **Router** : matching de routes (path + méthode + domaine), `Route.match()`.

package/dist/nodefony/controller/AdminApiController.js

@@ -59,7 +59,7 @@ var AdminApiController = class AdminApiController extends Controller {
 	}
 	/**
 	* Action générique appelée par le Resolver pour toute route admin — DUPLEX
-	* (« API souveraine ») : même exécution sur les deux transports, seul
+	* (une action, deux transports) : même exécution sur les deux transports, seul
 	* l'emballage diffère.
 	*
 	*  - **HTTP** : rendu historique inchangé (`renderJson` + status + header

package/dist/nodefony/src/Controller.js

@@ -140,6 +140,16 @@ var Controller = class extends Service {
 		this.#context = context ?? null;
 	}
 	/**
+	* Journalise au nom du module du contrôleur, pas du noyau : `moduleName`
+	* explicite, sinon le module posé sur la requête (`context.logModule`),
+	* sinon le module propriétaire du contrôleur.
+	*
+	* @param moduleName - module qui signe CETTE ligne
+	*/
+	log(pci, severity, msgid, msg, moduleName) {
+		return super.log(pci, severity, msgid, msg, moduleName ?? this.context?.logModule ?? this.module?.name);
+	}
+	/**
 	* Route de l'appel en cours. Par requête : posée par le Resolver
 	* (`setRoute`). Singleton : celle du résolveur de l'APPEL quand le pont
 	* `api.request` en a posé un dans l'ALS (clé `resolver` — un résolveur par

package/dist/nodefony/src/Resolver.js

@@ -668,7 +668,9 @@ var Resolver = class {
 					return this.context.render(result);
 				}
 				switch (this.context.type) {
-					case "http": this.context.waitAsync = true;
+					case "http":
+						this.context.waitAsync = true;
+						this.unrendered = `une instance de ${(typeof result === "object" && result !== null ? result.constructor.name : void 0) ?? "classe"}`;
 				}
 				return;
 			default: switch (this.context.type) {
@@ -677,6 +679,7 @@ var Resolver = class {
 					if (this.context.isRedirect) return this.context.send();
 					if (NO_BODY_STATUS.has(this.getResponseStatus())) return this.context.send();
 					this.context.waitAsync = true;
+					this.unrendered = result === null ? "null" : typeof result;
 			}
 		}
 	}

package/dist/nodefony/src/ResourceController.js

@@ -3,7 +3,7 @@ import { assertPageQuery } from "nodefony";
 import { HttpError } from "@nodefony/http";
 // nodefony/src/ResourceController.ts
 /**
-* Controller de ressource **souverain** (V4.2 — POC API souveraine, Phase 2) :
+* Controller de ressource **duplex** (V4.2 — une action, deux transports) :
 * la logique métier est écrite UNE fois dans le service de ressource, les
 * actions de la sous-classe ne sont que des portes (REST, WS-RPC `invoke`,
 * GraphQL à venir) qui retournent la **valeur brute** — `returnController`
@@ -38,8 +38,12 @@ import { HttpError } from "@nodefony/http";
 *     return this.listResource();
 *   }
 *   \@route("books-get", { path: "/{id}", requirements: { methods: ["GET", "WEBSOCKET"] } })
-*   detail(\@Param("id") id: string) {
-*     return this.getResource(id);
+*   async detail(\@Param("id") id: string) {
+*     // `null` rendu tel quel = « l'action répond elle-même » : la requête
+*     // pendrait jusqu'au délai d'expiration. La porte décide du 404.
+*     const found = await this.getResource(id);
+*     if (!found) throw new HttpError(`Book ${id} not found`, 404);
+*     return found;
 *   }
 * }
 * ```
@@ -117,6 +121,10 @@ var ResourceController = class extends Controller {
 	/**
 	* Lit une entité par id — `null` si absente (la porte décide du 404).
 	*
+	* ⚠️ Ne pas rendre ce `null` tel quel depuis une action : pour le Resolver,
+	* `null` veut dire « l'action répond elle-même », et la requête attend
+	* alors son délai d'expiration. Lever un `HttpError` 404.
+	*
 	* `options.relations` charge les associations dans la foulée. La porte doit
 	* n'y laisser passer que des relations qu'elle a DÉCLARÉES : un `include`
 	* libre laisse le client nommer n'importe quelle association, donc lire des

package/dist/nodefony/src/syslogFilters.js

@@ -29,6 +29,8 @@ const SYSLOG_FILTERS = {
 	module: "string",
 	/** Catégorie de message (msgid) — inclusion insensible à la casse. */
 	msgid: "string",
+	/** Module exclu — égalité insensible à la casse (`NODEFONY` = le framework). */
+	excludeModule: "string",
 	/** Protocole d'origine ; absent = les deux. */
 	protocol: ["ws", "http"],
 	/**
@@ -42,6 +44,10 @@ const SYSLOG_FILTERS = {
 	* seconde liste ne peut se périmer.
 	*/
 	flow: { each: Object.keys(FLOW_STEPS) },
+	/** Écarte les lignes d'accès de la console d'administration elle-même. */
+	hideConsole: "boolean",
+	/** Une ligne par requête (sa ligne d'accès), avec le nombre de lignes regroupées. */
+	groupByRequest: "boolean",
 	/** Borne basse d'horodatage (epoch ms, incluse). */
 	from: "int",
 	/** Borne haute d'horodatage (epoch ms, incluse). */

package/dist/types/nodefony/controller/AdminApiController.d.ts

@@ -35,7 +35,7 @@ declare class AdminApiController extends Controller {
     constructor(context: ContextType);
     /**
      * Action générique appelée par le Resolver pour toute route admin — DUPLEX
-     * (« API souveraine ») : même exécution sur les deux transports, seul
+     * (une action, deux transports) : même exécution sur les deux transports, seul
      * l'emballage diffère.
      *
      *  - **HTTP** : rendu historique inchangé (`renderJson` + status + header

package/dist/types/nodefony/src/Controller.d.ts

@@ -1,4 +1,4 @@
-import { Service, Module, FileClass } from "nodefony";
+import { Service, Module, type Pci, type Severity, type Msgid, type Message, FileClass } from "nodefony";
 import type { IRequestUser, MaybePromise } from "nodefony";
 import type { IController } from "../interfaces/index.js";
 import Route from "./Route.js";
@@ -83,6 +83,14 @@ declare class Controller extends Service implements IController {
      */
     get context(): ContextType | undefined;
     set context(context: ContextType | undefined);
+    /**
+     * Journalise au nom du module du contrôleur, pas du noyau : `moduleName`
+     * explicite, sinon le module posé sur la requête (`context.logModule`),
+     * sinon le module propriétaire du contrôleur.
+     *
+     * @param moduleName - module qui signe CETTE ligne
+     */
+    log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message, moduleName?: string): import("nodefony").Pdu;
     /**
      * Route de l'appel en cours. Par requête : posée par le Resolver
      * (`setRoute`). Singleton : celle du résolveur de l'APPEL quand le pont

package/dist/types/nodefony/src/Resolver.d.ts

@@ -37,6 +37,14 @@ declare class Resolver implements IResolver {
     resolve: boolean;
     variables: unknown[];
     exception?: HttpError | Error | null | undefined;
+    /**
+     * Ce que l'action a rendu quand le Resolver n'a rien pu envoyer — absent
+     * sinon. Lu par l'avertissement de développement
+     * (`IRouteResolver.unrendered`). `declare` : AUCUN champ émis — un Resolver
+     * naît à chaque requête, et la propriété n'apparaît que sur la branche qui
+     * attend déjà son délai d'expiration (`micro-resolver-field.mjs`).
+     */
+    unrendered?: string;
     acceptedProtocol: string | null;
     bypassFirewall: boolean;
     /**

package/dist/types/nodefony/src/ResourceController.d.ts

@@ -67,7 +67,7 @@ export interface IResourceService<T = unknown> {
     delete?(criteria: Record<string, unknown>): Promise<number> | number;
 }
 /**
- * Controller de ressource **souverain** (V4.2 — POC API souveraine, Phase 2) :
+ * Controller de ressource **duplex** (V4.2 — une action, deux transports) :
  * la logique métier est écrite UNE fois dans le service de ressource, les
  * actions de la sous-classe ne sont que des portes (REST, WS-RPC `invoke`,
  * GraphQL à venir) qui retournent la **valeur brute** — `returnController`
@@ -102,8 +102,12 @@ export interface IResourceService<T = unknown> {
  *     return this.listResource();
  *   }
  *   \@route("books-get", { path: "/{id}", requirements: { methods: ["GET", "WEBSOCKET"] } })
- *   detail(\@Param("id") id: string) {
- *     return this.getResource(id);
+ *   async detail(\@Param("id") id: string) {
+ *     // `null` rendu tel quel = « l'action répond elle-même » : la requête
+ *     // pendrait jusqu'au délai d'expiration. La porte décide du 404.
+ *     const found = await this.getResource(id);
+ *     if (!found) throw new HttpError(`Book ${id} not found`, 404);
+ *     return found;
  *   }
  * }
  * ```
@@ -155,6 +159,10 @@ declare class ResourceController<T = unknown> extends Controller {
     /**
      * Lit une entité par id — `null` si absente (la porte décide du 404).
      *
+     * ⚠️ Ne pas rendre ce `null` tel quel depuis une action : pour le Resolver,
+     * `null` veut dire « l'action répond elle-même », et la requête attend
+     * alors son délai d'expiration. Lever un `HttpError` 404.
+     *
      * `options.relations` charge les associations dans la foulée. La porte doit
      * n'y laisser passer que des relations qu'elle a DÉCLARÉES : un `include`
      * libre laisse le client nommer n'importe quelle association, donc lire des

package/dist/types/nodefony/src/syslogFilters.d.ts

@@ -28,6 +28,8 @@ export declare const SYSLOG_FILTERS: {
     readonly module: "string";
     /** Catégorie de message (msgid) — inclusion insensible à la casse. */
     readonly msgid: "string";
+    /** Module exclu — égalité insensible à la casse (`NODEFONY` = le framework). */
+    readonly excludeModule: "string";
     /** Protocole d'origine ; absent = les deux. */
     readonly protocol: readonly ["ws", "http"];
     /**
@@ -45,6 +47,10 @@ export declare const SYSLOG_FILTERS: {
     readonly flow: {
         readonly each: FlowStepId[];
     };
+    /** Écarte les lignes d'accès de la console d'administration elle-même. */
+    readonly hideConsole: "boolean";
+    /** Une ligne par requête (sa ligne d'accès), avec le nombre de lignes regroupées. */
+    readonly groupByRequest: "boolean";
     /** Borne basse d'horodatage (epoch ms, incluse). */
     readonly from: "int";
     /** Borne haute d'horodatage (epoch ms, incluse). */

package/docs/admin.md

@@ -82,7 +82,7 @@ Trois idées à retenir :
 | RBAC                  | _Role-Based Access Control_ : l'accès dépend des rôles de l'appelant.                                      |
 | `ROLE_NODEFONY_*`     | Rôles de la **plateforme** (admin du framework), distincts des rôles applicatifs `ROLE_*` d'un tenant.     |
 | Pont / dispatch       | Le controller unique qui, à chaque requête, retrouve l'endpoint et exécute son handler.                    |
-| API souveraine        | Toute action admin déclare AUSSI le transport WebSocket → invocable par le pont WS-RPC `api.request`.      |
+| Deux transports       | Toute action admin déclare AUSSI le transport WebSocket → invocable par le pont WS-RPC `api.request`.      |
 | Duplex                | Une même action servie sur HTTP **et** WebSocket (le différenciateur Nodefony).                            |
 | Catalogue / discovery | La liste des producteurs + endpoints, exposée en JSON pour que Studio bâtisse sa navigation.               |
 | Playground            | La console dev qui joue n'importe quel controller depuis le navigateur (`/nodefony/playground`).           |
@@ -327,7 +327,7 @@ laissez-passer.
 > applicatifs `ROLE_*` d'un tenant. Un endpoint peut exiger un rôle plus fin (`role: "ROLE_…"`) ou
 > graduer l'information **dans** son handler en lisant `request.roles`.
 
-## 🔌 HTTP et WebSocket — la même action (API souveraine)
+## 🔌 HTTP et WebSocket — la même action
 
 Toute action admin déclare **aussi** le transport `WEBSOCKET` (`AdminBroker.ts#AdminBroker.mountAll`) : la route est
 montée avec `[method, "WEBSOCKET"]`. Elle devient donc invocable par le pont WS-RPC `api.request`
@@ -362,6 +362,55 @@ Trois pas, du point de vue d'un module :
 **Handlers lazy** : résous tes services **dans** le handler (à la requête), jamais au montage — un
 service désactivable renvoie alors `503` proprement au lieu de casser le boot.
 
+### Ce que publie un endpoint — l'état réel, aucun secret, ses capacités déclarées
+
+Tout ce que renvoie un handler part tel quel vers la console, le pont socket et les agents. Trois
+règles en découlent.
+
+**1. Un DTO ne porte aucun secret : il en dit la présence.** Un mot de passe, une clé ou un jeton
+se décrivent par un booléen. Le résumé d'un utilisateur expose `hasPassword`, jamais le hash
+(`UserAdminApi.ts#IUserSummary`). La description du pare-feu expose `synchronizerToken: boolean`
+(`IFirewallDescription.ts#IFirewallDescription`). La redaction se fait **en construisant** le DTO,
+champ par champ. Copier l'objet puis retirer les clés sensibles laisserait passer la prochaine qui
+sera ajoutée. Un test le prouve : `JSON.stringify(dto)` ne contient pas la valeur sentinelle posée
+dans la configuration.
+
+**2. Une description montre ce qui TOURNE, pas la configuration relue.** Une méthode `describe()`
+lit les structures que le service a bâties au démarrage
+(`IFirewall.ts#IFirewall.describe`, `IBackplane.ts#IBackplane.describe`). Un authenticator mal
+orthographié dans la configuration n'y figure pas, puisqu'il n'est pas monté. Relire la
+configuration montrerait l'intention, et la console afficherait comme active une défense qui ne
+tourne pas.
+
+**3. Une capacité de liste non déclarée est refusée en `400`, jamais ignorée.** Tri, filtres,
+recherche et facettes se déclarent dans `page` (`IAdminApi.ts#IAdminPageCapabilities`), et le
+handler lit **la même donnée** : il passe ses champs triables à `parsePageQuery()`
+(`pageQuery.ts#parsePageQuery`) et son vocabulaire de filtres à `parseFilters()`
+(`pageFilters.ts#parseFilters`). Ces deux lecteurs refusent en `400` un tri hors liste, un `?q=`
+sur un endpoint qui ne cherche pas, une valeur mal formée et un paramètre que personne ne
+reconnaît. Lire `request.query.order` à la main renvoie une page non triée que le client prend pour
+triée. Avec un filtre mal orthographié, c'est la collection entière qui revient.
+
+```typescript ignore
+import { parseFilters, parsePageQuery, type IAdminEndpoint } from "nodefony";
+
+// Une constante, deux lectures : le catalogue et le handler ne peuvent pas diverger.
+const SORTABLE = ["createdAt", "total"] as const;
+const FILTERS = { status: ["paid", "pending", "refunded"] } as const;
+
+const listOrders: IAdminEndpoint = {
+  path: "orders",
+  method: "GET",
+  summary: "Commandes, paginées.",
+  page: { sortable: () => SORTABLE, filters: FILTERS },
+  handler: async (request) => {
+    const query = parsePageQuery(request.query, { sortable: SORTABLE }); // ?order=x → 400
+    const filters = parseFilters(request.query, FILTERS); // ?status=zzz, ?stauts= → 400
+    return orders.listPage({ ...query, ...filters });
+  },
+};
+```
+
 ### Les producteurs réels (à imiter, sans les redocumenter)
 
 Le broker lui-même est déclaré comme service du framework (`index.ts`). Les producteurs internes

package/docs/controller.md

@@ -306,7 +306,7 @@ class ChatController extends Controller {
 | Nombre d'appels d'action | 1 | 1 au handshake (`WebsocketContext.handle()`, `WebsocketContext.ts#WebsocketContext.handle`) + 1 par frame (`handleMessage()`, `WebsocketContext.ts#WebsocketContext.handleMessage`) |
 | Argument de l'action | Variables de route (ou paramètres décorés) | Idem + **le message** en dernier argument (`WebsocketContext.ts#WebsocketContext.handleMessage`) |
 | Rendu d'un `return` | Corps de la réponse | Frame envoyée sur la socket |
-| Échec | Statut HTTP + corps d'erreur | **Code de fermeture** RFC 6455 (401/403 → 1008, 5xx → 1011, autre → 4004) ; chemin sans route WebSocket → **404 HTTP avant l'ouverture** |
+| Échec | Statut HTTP + corps d'erreur | **Au handshake** : une garde refusée répond par un **statut HTTP** (401/403) **avant l'ouverture** (`Resolver.authorizeAction()`, `Resolver.ts#Resolver.authorizeAction`), chemin sans route WebSocket → **404** ; **après l'ouverture** : un **code de fermeture** RFC 6455 (401/403 → 1008, 5xx → 1011, autre → 4004) |
 | `initialize()` | Singleton : **une fois**, à la création · `@Scope("request")` : à chaque requête | Singleton : une fois, à la création · `@Scope("request")` : **une fois par connexion**, au handshake |
 
 La réutilisation de l'instance vient du cache posé sur le container du contexte

package/docs/decorateurs.md

@@ -334,7 +334,7 @@ Deux points qu'un dev découvre sinon à ses dépens :
   méthodes, ne serait-ce que pour l'en-tête `Allow`.
 
 Le second argument accepte les options de route non redondantes — `Omit<RouteOptions, "path" | "method">`
-(`routerDecorators.ts#route`), soit `defaults`, `requirements`, `host`, `bypassFirewall`
+(`routerDecorators.ts#route`), notamment `defaults`, `requirements`, `host`, `bypassFirewall` et `fallback`
 (`RouteOptions`, `Route.ts#RouteOptions`) :
 
 ```typescript
@@ -342,6 +342,12 @@ Le second argument accepte les options de route non redondantes — `Omit<RouteO
 async index(@Param("page") page: string) { /* … */ }
 ```
 
+`requirements.scheme` se compare au scheme **effectif** de la requête — celui qu'annonce un proxy de
+confiance compris : hors exigence, la route répond **403**, jamais une redirection
+(`Route.ts#Route.matchRequirements`). Rediriger `http` vers `https` relève de la bordure (HSTS, proxy
+inverse), pas du routage. `fallback: true` fait de la route un **repli**, servi seulement si aucune
+autre ne correspond — voir [le routage](routing.md#-ordre-de-résolution--trois-situations).
+
 ### Paramètres — ce que l'action reçoit
 
 Onze décorateurs, tous produits par `paramDecoratorFactory()` (`routerDecorators.ts#paramDecoratorFactory`) sauf

package/docs/idempotence.md

@@ -619,14 +619,32 @@ registerIdempotencyStore("mon-backend", (ctx) => {
 });
 ```
 
-Trois règles héritées du code existant, à respecter sous peine de double-effet :
+Quatre règles héritées du code existant, à respecter sous peine de double-effet :
 
 1. **`begin` doit être atomique côté backend.** Un `GET` puis `SET` séparés laissent deux retries
    concurrents obtenir `fresh` — précisément ce que l'idempotence doit empêcher.
 2. **Ne jamais rendre `fresh` hors réservation gagnée.** En cas de doute (course, état illisible),
-   rendre `in-flight` : le client réessaiera, c'est sans danger.
+   rendre `in-flight` : le client réessaiera, c'est sans danger. La seule exception est la coupure
+   du backend, et elle se décide (règle 4).
 3. **`complete` doit préserver l'empreinte** de l'entrée in-flight, sinon un rejeu avec un autre
    payload après complétion ne produit plus de 422.
+4. **Une fabrique qui ne peut pas construire son store LÈVE — elle ne rend jamais un store qui se
+   tait.** Module manquant, client du mauvais type, configuration incohérente : tout ce qui est
+   certain dès le démarrage se refuse dans la fabrique. Le framework en fait un arrêt de boot en
+   production, et un `WARNING` suivi d'un repli sur la mémoire en développement
+   ([contrat de dégradation](#le-contrat-de-dégradation--fail-loud-jamais-silencieux)). Un store
+   construit malgré tout, qui garde chaque appel par `if (!connected) return`, échappe à ce
+   contrat : le registre affiche ton backend pendant que plus rien n'est dédoublonné. C'est un
+   échec **ouvert** — la garde a disparu, et rien ne le dit.
+
+   La connexion, elle, ne peut pas être exigée là : la fabrique est appelée à `onKernelBoot`
+   (`index.ts#Framework.onKernelBoot`), avant que l'ORM ne soit connecté. Elle se résout donc à
+   chaque appel, comme le fait `DrizzleIdempotencyStore.from()`
+   (`DrizzleIdempotencyStore.ts#DrizzleIdempotencyStore.from`), et la conduite pendant une coupure
+   est un **choix à écrire**. Les stores livrés rendent `fresh` — exécuter sans dédoublonnage
+   plutôt que bloquer — et l'annoncent comme un compromis
+   ([`redis`](#redis--le-choix-cluster)). Si ton domaine ne tolère aucun double effet, rends
+   `in-flight` (le client réessaiera) ou lève : la requête échoue, rien n'est exécuté deux fois.
 
 Fonctions du registre : `registerIdempotencyStore()` (`idempotencyStoreRegistry.ts#registerIdempotencyStore`),
 `getIdempotencyStoreFactory()` (`idempotencyStoreRegistry.ts#getIdempotencyStoreFactory`), `listIdempotencyStores()`

package/docs/routing.md

@@ -172,7 +172,7 @@ class CatalogController extends Controller {
     path: "/files/*",
     requirements: { methods: ["GET"] },
   })
-  async files(rest: string) {
+  async download(rest: string) {
     return this.renderJson({ rest });
   }
 
@@ -363,6 +363,20 @@ le suit — un `@All("*")` déclaré tôt masque le reste du contrôleur.
 > ses propres routes, quel que soit l'ordre d'écriture (`hasMagic`, `routerDecorators.ts#controller`). Ça ne
 > vaut **que** pour `"*"` seul : `/files/*` reste ordonné comme les autres.
 
+Pour un repli qui doit céder **entre modules** — la page d'une application monopage, servie sur
+`/app/{page}` ou `/app/*` —, l'option `fallback: true` range la route après toutes les autres, dans
+leur ordre relatif, au moment de construire l'index (`Route.ts#RouteOptions.fallback`) : une route
+littérale ou dynamique de même forme, déclarée par un module chargé après, garde la main. Aucun coût
+par requête. Sans ce drapeau, un repli déclaré tôt capture en silence les routes des modules
+suivants.
+
+```ts ignore
+@Get("/app/{page}", { fallback: true })
+renderSpa(): unknown {
+  return this.renderApp();
+}
+```
+
 ### Situation 2 — le même chemin, deux méthodes
 
 Deux routes peuvent partager un chemin et se distinguer par la méthode. La passe 1 essaie la première,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodefony/framework",
-  "version": "10.0.0-beta.4",
+  "version": "10.0.0-beta.5",
   "description": "Le modèle de programmation Nodefony : routeur, contrôleurs, décorateurs et vues — HTTP et WebSocket dans le même contexte",
   "author": "Christophe CAMENSULI <ccamensuli@gmail.com>",
   "main": "./dist/index.js",
@@ -49,11 +49,11 @@
     "tslib": "2.8.1"
   },
   "devDependencies": {
-    "@nodefony/http": "^10.0.0-beta.4",
+    "@nodefony/http": "^10.0.0-beta.5",
     "@types/chai": "5.2.3",
     "@types/node": "26.6.5",
     "@vitest/coverage-v8": "5.0.5",
-    "nodefony": "^10.0.0-beta.4",
+    "nodefony": "^10.0.0-beta.5",
     "tsx": "4.23.15",
     "vitest": "5.0.5"
   },
@@ -61,8 +61,8 @@
   "readmeFilename": "README.md",
   "contributors": [],
   "peerDependencies": {
-    "@nodefony/http": "^10.0.0-beta.4",
-    "nodefony": "^10.0.0-beta.4",
+    "@nodefony/http": "^10.0.0-beta.5",
+    "nodefony": "^10.0.0-beta.5",
     "zod": "^4.6.7"
   },
   "files": [