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

package/dist/nodefony/decorators/routerDecorators.js

@@ -1,8 +1,9 @@
+import { assertRouteSchemaShape } from "../src/routeSchema.js";
 import Controller from "../src/Controller.js";
 import router_default from "../service/router.js";
-import { RequestContext } from "nodefony";
+import { BootConfigurationError, RequestContext } from "nodefony";
 import "reflect-metadata";
-//#region nodefony/decorators/routerDecorators.ts
+// nodefony/decorators/routerDecorators.ts
 const metadataKey = "routes:definitions";
 /**
 * Noms déjà portés par `Controller` — méthodes ET accesseurs, les siens comme
@@ -134,7 +135,7 @@ function controller(prefix) {
 					const classBypass = Reflect.getMetadata(BYPASS_FIREWALL_CLASS_METADATA, mycontroller);
 					if (methodBypass === true || classBypass === true) options.bypassFirewall = true;
 				}
-				if (options.path == "*") {
+				if (options.path === "*") {
 					hasMagic = {
 						options,
 						name
@@ -149,26 +150,19 @@ function controller(prefix) {
 		return mycontroller;
 	};
 }
-/**
-* Crée une route avec le nom et les options spécifiés.
-*
-* @param name - Le nom de la route.
-* @param options - Les options de la route.
-* @returns Un décorateur de méthode qui peut être utilisé pour annoter une méthode de contrôleur.
-*
-* @example
-* \@route("myroute", {
-*   path: "/add/{name}",
-*   method: ["GET", "POST"],
-*   defaults: { name: "john" },
-* })
-* method(name: string) {
-*   return this.renderJson({ name });
-* }
-*/
 function route(name, options) {
+	return defineRoute(name, options);
+}
+/** L'implémentation de {@link route}, sans les surcharges de typage. */
+function defineRoute(name, options) {
 	return function(target, propertyKey, descriptor) {
 		assertActionNameFree(target, propertyKey);
+		if (options.schema !== void 0) {
+			const previous = Reflect.getOwnMetadata(ROUTE_SCHEMA_METADATA, target, propertyKey);
+			if (previous !== void 0 && previous !== options.schema) throw new BootConfigurationError(`${target.constructor.name}.${propertyKey} : deux routes de la même action déclarent des schémas différents — une action n'a qu'une entrée, déclarer le schéma une seule fois.`);
+			Reflect.defineMetadata(ROUTE_SCHEMA_METADATA, options.schema, target, propertyKey);
+		}
+		if (options.bodyStream === true) Reflect.defineMetadata(BODY_STREAM_METADATA, true, target, propertyKey);
 		const className = target.constructor.name;
 		const classMethod = propertyKey;
 		const prefix = options.prefix || null;
@@ -211,6 +205,10 @@ function extractControllerFilePath(stackTrace) {
 const HTTP_CODE_METADATA = "route:httpCode";
 const HEADERS_METADATA = "route:responseHeaders";
 const REDIRECT_METADATA = "route:redirect";
+/** Schéma d'entrée d'une action (`schema` d'une option de route) — par méthode. */
+const ROUTE_SCHEMA_METADATA = "route:schema";
+/** `bodyStream: true` d'une option de route — par méthode. */
+const BODY_STREAM_METADATA = "route:bodyStream";
 const PARAM_ARGS_METADATA = "route:paramArgs";
 const DOMAIN_CLASS_METADATA = "route:domainClass";
 const DOMAIN_METHOD_METADATA = "route:domainMethod";
@@ -232,7 +230,7 @@ function httpMethodDecorator(methods) {
 			const declaredMethods = options.requirements?.methods;
 			const added = declaredMethods === void 0 ? [] : Array.isArray(declaredMethods) ? declaredMethods : [declaredMethods];
 			const fusion = added.length > 0 ? [.../* @__PURE__ */ new Set([...methods, ...added])] : methods;
-			return route(name, {
+			return defineRoute(name, {
 				...options,
 				path,
 				requirements: {
@@ -255,14 +253,14 @@ const Head = httpMethodDecorator(["HEAD"]);
 * HTTP (équivalent NestJS `@All()`). N'émet aucun requirement `methods`, donc
 * `Route.matchRequirements` ne lève jamais 405 sur la méthode.
 */
-function All(path = "", options = {}) {
+const All = function(path = "", options = {}) {
 	return function(target, propertyKey, descriptor) {
-		return route(`${target.constructor.name}::${propertyKey}`, {
+		return defineRoute(`${target.constructor.name}::${propertyKey}`, {
 			...options,
 			path
 		})(target, propertyKey, descriptor);
 	};
-}
+};
 /**
 * Fixe le code de statut HTTP de la réponse d'une action.
 *
@@ -722,26 +720,18 @@ const Query = paramDecoratorFactory("query");
 *
 * ## 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).
+* `@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é.
 *
-* Où valider, donc :
+* 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.
 *
-* - **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.
-*
-* 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
@@ -778,6 +768,75 @@ const Res = paramDecoratorFactory("res");
 const UploadedFile = paramDecoratorFactory("file");
 const UploadedFiles = paramDecoratorFactory("files");
 /**
+* La query de l'invocation : celle du chemin INVOQUÉ par le pont WebSocket
+* (`queryOverride`), sinon celle de l'URL. Source UNIQUE de `@Query` et de
+* `input.query` d'une route à schéma.
+*/
+function readQuery(ctx) {
+	return readQueryOf(ctx.queryOverride, ctx.request);
+}
+/** {@link readQuery}, depuis ses deux sources. */
+function readQueryOf(queryOverride, request) {
+	return queryOverride ?? request?.query;
+}
+/**
+* Le corps DÉCODÉ de l'invocation — source UNIQUE de `@Body` et de
+* `input.body` d'une route à schéma, pour qu'un corps ne puisse pas prendre
+* deux sens selon la forme de l'action.
+*
+* Pont `api.request` (WS) : le corps d'une mutation voyage dans l'ALS (aucun
+* corps HTTP parsé sur une frame — posé par appel par
+* `RealtimeController.invokeApiRequest`, zéro fuite entre appels) et PRIME sur
+* `request.body` (vide en WS) — même priorité que
+* `AdminApiController.buildRequest`. En HTTP, le magasin ALS ne porte jamais
+* `body`. Aucune forme n'est supposée : un codec binaire y posera des octets.
+*/
+function readBody(ctx) {
+	return readInvocationBody(ctx.request);
+}
+/**
+* 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.
+*/
+function readInvocationBody(request) {
+	const alsBody = RequestContext.get()?.body;
+	return alsBody !== void 0 ? alsBody : request?.body;
+}
+/** Un champ d'une valeur décodée ; `undefined` si elle n'est pas un objet. */
+function readField(value, key) {
+	if (typeof value !== "object" || value === null) return void 0;
+	return Reflect.get(value, key);
+}
+/** Objet vide partagé : une partie absente n'alloue rien. Gelé, jamais muté. */
+const EMPTY_PART = Object.freeze({});
+/**
+* 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.
+*/
+function readRouteInput(paramsMap, request, queryOverride, bodyStream) {
+	return {
+		params: paramsMap,
+		query: readQueryOf(queryOverride, request) ?? EMPTY_PART,
+		body: bodyStream ? request?.request : readInvocationBody(request),
+		headers: request?.headers ?? EMPTY_PART
+	};
+}
+/**
 * Résout la valeur d'un unique paramètre décoré depuis le contexte de requête.
 *
 * @param meta - métadonnée posée par le décorateur (source + clé optionnelle)
@@ -788,15 +847,13 @@ function resolveParamArg(meta, ctx) {
 	switch (meta.source) {
 		case "param": return meta.key !== void 0 ? ctx.paramsMap[meta.key] : ctx.paramsMap;
 		case "query": {
-			const qg = ctx.queryOverride ?? ctx.request?.queryGet;
-			return meta.key !== void 0 ? qg?.[meta.key] : qg;
+			const q = readQuery(ctx);
+			return meta.key !== void 0 ? q?.[meta.key] : q;
 		}
 		case "body": {
 			if (meta.stream) return ctx.request?.request;
-			const alsBody = RequestContext.get()?.body;
-			if (alsBody !== void 0) return meta.key !== void 0 ? alsBody?.[meta.key] : alsBody;
-			const qp = ctx.request?.queryPost;
-			return meta.key !== void 0 ? qp?.[meta.key] : qp;
+			const body = readBody(ctx);
+			return meta.key !== void 0 ? readField(body, meta.key) : body;
 		}
 		case "headers": {
 			const h = ctx.request?.headers;
@@ -806,8 +863,8 @@ function resolveParamArg(meta, ctx) {
 		case "session": return meta.key !== void 0 ? ctx.session?.get(meta.key) : ctx.session;
 		case "req": return ctx.request;
 		case "res": return ctx.response;
-		case "file": return ctx.request?.queryFile?.[0];
-		case "files": return ctx.request?.queryFile;
+		case "file": return ctx.request?.files?.[0];
+		case "files": return ctx.request?.files;
 		case "user": return RequestContext.isAnonymous() ? void 0 : RequestContext.getUser();
 		default: return;
 	}
@@ -866,6 +923,48 @@ function getParamArgsMeta(proto, method) {
 	return metas !== void 0 && metas.length > 0 ? metas : 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é.
+*/
+function getRouteSchema(proto, method) {
+	const schema = Reflect.getMetadata(ROUTE_SCHEMA_METADATA, proto, method);
+	if (schema === void 0) return null;
+	assertRouteSchemaShape(schema, `${proto.constructor.name}.${method}`);
+	return schema;
+}
+/**
+* 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.
+*/
+function assertRouteSchemaDeclaration(routeDef) {
+	const ctor = routeDef.controller;
+	const method = routeDef.classMethod;
+	if (!ctor || !method) return;
+	const proto = ctor.prototype;
+	const raw = Reflect.getMetadata(ROUTE_SCHEMA_METADATA, proto, method);
+	if (raw === void 0) {
+		if (Reflect.getMetadata(BODY_STREAM_METADATA, proto, method) === true) throw new BootConfigurationError(`Route "${routeDef.name}" : « bodyStream: true » exige un « schema » — sans schéma, demander le flux par @Body({ stream: true }).`);
+		return;
+	}
+	assertRouteSchemaShape(raw, routeDef.name);
+	if (getParamArgsMeta(proto, method) !== null) throw new BootConfigurationError(`Route "${routeDef.name}" : une action à schéma reçoit un argument unique (input) — retirer les décorateurs de paramètre (@Body, @Query, @Param…) de ${proto.constructor.name}.${method}, ou retirer l'option « schema ».`);
+	if (raw.body !== void 0 && Reflect.getMetadata(BODY_STREAM_METADATA, proto, method) === true) throw new BootConfigurationError(`Route "${routeDef.name}" : « bodyStream: true » et « schema.body » s'excluent — un flux n'est pas lu, il ne peut pas être validé.`);
+}
+/**
 * 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
 * `route.bodyStream` : lecture `Reflect` au 1er appel, O(1) ensuite → 0 coût
@@ -880,13 +979,15 @@ function routeExpectsBodyStream(routeDef) {
 		let flag = false;
 		const ctor = routeDef.controller;
 		const method = routeDef.classMethod;
-		if (ctor && method) flag = (Reflect.getMetadata("route:paramArgs", ctor.prototype, method) ?? []).some((m) => m.source === "body" && m.stream === true);
+		if (ctor && method) flag = Reflect.getMetadata(BODY_STREAM_METADATA, ctor.prototype, method) === true || (getParamArgsMeta(ctor.prototype, method)?.some((m) => m.source === "body" && m.stream === true) ?? false);
 		routeDef.bodyStream = flag;
 	}
 	return routeDef.bodyStream;
 }
 const EMPTY_ACTION_META = {
 	paramsMeta: null,
+	schema: null,
+	bodyStream: false,
 	redirectMeta: null,
 	httpCode: null,
 	headerEntries: null,
@@ -988,6 +1089,8 @@ function computeActionMeta(ctor, method) {
 	const headers = Reflect.getMetadata(HEADERS_METADATA, proto, method);
 	return {
 		paramsMeta: getParamArgsMeta(proto, method),
+		schema: getRouteSchema(proto, method),
+		bodyStream: Reflect.getMetadata(BODY_STREAM_METADATA, proto, method) === true,
 		redirectMeta: redirect ?? null,
 		httpCode: httpCode ?? null,
 		headerEntries: headers ? Object.entries(headers) : null,
@@ -1073,5 +1176,4 @@ function computeAuthenticationRequirement(ctor, method) {
 		amr: Object.freeze([.../* @__PURE__ */ new Set([...onClass.amr, ...onMethod.amr])])
 	});
 }
-//#endregion
-export { All, Anonymous, BYPASS_FIREWALL_CLASS_METADATA, BYPASS_FIREWALL_METHOD_METADATA, Body, BypassFirewall, Cookie, Csp, CsrfExempt, CsrfProtect, CurrentUser, DOMAIN_CLASS_METADATA, DOMAIN_METHOD_METADATA, Delete, Domain, Get, HEADERS_METADATA, HTTP_CODE_METADATA, Head, Header, Headers, HttpCode, Idempotent, IsGranted, Options, PARAM_ARGS_METADATA, Param, Patch, Post, Put, Query, REDIRECT_METADATA, Redirect, Req, RequireAuthentication, RequireScope, Res, Scope, Session, USE_SESSION_CLASS_METADATA, USE_SESSION_METHOD_METADATA, UploadedFile, UploadedFiles, UseSession, buildContextParamArgs, buildParamArgs, computeActionMeta, controller, controllers, extractActionScopes, getParamArgsMeta, resolveActionMeta, resolveParamArg, resolveSessionIntent, route, routeExpectsBodyStream };
+export { All, Anonymous, BYPASS_FIREWALL_CLASS_METADATA, BYPASS_FIREWALL_METHOD_METADATA, Body, BypassFirewall, Cookie, Csp, CsrfExempt, CsrfProtect, CurrentUser, DOMAIN_CLASS_METADATA, DOMAIN_METHOD_METADATA, Delete, Domain, Get, HEADERS_METADATA, HTTP_CODE_METADATA, Head, Header, Headers, HttpCode, Idempotent, IsGranted, Options, PARAM_ARGS_METADATA, Param, Patch, Post, Put, Query, REDIRECT_METADATA, Redirect, Req, RequireAuthentication, RequireScope, Res, Scope, Session, USE_SESSION_CLASS_METADATA, USE_SESSION_METHOD_METADATA, UploadedFile, UploadedFiles, UseSession, assertRouteSchemaDeclaration, buildContextParamArgs, buildParamArgs, computeActionMeta, controller, controllers, extractActionScopes, getParamArgsMeta, getRouteSchema, readInvocationBody, readRouteInput, resolveActionMeta, resolveParamArg, resolveSessionIntent, route, routeExpectsBodyStream };

package/dist/nodefony/service/AdminBroker.js

@@ -1,9 +1,8 @@
-import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
 import router_default from "./router.js";
 import AdminApiController from "../controller/AdminApiController.js";
-import { ADMIN_DEFAULT_ROLE, Module, Service, injectable, resolveAdminRole } from "nodefony";
-//#region nodefony/service/AdminBroker.ts
+import { ADMIN_DEFAULT_ROLE, Service, injectable, resolveAdminRole } from "nodefony";
+// nodefony/service/AdminBroker.ts
 const serviceName = "adminBroker";
 /**
 * Implémentation du data plane admin (Studio) — collecte les {@link IAdminApi}
@@ -101,7 +100,6 @@ let AdminBroker = class AdminBroker extends Service {
 		return this.get("router");
 	}
 };
-AdminBroker = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module])], AdminBroker);
+AdminBroker = __decorate([injectable()], AdminBroker);
 var AdminBroker_default = AdminBroker;
-//#endregion
 export { AdminBroker_default as default };

package/dist/nodefony/service/Eta.js

@@ -2,7 +2,7 @@ import Template from "../src/Template.js";
 import { extend, injectable } from "nodefony";
 import { readFile } from "node:fs/promises";
 import { Eta as Eta$1 } from "eta";
-//#region nodefony/service/Eta.ts
+// nodefony/service/Eta.ts
 /**
 * Options par défaut du moteur Eta.
 *
@@ -64,5 +64,4 @@ var Eta = class extends Template {
 		}
 	}
 };
-//#endregion
 export { Eta as default };

package/dist/nodefony/service/IdempotencyStore.js

@@ -1,7 +1,6 @@
-import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
-import { Module, Service, assertPageQuery, injectable } from "nodefony";
-//#region nodefony/service/IdempotencyStore.ts
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
+import { Service, assertPageQuery, injectable } from "nodefony";
+// nodefony/service/IdempotencyStore.ts
 const serviceName = "idempotencyStore";
 /** Réponses mémorisées : 10 min (un rejeu plausible reste dans cette fenêtre). */
 const DEFAULT_TTL_MS = 6e5;
@@ -129,7 +128,6 @@ let MemoryIdempotencyStore = class MemoryIdempotencyStore extends Service {
 		}
 	}
 };
-MemoryIdempotencyStore = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module])], MemoryIdempotencyStore);
+MemoryIdempotencyStore = __decorate([injectable()], MemoryIdempotencyStore);
 var IdempotencyStore_default = MemoryIdempotencyStore;
