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

package/dist/nodefony/src/loginPage.js

@@ -1,5 +1,5 @@
 import { LOGIN_PAGE_ASSETS_BASE, LOGIN_PAGE_LAYOUTS, LOGIN_PAGE_SKINS, LOGIN_PAGE_SKIN_SPECS, LOGIN_PAGE_THEME_KEY, OAUTH2_CANCELLED_REASON, isLoginPageSkin, loginPageSkinFile, oauth2AuthorizePath, safeRedirectPath } from "nodefony";
-//#region nodefony/src/loginPage.ts
+// nodefony/src/loginPage.ts
 /**
 * Mémoïse une ressource chargée de façon asynchrone : le SUCCÈS est gardé, un
 * ÉCHEC est oublié. Garder la promesse rejetée figerait la panne — la page
@@ -210,7 +210,7 @@ const LOGIN_PAGE_TEMPLATE = `<!doctype html>
           </p>
           <ul class="badges">
             <li class="agentic">Agentic ready</li>
-            <li>Node.js ≥ 24</li>
+            <li>Node.js ≥ 24.14</li>
             <li>TypeScript strict</li>
             <li>ESM only</li>
             <li>Licence Apache 2.0</li>
@@ -427,5 +427,4 @@ const LOGIN_PAGE_TEMPLATE = `<!doctype html>
   </body>
 </html>
 `;
-//#endregion
 export { LOGIN_PAGE_ASSET_FILES, LOGIN_PAGE_EMPTY_NOTICE, LOGIN_PAGE_TEMPLATE, ORGANIZATION_ACCOUNT_LABEL, buildLoginPageView, keepSuccess };

package/dist/nodefony/src/requireAuthentication.js

@@ -1,5 +1,5 @@
 import { readSessionAuthentication } from "nodefony";
-//#region nodefony/src/requireAuthentication.ts
+// nodefony/src/requireAuthentication.ts
 /**
 * Ce qui manque à une session pour satisfaire un `@RequireAuthentication` —
 * fonction PURE : la session, l'exigence et l'heure lui sont données.
@@ -32,5 +32,4 @@ function authenticationShortfall(session, requirement, now) {
 function stepUpChallenge(requirement) {
 	return "Session realm=\"nodefony\", error=\"insufficient_user_authentication\", error_description=\"A more recent or stronger authentication is required\"" + (requirement.maxAge === null ? "" : `, max_age="${requirement.maxAge}"`);
 }
-//#endregion
 export { authenticationShortfall, stepUpChallenge };

package/dist/nodefony/src/routeSchema.js

@@ -0,0 +1,81 @@
+import { BootConfigurationError, SchemaValidationError, isStandardSchema, toSchemaValidationIssues } from "nodefony";
+// nodefony/src/routeSchema.ts
+const ROUTE_PARTS = [
+	"params",
+	"query",
+	"body",
+	"headers"
+];
+/** Les noms des parties, pour reconnaître une clé lue sur un objet inconnu. */
+const ROUTE_PART_NAMES = new Set(ROUTE_PARTS);
+/**
+* Valide l'entrée d'une action contre son schéma — synchrone tant que chaque
+* validateur l'est, asynchrone seulement si l'un d'eux rend une promesse.
+*
+* Les quatre parties sont toutes validées avant de conclure : un échec rend
+* en une fois TOUTES les anomalies, chacune rattachée à sa partie. La valeur
+* d'une partie validée est remplacée par la SORTIE de son schéma (valeurs par
+* défaut, coercitions) ; la valeur reçue n'est ni copiée ni sérialisée — des
+* octets décodés par le transport arrivent tels quels au validateur.
+*
+* @param schema - le schéma de la route.
+* @param raw - l'entrée brute, mutée en place (objet propre à la requête).
+* @returns l'entrée validée, ou sa promesse.
+* @throws SchemaValidationError (statut 422) quand une partie est invalide —
+*   de façon synchrone, ou par la promesse rendue.
+*/
+function validateRouteInput(schema, raw) {
+	let failures = null;
+	let pending = null;
+	for (let i = 0; i < ROUTE_PARTS.length; i++) {
+		const part = ROUTE_PARTS[i];
+		const partSchema = part === void 0 ? void 0 : schema[part];
+		if (part === void 0 || partSchema === void 0) continue;
+		const result = partSchema["~standard"].validate(raw[part]);
+		if (result instanceof Promise) {
+			pending ??= [];
+			pending.push(result.then((settled) => failures = applyPartResult(raw, part, i, settled, failures)));
+		} else failures = applyPartResult(raw, part, i, result, failures);
+	}
+	if (pending === null) return concludeRouteInput(raw, failures);
+	return Promise.all(pending).then(() => concludeRouteInput(raw, failures));
+}
+/**
+* Applique le résultat d'une partie : sa sortie remplace la valeur brute, ou
+* ses anomalies sont rangées à SON rang — l'erreur les rend dans l'ordre des
+* parties, que leurs validateurs aient attendu ou non.
+*/
+function applyPartResult(raw, part, rank, result, failures) {
+	if (result.issues === void 0) {
+		raw[part] = result.value;
+		return failures;
+	}
+	const ranked = failures ?? [];
+	ranked[rank] = toSchemaValidationIssues(result.issues, part);
+	return ranked;
+}
+/** Rend l'entrée validée, ou lève l'erreur unique qui porte toutes les anomalies. */
+function concludeRouteInput(raw, failures) {
+	if (failures === null) return raw;
+	const issues = [];
+	for (const partIssues of failures) if (partIssues !== void 0) issues.push(...partIssues);
+	throw new SchemaValidationError(issues);
+}
+/**
+* Refuse, au démarrage, un schéma de route mal formé : partie inconnue (une
+* faute de frappe — `bodies` — serait sinon ignorée sans un mot), ou valeur
+* qui n'implémente pas Standard Schema (un appelant JavaScript peut passer
+* n'importe quoi).
+*
+* @param schema - le schéma déclaré.
+* @param routeName - la route, nommée dans l'erreur.
+* @throws BootConfigurationError sur la première faute trouvée.
+*/
+function assertRouteSchemaShape(schema, routeName) {
+	if (typeof schema !== "object" || schema === null) throw new BootConfigurationError(`Route "${routeName}" : l'option « schema » doit être un objet { params, query, body, headers }.`);
+	for (const [part, value] of Object.entries(schema)) {
+		if (!ROUTE_PART_NAMES.has(part)) throw new BootConfigurationError(`Route "${routeName}" : partie de schéma inconnue « ${part} » (attendu : ${ROUTE_PARTS.join(", ")}).`);
+		if (value !== void 0 && !isStandardSchema(value)) throw new BootConfigurationError(`Route "${routeName}" : « schema.${part} » n'implémente pas Standard Schema (Zod, Valibot, ArkType…).`);
+	}
+}
+export { assertRouteSchemaShape, validateRouteInput };

