@nodefony/framework 10.0.0-beta.2 → 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;
@@ -183,7 +177,7 @@ function route(name, options) {
 		} catch (error) {
 			filePath = error;
 		}
-		const metadata = Reflect.getMetadata(metadataKey, target.constructor) ?? {};
+		const metadata = { ...Reflect.getMetadata(metadataKey, target.constructor) };
 		metadata[name] = {
 			path,
 			filePath,
@@ -195,7 +189,8 @@ function route(name, options) {
 			host: options.host,
 			defaults: options.defaults,
 			requirements: options.requirements,
-			bypassFirewall: options.bypassFirewall
+			bypassFirewall: options.bypassFirewall,
+			fallback: options.fallback
 		};
 		Reflect.defineMetadata(metadataKey, metadata, target.constructor);
 		return descriptor;
@@ -210,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";
@@ -231,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: {
@@ -254,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.
 *
@@ -312,7 +311,7 @@ function HttpCode(statusCode) {
 */
 function Header(key, value) {
 	return function(target, propertyKey, descriptor) {
-		const existing = Reflect.getMetadata("route:responseHeaders", target, propertyKey) ?? {};
+		const existing = { ...Reflect.getMetadata(HEADERS_METADATA, target, propertyKey) };
 		existing[key] = value;
 		Reflect.defineMetadata(HEADERS_METADATA, existing, target, propertyKey);
 		return descriptor;
@@ -522,12 +521,12 @@ function IsGranted(attribute, options) {
 	};
 	return function(target, propertyKey, descriptor) {
 		if (propertyKey === void 0) {
-			const existing = Reflect.getMetadata(SECURITY_CLAUSES_METADATA, target) ?? [];
+			const existing = [...Reflect.getMetadata(SECURITY_CLAUSES_METADATA, target) ?? []];
 			existing.push(clause);
 			Reflect.defineMetadata(SECURITY_CLAUSES_METADATA, existing, target);
 			return target;
 		}
-		const existing = Reflect.getMetadata(SECURITY_CLAUSES_METADATA, target, propertyKey) ?? [];
+		const existing = [...Reflect.getMetadata(SECURITY_CLAUSES_METADATA, target, propertyKey) ?? []];
 		existing.push(clause);
 		Reflect.defineMetadata(SECURITY_CLAUSES_METADATA, existing, target, propertyKey);
 		return descriptor;
@@ -578,12 +577,12 @@ function RequireScope(scope) {
 	const clause = { anyOf: Array.isArray(scope) ? [...scope] : [scope] };
 	return function(target, propertyKey, descriptor) {
 		if (propertyKey === void 0) {
-			const existing = Reflect.getMetadata(SECURITY_SCOPES_METADATA, target) ?? [];
+			const existing = [...Reflect.getMetadata(SECURITY_SCOPES_METADATA, target) ?? []];
 			existing.push(clause);
 			Reflect.defineMetadata(SECURITY_SCOPES_METADATA, existing, target);
 			return target;
 		}
-		const existing = Reflect.getMetadata(SECURITY_SCOPES_METADATA, target, propertyKey) ?? [];
+		const existing = [...Reflect.getMetadata(SECURITY_SCOPES_METADATA, target, propertyKey) ?? []];
 		existing.push(clause);
 		Reflect.defineMetadata(SECURITY_SCOPES_METADATA, existing, target, propertyKey);
 		return descriptor;
@@ -700,7 +699,7 @@ function Idempotent(options) {
 function paramDecoratorFactory(source) {
 	return function(key) {
 		return function(target, propertyKey, parameterIndex) {
-			const existing = Reflect.getMetadata("route:paramArgs", target, propertyKey) ?? [];
+			const existing = Reflect.getOwnMetadata("route:paramArgs", target, propertyKey) ?? [];
 			existing.push({
 				source,
 				key,
@@ -721,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).
-*
-* 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
@@ -756,7 +747,7 @@ function Body(keyOrOptions) {
 	const key = isOptions ? void 0 : raw ?? void 0;
 	const stream = isOptions ? raw.stream === true : false;
 	return function(target, propertyKey, parameterIndex) {
-		const existing = Reflect.getMetadata("route:paramArgs", target, propertyKey) ?? [];
+		const existing = Reflect.getOwnMetadata("route:paramArgs", target, propertyKey) ?? [];
 		const meta = {
 			source: "body",
 			key,
@@ -777,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)
@@ -787,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;
@@ -805,9 +863,9 @@ 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 "user": return RequestContext.getUser();
+		case "file": return ctx.request?.files?.[0];
+		case "files": return ctx.request?.files;
+		case "user": return RequestContext.isAnonymous() ? void 0 : RequestContext.getUser();
 		default: return;
 	}
 }
@@ -826,6 +884,87 @@ function buildParamArgs(metas, ctx) {
 	return result;
 }
 /**
+* Résout les paramètres décorés d'une action depuis un `Context` — la mise en
+* forme UNIQUE, appelée par le Resolver (routes HTTP et WS) comme par les
+* actions `@RealtimeAction`, pour qu'un décorateur ne puisse pas prendre deux
+* sens selon le transport.
+*
+* Le corps d'un appel WebSocket voyage dans l'ALS (`RequestContext` clé
+* `body`) et `@CurrentUser` y lit l'utilisateur : l'appelant pose la bulle,
+* cette fonction n'en crée aucune.
+*
+* @param metas - paramètres décorés de l'action ({@link getParamArgsMeta})
+* @param context - le contexte de la requête ou de la connexion
+* @param paramsMap - variables de route nommées (vide hors route)
+* @param queryOverride - query de l'invocation quand elle ne vient pas de l'URL
+* @returns arguments positionnels à passer à l'action
+*/
+function buildContextParamArgs(metas, context, paramsMap, queryOverride) {
+	return buildParamArgs(metas, {
+		paramsMap,
+		request: context.request,
+		response: context.response,
+		session: context.session,
+		queryOverride,
+		getRequestCookies: (name) => context.getRequestCookies(name)
+	});
+}
+/**
+* Les paramètres décorés d'une méthode (`@Body`, `@CurrentUser`…), ou `null`
+* si elle n'en porte aucun. 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 les métadonnées, ou `null` — une action sans décorateur ne paie rien
+*/
+function getParamArgsMeta(proto, method) {
+	const metas = Reflect.getMetadata(PARAM_ARGS_METADATA, 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
@@ -840,18 +979,21 @@ 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,
 	sessionIntent: null,
 	security: null,
+	authentication: null,
 	cspDirectives: null,
 	csrfProtect: false,
 	csrfExempt: false,
@@ -942,17 +1084,19 @@ function computeIdempotent(ctor, method) {
 function computeActionMeta(ctor, method) {
 	if (!ctor || !method) return EMPTY_ACTION_META;
 	const proto = ctor.prototype;
-	const params = Reflect.getMetadata(PARAM_ARGS_METADATA, proto, method);
 	const redirect = Reflect.getMetadata(REDIRECT_METADATA, proto, method);
 	const httpCode = Reflect.getMetadata(HTTP_CODE_METADATA, proto, method);
 	const headers = Reflect.getMetadata(HEADERS_METADATA, proto, method);
 	return {
-		paramsMeta: params && params.length > 0 ? params : null,
+		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,
 		sessionIntent: resolveSessionIntent(ctor, method),
 		security: computeSecurityRequirement(ctor, method),
+		authentication: computeAuthenticationRequirement(ctor, method),
 		cspDirectives: computeCspDirectives(ctor, method),
 		csrfProtect: Reflect.getMetadata(CSRF_PROTECT_METADATA, proto, method) === true || Reflect.getMetadata(CSRF_PROTECT_METADATA, ctor) === true,
 		csrfExempt: Reflect.getMetadata(CSRF_EXEMPT_METADATA, proto, method) === true || Reflect.getMetadata(CSRF_EXEMPT_METADATA, ctor) === true,
@@ -972,5 +1116,64 @@ function resolveActionMeta(routeDef) {
 	routeDef.actionMeta ??= computeActionMeta(routeDef.controller, routeDef.classMethod);
 	return routeDef.actionMeta;
 }
-//#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, RequireScope, Res, Scope, Session, USE_SESSION_CLASS_METADATA, USE_SESSION_METHOD_METADATA, UploadedFile, UploadedFiles, UseSession, buildParamArgs, computeActionMeta, controller, controllers, extractActionScopes, resolveActionMeta, resolveParamArg, resolveSessionIntent, route, routeExpectsBodyStream };
+const AUTHENTICATION_REQUIREMENT_METADATA = "nodefony:security:authentication";
+/**
+* Exige une connexion RÉCENTE et/ou faite avec certains moyens pour l'action
+* (décorateur de méthode) ou tout le contrôleur (décorateur de classe).
+*
+* - `@RequireAuthentication({ maxAge: 300 })` — connexion de moins de 5 minutes.
+* - `@RequireAuthentication({ amr: ["otp"] })` — second facteur exigé.
+* - les deux se combinent ; classe + méthode fusionnent au plus strict.
+*
+* Lit ce que la session a retenu à son ouverture (`readSessionAuthentication`,
+* ADR-0015) et s'évalue dans le `Resolver` APRÈS `@IsGranted` : un rôle absent
+* reste un 403 définitif, une connexion trop ancienne ou trop faible devient un
+* **401** dont le `WWW-Authenticate` porte
+* `error="insufficient_user_authentication"` (RFC 9470) — le client sait qu'il
+* doit redemander une connexion, pas que l'accès lui est fermé. Une session qui
+* ne porte pas ces métadonnées est refusée, jamais acceptée.
+*
+* @param options - âge maximal et moyens exigés.
+* @throws TypeError si `maxAge` n'est pas un entier positif ou si un moyen est vide.
+*/
+function RequireAuthentication(options = {}) {
+	const { maxAge, amr = [] } = options;
+	if (maxAge !== void 0 && (!Number.isInteger(maxAge) || maxAge <= 0)) throw new TypeError(`@RequireAuthentication : maxAge doit être un entier de secondes > 0, reçu ${String(maxAge)}`);
+	if (amr.some((m) => typeof m !== "string" || m.length === 0)) throw new TypeError("@RequireAuthentication : chaque moyen de `amr` est une chaîne non vide (RFC 8176 : pwd, otp, pop)");
+	const requirement = Object.freeze({
+		maxAge: maxAge ?? null,
+		amr: Object.freeze([...amr])
+	});
+	return function(target, propertyKey, descriptor) {
+		if (propertyKey === void 0) {
+			Reflect.defineMetadata(AUTHENTICATION_REQUIREMENT_METADATA, requirement, target);
+			return target;
+		}
+		Reflect.defineMetadata(AUTHENTICATION_REQUIREMENT_METADATA, requirement, target, propertyKey);
+		return descriptor;
+	};
+}
+/** Une métadonnée lue par `Reflect` qui a bien la forme d'une exigence, sinon `undefined`. */
+function asAuthenticationRequirement(value) {
+	return typeof value === "object" && value !== null && "maxAge" in value && "amr" in value && (value.maxAge === null || typeof value.maxAge === "number") && Array.isArray(value.amr) ? {
+		maxAge: value.maxAge,
+		amr: value.amr.filter((m) => typeof m === "string")
+	} : void 0;
+}
+/**
+* Fusionne les `@RequireAuthentication` de classe et de méthode au plus strict,
+* ou `null` si aucune — `@Anonymous` (méthode) rend l'action publique.
+*/
+function computeAuthenticationRequirement(ctor, method) {
+	if (Reflect.getMetadata(SECURITY_ANONYMOUS_METADATA, ctor, method) === true) return null;
+	const onMethod = asAuthenticationRequirement(Reflect.getMetadata(AUTHENTICATION_REQUIREMENT_METADATA, ctor.prototype, method));
+	const onClass = Reflect.getMetadata(SECURITY_ANONYMOUS_METADATA, ctor) === true ? void 0 : asAuthenticationRequirement(Reflect.getMetadata(AUTHENTICATION_REQUIREMENT_METADATA, ctor));
+	if (onMethod === void 0) return onClass ?? null;
+	if (onClass === void 0) return onMethod;
+	const ages = [onClass.maxAge, onMethod.maxAge].filter((age) => age !== null);
+	return Object.freeze({
+		maxAge: ages.length > 0 ? Math.min(...ages) : null,
+		amr: Object.freeze([.../* @__PURE__ */ new Set([...onClass.amr, ...onMethod.amr])])
+	});
+}
+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.152.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.152.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.152.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.152.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 };