-//#endregion
 export { IdempotencyStore_default as default };

package/dist/nodefony/service/router.js

@@ -1,13 +1,12 @@
 import Route from "../src/Route.js";
-import { routeExpectsBodyStream } from "../decorators/routerDecorators.js";
+import { assertRouteSchemaDeclaration, routeExpectsBodyStream } from "../decorators/routerDecorators.js";
 import Resolver from "../src/Resolver.js";
-import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
-import { Injector, Module, Service, injectable, isPromise, stripTrailingSlashes } from "nodefony";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
+import { BootConfigurationError, Injector, Module, Service, injectable, isPromise, stripTrailingSlashes } from "nodefony";
 import { HttpError, isDomainAllowed } from "@nodefony/http";
-//#region nodefony/service/router.ts
+// nodefony/service/router.ts
 var _Router;
-let routeNoticePromoted = null;
+let routeMatchLogged = null;
 /**
 * Méthodes que sert une route — lues sur le `methodsSet` COMPILÉ par
 * `Route.compileRequirements`, jamais recalculées depuis la config brute.
@@ -92,10 +91,21 @@ function indexRoute(route, i, statics, dynamics) {
 		prefix: literalPrefix(path)
 	});
 }
+/**
+* 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.
+*/
+const FRAMEWORK_ROUTER = Symbol.for("nodefony.framework.router");
 let Router = class Router extends Service {
 	static {
 		_Router = this;
 	}
+	/** Marque {@link FRAMEWORK_ROUTER} — sur le prototype, aucun champ par instance. */
+	get [FRAMEWORK_ROUTER]() {
+		return true;
+	}
 	static routes = routes;
 	routes = _Router.routes;
 	singletonControllers = null;
@@ -167,7 +177,10 @@ let Router = class Router extends Service {
 	*   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, cleanPathOverride, methodOverride) {
 		const resolver = new Resolver(context);
@@ -200,8 +213,8 @@ let Router = class Router extends Service {
 			}
 			try {
 				if (resolver.match(route, context, cleanPath, fromLiterals)) {
-					routeNoticePromoted ??= this.kernel?.environment !== "production";
-					if (routeNoticePromoted) this.log(`Match route : ${route.name}`, "NOTICE");
+					routeMatchLogged ??= this.kernel?.environment !== "production";
+					if (routeMatchLogged) this.log(`Match route : ${route.name}`, "DEBUG");
 					resolver.exception = void 0;
 					routeExpectsBodyStream(route);
 					return resolver;
@@ -221,11 +234,13 @@ let Router = class Router extends Service {
 			}
 			const servesWebsocket = allowed.delete("WEBSOCKET");
 			if (allowed.size === 0 && servesWebsocket) {
-				context.response?.setHeaders({
+				const req = context.request;
+				if ((req && "request" in req ? req.request : req)?.httpVersionMajor !== 2) context.response?.setHeaders({
 					Upgrade: "websocket",
 					Connection: "Upgrade"
 				});
-				throw new HttpError("Upgrade Required: websocket", 426, context);
+				resolver.exception = new HttpError("Upgrade Required: websocket", 426, context);
+				return resolver;
 			}
 			if (allowed.size > 0) {
 				const allowHeader = Array.from(allowed).join(", ");
@@ -276,6 +291,7 @@ let Router = class Router extends Service {
 		}
 	}
 	static createRoute(name, obj) {
+		if ("schema" in obj || "bodyStream" in obj) throw new BootConfigurationError(`Route "${name}" : « schema » et « bodyStream » se déclarent par un décorateur de route (@Get, @Post, @route…), pas par createRoute.`);
 		const routenew = new Route(name, obj);
 		routes.push(routenew);
 		invalidateRouteIndex();
@@ -307,7 +323,10 @@ let Router = class Router extends Service {
 		});
 		const key = `${module.name}:${myconstructor.name}`;
 		if (Module.controllers[key]) module.log(/* @__PURE__ */ new Error(`Controller already exist ${key}`), "WARNING");
-		for (const r of routes) if (r.controller === myconstructor) r.module = { name: module.name };
+		for (const r of routes) if (r.controller === myconstructor) {
+			assertRouteSchemaDeclaration(r);
+			r.module = { name: module.name };
+		}
 		return Module.controllers[key] = myconstructor;
 	}
 	/**
@@ -319,7 +338,22 @@ let Router = class Router extends Service {
 		return routes.filter((r) => r.controller === myconstructor);
 	}
 };
-Router = _Router = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module])], Router);
+Router = _Router = __decorate([injectable()], Router);
+/**
+* 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.
+*/
+function isFrameworkRouter(router) {
+	return router != null && FRAMEWORK_ROUTER in router;
+}
 var router_default = Router;
-//#endregion
-export { router_default as default };
+export { FRAMEWORK_ROUTER, router_default as default, isFrameworkRouter };

package/dist/nodefony/src/Controller.js

@@ -3,7 +3,7 @@ import { FileClass, RequestContext, Service } from "nodefony";
 import { HttpContext, HttpError, acceptsEventStream } from "@nodefony/http";
 import fs, { createReadStream } from "node:fs";
 import { promisify } from "node:util";
-//#region nodefony/src/Controller.ts
+// nodefony/src/Controller.ts
 const fsClose = promisify(fs.close);
 /**
 * Un `<script>` EN LIGNE qui ne porte pas d'attribut `nonce`.
@@ -108,10 +108,9 @@ var Controller = class extends Service {
 	#request = null;
 	#response = null;
 	#method = null;
-	#queryGet = null;
 	#query = null;
-	#queryFile = null;
-	#queryPost = null;
+	#files = null;
+	#body = null;
 	module;
 	template;
 	/**
@@ -184,21 +183,11 @@ var Controller = class extends Service {
 		this.#method = method ?? null;
 	}
 	/**
-	* 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() {
-		if (this.#queryGet !== null) return this.#queryGet;
-		if (this.#context !== null) return this.#context.request?.queryGet;
-		const store = RequestContext.get();
-		return (store?.resolver)?.queryOverride ?? ((store?.context)?.request)?.queryGet;
-	}
-	set queryGet(value) {
-		this.#assertPerRequest("queryGet");
-		this.#queryGet = value;
-	}
-	/** Comme {@link queryGet}, pour la query fusionnée (`query`). */
 	get query() {
 		if (this.#query !== null) return this.#query;
 		if (this.#context !== null) return this.#context.request?.query;
@@ -209,35 +198,30 @@ var Controller = class extends Service {
 		this.#assertPerRequest("query");
 		this.#query = value;
 	}
-	get queryFile() {
-		return this.#queryFile ?? (this.context?.request)?.queryFile;
-	}
-	set queryFile(value) {
-		this.#assertPerRequest("queryFile");
-		this.#queryFile = value;
-	}
-	get queryPost() {
-		return this.#queryPost ?? (this.context?.request)?.queryPost;
+	/**
+	* 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() {
+		return this.#files ?? (this.context?.request)?.files;
 	}
-	set queryPost(value) {
-		this.#assertPerRequest("queryPost");
-		this.#queryPost = value;
+	set files(value) {
+		this.#assertPerRequest("files");
+		this.#files = value;
 	}
 	/**
 	* 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() {
-		return this.queryPost;
+		return this.#body ?? (this.context?.request)?.body;
 	}
 	set body(value) {
 		this.#assertPerRequest("body");
-		this.queryPost = value;
+		this.#body = value;
 	}
 	/**
 	* Session courante, ou `null`. Getter direct sur `context.session` (peuplé au
@@ -662,5 +646,4 @@ var Controller = class extends Service {
 		return this.streamFile(File, head, value);
 	}
 };
-//#endregion
 export { Controller as default, parseByteRange };