package/dist/nodefony/src/scopeCatalog.js

@@ -1,6 +1,6 @@
 import { extractActionScopes } from "../decorators/routerDecorators.js";
 import router_default from "../service/router.js";
-//#region nodefony/src/scopeCatalog.ts
+// nodefony/src/scopeCatalog.ts
 /**
 * P6.8 — **Découverte au boot** : scanne TOUTES les routes montées (`Router.routes`)
 * et agrège les scopes déclarés par `@RequireScope`, **regroupés par API** (préfixe
@@ -36,5 +36,4 @@ function collectDeclaredApiScopes() {
 		scopes: [...byApi.get(api) ?? []].sort()
 	}));
 }
-//#endregion
 export { collectDeclaredApiScopes, collectDeclaredApiScopes as default };

package/dist/nodefony/src/singletonGuard.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/singletonGuard.ts
+// nodefony/src/singletonGuard.ts
 /**
 * Filets d'un contrôleur **singleton** — le défaut : UNE instance par classe,
 * partagée par toutes les requêtes, concurrentes comprises.
@@ -72,5 +72,4 @@ function guardSingletonState(controller, name) {
 	}
 	Object.preventExtensions(controller);
 }
-//#endregion
 export { guardSingletonState, isDevelopment, singletonWriteMessage };

package/dist/nodefony/src/syslogFilters.js

@@ -1,5 +1,5 @@
 import { FLOW_STEPS, SEVERITY_NAMES } from "nodefony";
-//#region nodefony/src/syslogFilters.ts
+// nodefony/src/syslogFilters.ts
 /**
 * Ce que le journal sait TRIER — un seul axe, le temps.
 *
@@ -47,5 +47,4 @@ const SYSLOG_FILTERS = {
 	/** Borne haute d'horodatage (epoch ms, incluse). */
 	to: "int"
 };
-//#endregion
 export { SYSLOG_FILTERS, SYSLOG_SORTABLE };

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 import { Kernel, Module } from "nodefony";
 import type { IFrameworkConfigInput, IFrameworkConfig } from "./nodefony/config/config.js";
 import { getIdempotencyStoreFactory, registerIdempotencyStore, listIdempotencyStores } from "./nodefony/src/idempotencyStoreRegistry.js";
-import Router from "./nodefony/service/router.js";
+import Router, { FRAMEWORK_ROUTER, isFrameworkRouter } from "./nodefony/service/router.js";
 import Route from "./nodefony/src/Route.js";
 import Controller from "./nodefony/src/Controller.js";
 import ResourceController from "./nodefony/src/ResourceController.js";
@@ -24,9 +24,10 @@ import { createFrameworkAdminApi } from "./nodefony/src/FrameworkAdminApi.js";
 import { buildPlaygroundSnapshot } from "./nodefony/src/PlaygroundAdminApi.js";
 import { createSyslogAdminApi } from "./nodefony/src/SyslogAdminApi.js";
 import Eta from "./nodefony/service/Eta.js";
-import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
-import { mergeSchemas, makeExecutableSchema } from "@graphql-tools/schema";
 import { controllers, route, controller, Get, Post, Put, Delete, Patch, Options, Head, All, Domain, BypassFirewall, IsGranted, RequireScope, RequireAuthentication, Anonymous, Csp, CsrfProtect, CsrfExempt, Idempotent, CurrentUser, Scope, UseSession, HttpCode, Header, Redirect, Param, Body, Query, Headers, Cookie, Session, Req, Res, UploadedFile, UploadedFiles, routeExpectsBodyStream, buildContextParamArgs, getParamArgsMeta } from "./nodefony/decorators/routerDecorators.js";
+export type { IHttpMethodDecorator } from "./nodefony/decorators/routerDecorators.js";
+export { validateRouteInput } from "./nodefony/src/routeSchema.js";
+export type { IRouteSchema, RouteInput, RoutePart, RawRouteInput, RawRouteParams, RawRouteQuery, RawRouteHeaders, } from "./nodefony/src/routeSchema.js";
 declare module "nodefony" {
     interface NodefonyModuleConfig {
         "@nodefony/framework": IFrameworkConfigInput;
@@ -77,14 +78,8 @@ declare class Framework extends Module<IFrameworkConfig> {
      */
     onKernelReady(): Promise<this>;
 }
-declare const graphql: {
-    mergeSchemas: typeof mergeSchemas;
-    makeExecutableSchema: typeof makeExecutableSchema;
-    mergeResolvers: typeof mergeResolvers;
-    mergeTypeDefs: typeof mergeTypeDefs;
-};
 export default Framework;
-export { Controller, ResourceController, Route, Router, Resolver, AdminBroker, MemoryIdempotencyStore, AdminApiController, SessionAuthController, mountSessionAuthRoutes, LoginPageController, mountLoginPage, TokenAuthController, mountTokenAuthRoutes, IssuerMetadataController, mountIssuerMetadataRoutes, ProtectedResourceMetadataController, mountProtectedResourceRoutes, protectedResourceRoutePaths, collectProtectedResources, WebAuthnController, mountWebAuthnRoutes, OAuth2Controller, mountOAuth2Routes, BenchController, mountBenchRoutes, ApiKeyController, mountApiKeyRoutes, TotpController, mountTotpRoutes, createKernelAdminApi, createFrameworkAdminApi, createSyslogAdminApi, buildPlaygroundSnapshot, Eta, route, controller, controllers, Get, Post, Put, Delete, Patch, Options, Head, All, Domain, BypassFirewall, IsGranted, RequireScope, RequireAuthentication, Anonymous, Csp, CsrfProtect, CsrfExempt, Idempotent, CurrentUser, Scope, UseSession, HttpCode, Header, Redirect, Param, Body, Query, Headers, Cookie, Session, Req, Res, UploadedFile, UploadedFiles, routeExpectsBodyStream, buildContextParamArgs, getParamArgsMeta, graphql, registerIdempotencyStore, getIdempotencyStoreFactory, listIdempotencyStores, };
+export { Controller, ResourceController, Route, Router, FRAMEWORK_ROUTER, isFrameworkRouter, Resolver, AdminBroker, MemoryIdempotencyStore, AdminApiController, SessionAuthController, mountSessionAuthRoutes, LoginPageController, mountLoginPage, TokenAuthController, mountTokenAuthRoutes, IssuerMetadataController, mountIssuerMetadataRoutes, ProtectedResourceMetadataController, mountProtectedResourceRoutes, protectedResourceRoutePaths, collectProtectedResources, WebAuthnController, mountWebAuthnRoutes, OAuth2Controller, mountOAuth2Routes, BenchController, mountBenchRoutes, ApiKeyController, mountApiKeyRoutes, TotpController, mountTotpRoutes, createKernelAdminApi, createFrameworkAdminApi, createSyslogAdminApi, buildPlaygroundSnapshot, Eta, route, controller, controllers, Get, Post, Put, Delete, Patch, Options, Head, All, Domain, BypassFirewall, IsGranted, RequireScope, RequireAuthentication, Anonymous, Csp, CsrfProtect, CsrfExempt, Idempotent, CurrentUser, Scope, UseSession, HttpCode, Header, Redirect, Param, Body, Query, Headers, Cookie, Session, Req, Res, UploadedFile, UploadedFiles, routeExpectsBodyStream, buildContextParamArgs, getParamArgsMeta, registerIdempotencyStore, getIdempotencyStoreFactory, listIdempotencyStores, };
 export { frameworkConfigSchema } from "./nodefony/config/config.js";
 export type { IdempotencyStoreFactory, IIdempotencyStoreFactoryContext, } from "./nodefony/src/idempotencyStoreRegistry.js";
 export type { SecurityClause, SecurityRequirement, IAuthenticationRequirement, IRequireAuthenticationOptions, CspDirectives, IParamArgSource, ParamMeta, } from "./nodefony/decorators/routerDecorators.js";

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

@@ -1,5 +1,17 @@
 import type { ContextType } from "@nodefony/http";
 import Controller from "../src/Controller.js";
+type AdminQuery = Record<string, string | string[]>;
+/**
+ * Ramène les paramètres d'URL au contrat {@link IAdminRequest.query} : seules
+ * les chaînes et les tableaux de chaînes passent. `qs` produit des objets pour
+ * `a[b]=1` ; les laisser passer sous un type qui les nie tromperait chaque
+ * producteur du plan d'administration.
+ *
+ * @param source - paramètres d'URL de la requête (`Controller.query`)
+ * @returns `source` lui-même quand il respecte déjà le contrat (aucune
+ *   allocation), sinon une copie sans les valeurs imbriquées
+ */
+export declare function toAdminQuery(source: Record<string, unknown> | undefined): AdminQuery;
 /**
  * Controller pont unique du data plane admin (Studio).
  *

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

@@ -91,6 +91,13 @@ declare class SessionAuthController extends SecurityApiController {
      * Identité de la session courante, re-résolue (rôles frais). Toujours `200` :
      * `{ user: null }` quand il n'y a pas de session (ou qu'elle ne mène plus à
      * un compte actif) — l'absence de session est un état, pas une erreur.
+     *
+     * **Sème aussi le jeton anti-CSRF** (cookie lisible `csrf-token`) : c'est la
+     * seule requête sûre que TOUT client connaît d'avance. Sans elle, une mutation
+     * `@CsrfProtect` n'a de jeton à rejouer que si son auteur a AUSSI décoré une
+     * lecture — protéger les seules écritures, le geste naturel, rendait alors 403
+     * sans issue, au navigateur comme aux tests générés. Le jeton est sans état
+     * (HMAC) : celui-ci vaut pour toute route protégée.
      */
     me(): Promise<import("@nodefony/http").Http2Response | import("@nodefony/http").HttpResponse | import("@nodefony/http").WebsocketResponse>;
 }

package/dist/types/nodefony/decorators/routerDecorators.d.ts

@@ -1,10 +1,12 @@
 import "reflect-metadata";
+import type { Readable } from "node:stream";
 import { TypeController } from "../service/router.js";
 import { RouteOptions } from "../src/Route.js";
 import Controller from "../src/Controller.js";
 import type { ControllerScope } from "../src/Controller.js";
 import { Module } from "nodefony";
 import { ControllerConstructor } from "../src/Route.js";
+import type { IRouteSchema, RawRouteInput, RouteInput } from "../src/routeSchema.js";
 import type { SessionIntent } from "@nodefony/http";
 type Constructor<T = {}> = new (...args: any[]) => T;
 /**
@@ -66,7 +68,30 @@ declare function controller(prefix: string): <T extends ControllerConstructor &
  *   return this.renderJson({ name });
  * }
  */
-declare function route(name: string, options: RouteOptions): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+declare function route(name: string, options: RouteOptions & {
+    schema?: undefined;
+    bodyStream?: false;
+}): RouteMethodDecorator;
+declare function route<S extends IRouteSchema>(name: string, options: RouteOptionsWithSchema<S> & {
+    bodyStream?: false;
+}): SchemaRouteMethodDecorator<S, false>;
+declare function route<S extends IRouteSchema & {
+    readonly body?: undefined;
+}>(name: string, options: RouteOptionsWithSchema<S> & {
+    bodyStream: true;
+}): SchemaRouteMethodDecorator<S, true>;
+/** Options d'une route qui déclare un schéma. */
+type RouteOptionsWithSchema<S extends IRouteSchema> = RouteOptions & {
+    schema: S;
+};
+/** Décorateur de méthode d'une route sans schéma : la signature de l'action est libre. */
+type RouteMethodDecorator = (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Décorateur d'une action à schéma : la compilation refuse une action dont
+ * l'argument ne reçoit pas `RouteInput<S, Stream>` (champ absent du schéma,
+ * type divergent, second argument).
+ */
+type SchemaRouteMethodDecorator<S extends IRouteSchema, Stream extends boolean> = <T extends (input: RouteInput<S, Stream>) => unknown>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
 export declare const HTTP_CODE_METADATA = "route:httpCode";
 export declare const HEADERS_METADATA = "route:responseHeaders";
 export declare const REDIRECT_METADATA = "route:redirect";
@@ -158,19 +183,40 @@ export interface IdempotentMeta {
     readonly required: boolean;
 }
 type MethodDecoratorOptions = Omit<RouteOptions, "path" | "method">;
-declare const Get: (path?: string, options?: MethodDecoratorOptions) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-declare const Post: (path?: string, options?: MethodDecoratorOptions) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-declare const Put: (path?: string, options?: MethodDecoratorOptions) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-declare const Delete: (path?: string, options?: MethodDecoratorOptions) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-declare const Patch: (path?: string, options?: MethodDecoratorOptions) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-declare const Options: (path?: string, options?: MethodDecoratorOptions) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-declare const Head: (path?: string, options?: MethodDecoratorOptions) => (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Un décorateur de méthode HTTP (`@Get`, `@Post`…). Sans schéma, la signature
+ * de l'action est libre (décorateurs de paramètre) ; avec `schema`, l'action
+ * reçoit un argument unique `RouteInput<S>`, vérifié à la compilation.
+ */
+export interface IHttpMethodDecorator {
+    (path?: string, options?: MethodDecoratorOptions & {
+        schema?: undefined;
+        bodyStream?: false;
+    }): RouteMethodDecorator;
+    <S extends IRouteSchema>(path: string, options: MethodDecoratorOptions & {
+        schema: S;
+        bodyStream?: false;
+    }): SchemaRouteMethodDecorator<S, false>;
+    <S extends IRouteSchema & {
+        readonly body?: undefined;
+    }>(path: string, options: MethodDecoratorOptions & {
+        schema: S;
+        bodyStream: true;
+    }): SchemaRouteMethodDecorator<S, true>;
+}
+declare const Get: IHttpMethodDecorator;
+declare const Post: IHttpMethodDecorator;
+declare const Put: IHttpMethodDecorator;
+declare const Delete: IHttpMethodDecorator;
+declare const Patch: IHttpMethodDecorator;
+declare const Options: IHttpMethodDecorator;
+declare const Head: IHttpMethodDecorator;
 /**
  * `@All` — route sans restriction de méthode : matche **toutes** les méthodes
  * HTTP (équivalent NestJS `@All()`). N'émet aucun requirement `methods`, donc
  * `Route.matchRequirements` ne lève jamais 405 sur la méthode.
  */
-declare function All(path?: string, options?: MethodDecoratorOptions): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+declare const All: IHttpMethodDecorator;
 /**
  * Fixe le code de statut HTTP de la réponse d'une action.
  *
@@ -470,26 +516,18 @@ declare const Query: (key?: string) => (target: object, propertyKey: string, par
  *
  * ## Le corps n'est PAS validé — le type écrit ici ne promet rien
  *
- * `@Body()` injecte le corps **tel qu'il a été parsé** : `@Body() dto: CreateOrder`
- * compile, mais rien ne garantit qu'un `CreateOrder` soit arrivé. C'est un choix
- * assumé, pas un oubli — valider ici ne garderait que la porte HTTP, et devrait
- * rester **synchrone** ({@link resolveParamArg} l'est, et le rendre asynchrone
- * taxerait toute requête à paramètres décorés).
- *
- * Où valider, donc :
+ * `@Body()` injecte le corps **tel qu'il a été décodé** (objet JSON ou de
+ * formulaire, chaîne pour `text/*`, octets `Uint8Array` pour tout autre type) :
+ * `@Body() dto: CreateOrder` compile, mais rien ne garantit qu'un `CreateOrder`
+ * soit arrivé.
  *
- * - **Une entité** → les hooks `beforeCreate` / `beforeUpdate` d'
- *   `AbstractCrudService` : ils sont `await`és — donc une règle asynchrone
- *   (unicité en base) y est possible — et ils gardent REST, WebSocket **et** la
- *   CLI d'un seul geste. C'est ce que génère `nodefony create entity`.
- * - **Un cas isolé** → `schema.parse(body)` en première ligne de l'action, sur le
- *   modèle d'`assertPageQuery`. Rien d'autre à écrire : une `ZodError` qui remonte
- *   devient un **422** (RFC 9110 §15.5.21) portant `error.fields` — quel champ,
- *   quel message, quelle règle.
+ * Pour un contrat vérifié, déclarer l'option de route `schema` (ADR-0018) : le
+ * corps est validé AVANT l'action — 422 qui nomme chaque champ —, sur HTTP comme
+ * sur le pont WebSocket, et l'action le reçoit typé dans `input.body`. Une action
+ * à schéma ne prend aucun décorateur de paramètre.
  *
- * Et typer le paramètre avec `z.infer<typeof createXSchema>` plutôt qu'avec
- * `Partial<XRow>` : le premier décrit le contrat d'**entrée**, le second promet la
- * ligne de **table** (`id`, horodatages) que le schéma effacera de toute façon.
+ * Sans schéma, `schema.parse(body)` en première ligne de l'action reste le geste
+ * d'un cas isolé : une `ZodError` qui remonte devient le même **422**.
  *
  * @example
  * ```ts
@@ -524,20 +562,21 @@ export interface IParamArgContext {
     /**
      * Query de l'invocation courante quand elle ne vient PAS de l'URL du
      * transport — pont WS-RPC `api.request` (`Resolver.queryOverride`). Prime
-     * sur `request.queryGet` pour `@Query` uniquement (`@Req` reste le brut).
+     * sur `request.query` pour `@Query` uniquement (`@Req` reste le brut).
      */
     queryOverride?: Record<string, unknown> | undefined;
     request?: {
-        queryGet?: Record<string, unknown> | undefined;
-        queryPost?: Record<string, unknown> | undefined;
-        queryFile?: unknown[] | undefined;
+        query?: Record<string, unknown> | undefined;
+        /** Corps décodé : objet JSON, champs de formulaire, octets… */
+        body?: unknown;
+        files?: readonly unknown[] | undefined;
         headers?: Record<string, unknown> | undefined;
         /**
          * P2.9 — `IncomingMessage` brut (un `Readable`) sous-jacent au wrapper
          * `HttpRequest`. Injecté tel quel par `@Body({ stream: true })` (le pipeline
          * n'a pas consommé/parsé ce flux). `undefined` pour les contextes WS.
          */
-        request?: NodeJS.ReadableStream | undefined;
+        request?: Readable | undefined;
     } | null | undefined;
     response?: unknown;
     session?: {
@@ -545,6 +584,31 @@ export interface IParamArgContext {
     } | null | undefined;
     getRequestCookies(name?: string): unknown;
 }
+/**
+ * Le corps DÉCODÉ d'une invocation, depuis la requête seule — la règle de
+ * {@link readBody}, pour qui n'a pas de contexte de paramètres (porte
+ * d'idempotence).
+ *
+ * @param request - la requête du contexte.
+ * @returns le corps posé par le pont WebSocket, sinon le corps HTTP lu.
+ */
+export declare function readInvocationBody(request: IParamArgContext["request"]): unknown;
+/**
+ * L'entrée BRUTE d'une action à schéma, lue aux MÊMES sources que les
+ * décorateurs de paramètre ({@link readQuery}, {@link readBody}) : pont
+ * WebSocket compris. Seule allocation de la voie à schéma : cet objet, propre
+ * à l'invocation, que la validation complète en place et que l'action reçoit.
+ *
+ * Arguments POSITIONNELS, pas un objet de contexte : la voie à schéma n'en
+ * alloue aucun de plus.
+ *
+ * @param paramsMap - variables de route nommées.
+ * @param request - la requête du contexte.
+ * @param queryOverride - query du chemin invoqué (pont WebSocket), sinon rien.
+ * @param bodyStream - `true` : `body` est le flux brut, jamais lu.
+ * @returns les quatre parties, brutes.
+ */
+export declare function readRouteInput(paramsMap: Record<string, unknown>, request: IParamArgContext["request"], queryOverride: Record<string, unknown> | undefined, bodyStream: boolean): RawRouteInput;
 /**
  * Résout la valeur d'un unique paramètre décoré depuis le contexte de requête.
  *
@@ -605,6 +669,36 @@ export declare function buildContextParamArgs(metas: readonly ParamMeta[], conte
  * @returns les métadonnées, ou `null` — une action sans décorateur ne paie rien
  */
 export declare function getParamArgsMeta(proto: object, method: string | symbol): readonly ParamMeta[] | null;
+/**
+ * Le schéma d'entrée d'une méthode (option de route `schema`), ou `null`.
+ * Lecture `Reflect` : à faire une fois, hors du chemin de chaque requête.
+ *
+ * @param proto - le prototype de la classe.
+ * @param method - le nom de la méthode.
+ * @returns le schéma, ou `null` — une action sans schéma ne paie rien.
+ * @throws BootConfigurationError si le schéma rangé est mal formé.
+ */
+export declare function getRouteSchema(proto: object, method: string): IRouteSchema | null;
+/**
+ * Refuse, au DÉMARRAGE, une action à schéma mal déclarée — appelé par
+ * `Router.setController` pour chaque route du contrôleur, pour qu'une faute
+ * ne se révèle pas à la première requête :
+ *
+ * - schéma mal formé (partie inconnue, valeur qui n'est pas un Standard Schema) ;
+ * - schéma ET décorateurs de paramètre (`@Body`…) : une action à schéma reçoit
+ *   un argument UNIQUE, les deux formes ne se combinent pas ;
+ * - `bodyStream: true` ET `schema.body` : un flux ne se valide pas.
+ *
+ * @param routeDef - la route (nom, contrôleur, méthode).
+ * @throws BootConfigurationError qui nomme la route.
+ */
+export declare function assertRouteSchemaDeclaration(routeDef: {
+    name: string;
+    controller?: {
+        prototype: object;
+    } | null | undefined;
+    classMethod?: string | undefined;
+}): void;
 /**
  * P2.9 — Indique si l'action d'une route attend le **flux brut** du body
  * (un paramètre `@Body({ stream:true })`). Le résultat est **mémoïsé** sur
@@ -631,6 +725,13 @@ declare function routeExpectsBodyStream(routeDef: {
 export interface RouteActionMeta {
     /** Paramètres décorés (`@Param`/`@Body`/`@Query`…) — `null` si aucun. */
     paramsMeta: readonly ParamMeta[] | null;
+    /**
+     * Schéma d'entrée (`schema` de l'option de route) — `null` si l'action n'en
+     * déclare pas (cas courant → une comparaison, aucune allocation).
+     */
+    schema: IRouteSchema | null;
+    /** `bodyStream: true` déclaré en option de route. */
+    bodyStream: boolean;
     /** `@Redirect` de l'action — `null` si absent. */
     redirectMeta: RedirectMeta | null;
     /** `@HttpCode` de l'action — `null` si absent. */

package/dist/types/nodefony/interfaces/IController.d.ts

@@ -10,10 +10,9 @@ export interface IController {
     context?: ContextType | undefined;
     session?: Session | null;
     method?: HTTPMethod | undefined;
-    queryGet: Record<string, unknown>;
     query: Record<string, unknown>;
-    queryFile: unknown[];
-    queryPost: Record<string, unknown>;
+    files: readonly unknown[];
+    body: Record<string, unknown>;
     module?: Module | undefined;
     setContext(context: ContextType): void;
     setContextJson(encoding?: BufferEncoding): unknown;

package/dist/types/nodefony/service/router.d.ts

@@ -6,7 +6,16 @@ import type { IRequestRouter } from "@nodefony/http";
 import Resolver from "../src/Resolver.js";
 import Controller from "../src/Controller.js";
 export type TypeController<T> = new (...args: any[]) => T;
+/**
+ * Marque du Router de `@nodefony/framework` — ce que {@link isFrameworkRouter}
+ * lit. `Symbol.for` : la même marque pour deux copies installées du framework,
+ * là où `instanceof` échouerait en silence. Un faux routeur de test s'en
+ * réclame explicitement.
+ */
+export declare const FRAMEWORK_ROUTER: unique symbol;
 declare class Router extends Service implements IRequestRouter {
+    /** Marque {@link FRAMEWORK_ROUTER} — sur le prototype, aucun champ par instance. */
+    get [FRAMEWORK_ROUTER](): true;
     static routes: Route[];
     routes: Route[];
     private singletonControllers;
@@ -55,7 +64,10 @@ declare class Router extends Service implements IRequestRouter {
      *   WEBSOCKET (pont WS-RPC `api.request` d'une MUTATION) : lève l'ambiguïté
      *   GET-via-WS / POST-via-WS sur un même chemin (`context.method` = "WEBSOCKET").
      *   `undefined` (GET/HTTP) → match historique sur `context.method`.
-     * @returns un `Resolver` (`.resolve === true` si une route a matché).
+     * @returns un `Resolver` (`.resolve === true` si une route a matché) — ou,
+     *   pour un chemin servi en WebSocket SEULEMENT et demandé en HTTP, un
+     *   `Resolver` dont `exception` porte le `426` (en-têtes `Upgrade` posés) :
+     *   le pipeline le lève après le pare-feu.
      */
     resolve(context: ContextType, cleanPathOverride?: string, methodOverride?: string): Resolver;
     resolveController(contex: ContextType, name: string): Resolver;
@@ -89,4 +101,18 @@ declare class Router extends Service implements IRequestRouter {
      */
     static getRoutesForController(myconstructor: TypeController<Controller>): Route[];
 }
+/**
+ * Dit si le service `router` d'un contexte est le Router de
+ * `@nodefony/framework` — la garde qui rétrécit le contrat `IRequestRouter` de
+ * `@nodefony/http` sans conversion, pour qui lit des membres propres au
+ * framework (le Resolver complet que rend `resolve`).
+ *
+ * Lit la marque {@link FRAMEWORK_ROUTER}, jamais `instanceof` : deux copies
+ * installées du framework feraient échouer `instanceof` en silence. Une
+ * lecture de propriété.
+ *
+ * @param router - le routeur lu sur le contexte (`context.router`).
+ * @returns `true` si c'est le Router du framework.
+ */
+export declare function isFrameworkRouter(router: IRequestRouter | null | undefined): router is Router;
 export default Router;

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

@@ -105,27 +105,25 @@ declare class Controller extends Service implements IController {
     get method(): HTTPMethod | undefined;
     set method(method: HTTPMethod | undefined);
     /**
-     * Query string de l'appel en cours — pour un singleton invoqué par le pont
-     * `api.request`, celle du chemin INVOQUÉ (résolveur d'appel dans l'ALS), pas
-     * celle du handshake de la connexion. Une seule lecture de l'ALS.
+     * Paramètres d'URL de l'appel en cours — jamais le corps, qui reste dans
+     * {@link body}. Pour un singleton invoqué par le pont `api.request`,
+     * ceux du chemin INVOQUÉ (résolveur d'appel dans l'ALS), pas ceux du
+     * handshake de la connexion. Une seule lecture de l'ALS.
      */
-    get queryGet(): Record<string, unknown>;
-    set queryGet(value: Record<string, unknown>);
-    /** Comme {@link queryGet}, pour la query fusionnée (`query`). */
     get query(): Record<string, unknown>;
     set query(value: Record<string, unknown>);
-    get queryFile(): unknown[];
-    set queryFile(value: unknown[]);
-    get queryPost(): Record<string, unknown>;
-    set queryPost(value: Record<string, unknown>);
+    /**
+     * Les fichiers reçus dans un corps multipart (`UploadedFile`) ; les champs
+     * texte du même corps sont dans {@link body}. Pour une action typée,
+     * préférer `@UploadedFiles()`.
+     */
+    get files(): readonly unknown[];
+    set files(value: readonly unknown[]);
     /**
      * Le CORPS de la requête, parsé — nom universel de l'écosystème (Express,
-     * Fastify, NestJS), alias de {@link queryPost}.
-     *
-     * Ne pas confondre avec {@link query}, qui FUSIONNE la query string et le
-     * corps. Pour une action typée, préférer le décorateur `@Body()`.
-     *
-     * Getter (aucune allocation) : `queryPost` reste la source unique.
+     * Fastify, NestJS). Jamais un paramètre d'URL : ceux-là sont dans
+     * {@link query}, et les deux ne fusionnent pas. Pour une action typée,
+     * préférer le décorateur `@Body()`.
      */
     get body(): Record<string, unknown>;
     set body(value: Record<string, unknown>);

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

@@ -1,4 +1,5 @@
 import type { IAdminEndpoint } from "nodefony";
+import type { RoutePart } from "./routeSchema.js";
 /**
  * Endpoints « Playground » du data plane framework — la source de données de la
  * console vivante des controllers dans Studio (`/nodefony/playground`).
@@ -65,7 +66,18 @@ export interface PlaygroundAction {
     variables: string[];
     /** Défauts de variables (hors clé interne `controller`). */
     defaults: Record<string, unknown>;
+    /**
+     * Entrées de l'action. Pour une action à schéma, déduites du schéma (une
+     * entrée par champ de `query`/`headers`/`params`, une pour `body`) : le
+     * formulaire se construit pareil, quelle que soit la forme de l'action.
+     */
     params: PlaygroundParam[];
+    /**
+     * Le contrat d'une action à schéma — JSON Schema d'entrée de chaque partie
+     * déclarée (`null` quand la bibliothèque ne sait pas le décrire). `null`
+     * pour une action sans schéma.
+     */
+    schema: Partial<Record<RoutePart, Record<string, unknown> | null>> | null;
     guards: PlaygroundGuards;
 }
 /** Un controller et ses actions, groupés pour la navigation Studio. */