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

package/dist/nodefony/src/KernelAdminApi.js

@@ -2,10 +2,10 @@ import { CORE_PACKAGE, checkOutdated, countModuleDocs, listModuleDocs, listModul
 import { getResolvedPath, navigateSchemaNode, nodeFlags, notEditableReason, recipeFor, validateLeafValue } from "./configMutation.js";
 import { createRequire } from "node:module";
 import { join } from "node:path";
-import { GitService, Syslog, aggregateProvenance, collectDevStatus, computeConfigProvenance, defaultAppConfig, extractJsonSchemaDefaults, extractMarkdownSection, flattenConfigSchema, getActiveLogDriver, listLogDrivers, outlineMarkdown, parseNfEnvOverrides, parseStoreManifest, readResolvedPath, withResolvedPath } from "nodefony";
+import { GitService, Syslog, aggregateProvenance, collectDevStatus, collectEnvShortcuts, computeConfigProvenance, defaultAppConfig, extractJsonSchemaDefaults, extractMarkdownSection, flattenConfigSchema, getActiveLogDriver, isFrameworkRepository, listLogDrivers, outlineMarkdown, parseNfEnvOverrides, parseStoreManifest, readResolvedPath, redactUrlCredentials, resumeSupervisor, runAppContributions, suspendSupervisor, withResolvedPath } from "nodefony";
 import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
-//#region nodefony/src/KernelAdminApi.ts
+// nodefony/src/KernelAdminApi.ts
 /** Clé du pseudo-module core dans Studio (cf carte "Core" / `resolveCorePath`). */
 const CORE_KEY = "core";
 /** Racine projet — pour ne PAS exposer de chemin absolu (sécu). */
@@ -109,7 +109,7 @@ const SECRET_KEY = /(?:^|[a-z0-9])(secret|password|passwd|passphrase|credential|
 function safeConfig(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
 	if (typeof value === "function") return "[Function]";
 	if (typeof value === "bigint") return value.toString();
-	if (typeof value === "string") return stripAbs(value);
+	if (typeof value === "string") return stripAbs(redactUrlCredentials(value));
 	if (value === null || typeof value !== "object") return value;
 	if (depth > 5) return "[depth limit]";
 	if (seen.has(value)) return "[Circular]";
@@ -204,13 +204,23 @@ function computeConfigEntry(key, mod, runtimePaths) {
 	const isApp = mod.isApp ?? false;
 	const seg = computeSeg(pkg, isApp);
 	const envKeys = {};
+	const shortcutPaths = [];
+	if (!isApp) for (const s of collectEnvShortcuts(schema)) {
+		const raw = process.env[s.env];
+		const file = process.env[`${s.env}_FILE`];
+		const fromFile = file !== void 0 && file !== "";
+		if ((raw === void 0 || raw === "") && !fromFile) continue;
+		const dotted = s.path.join(".").toLowerCase();
+		envKeys[dotted] = fromFile ? `${s.env}_FILE` : s.env;
+		shortcutPaths.push(dotted);
+	}
 	for (const o of parseNfEnvOverrides(process.env)) if (o.moduleSeg === seg) envKeys[o.path.join(".")] = o.envKey;
 	let provenance = null;
 	if (isApp) {
 		const envPaths = new Set(parseNfEnvOverrides(process.env).filter((o) => o.moduleSeg === "app").map((o) => o.path.join(".")));
 		provenance = computeConfigProvenance(opts, defaultAppConfig, envPaths);
 	} else if (schema) {
-		const envPaths = new Set(parseNfEnvOverrides(process.env).filter((o) => o.moduleSeg === seg).map((o) => o.path.join(".")));
+		const envPaths = /* @__PURE__ */ new Set([...shortcutPaths, ...parseNfEnvOverrides(process.env).filter((o) => o.moduleSeg === seg).map((o) => o.path.join("."))]);
 		provenance = computeConfigProvenance(opts, extractJsonSchemaDefaults(schema), envPaths);
 	}
 	if (provenance && runtimePaths?.size) {
@@ -235,7 +245,7 @@ function actorLabel(user) {
 	if (typeof u.getUserIdentifier === "function") try {
 		return u.getUserIdentifier();
 	} catch {}
-	return u.username ?? u.email ?? (u.id != null ? String(u.id) : null);
+	return u.identifier ?? u.email ?? (u.id != null ? String(u.id) : null);
 }
 /**
 * Journalise une mutation de config (catégorie `config`) **si** le service d'audit
@@ -337,6 +347,33 @@ function nodefonyPackageCandidates(name) {
 	const inScope = (pkg) => pkg === "nodefony" || pkg === "@nodefony/core" || pkg.startsWith("@nodefony/");
 	return (name.includes("/") ? [name] : [`@nodefony/${name}`, name]).filter(inScope);
 }
+/** Refus de `scaffold` hors développement. */
+const scaffoldRefused = () => ({
+	status: 403,
+	body: { error: "scaffold:sync is disabled outside development" }
+});
+/**
+* La réponse de `scaffold` : les rapports tels quels, et les totaux qu'un écran
+* affiche sans les recompter.
+*
+* @param reports - le rendu de `runAppContributions`
+* @param dryRun - `true` pour un plan
+* @returns le corps de la réponse
+*/
+function scaffoldPayload(reports, dryRun) {
+	const sum = (pick) => reports.reduce((n, r) => n + pick(r), 0);
+	return {
+		dryRun,
+		reports,
+		totals: {
+			written: sum((r) => r.written.length),
+			updated: sum((r) => r.updated.length),
+			outdated: sum((r) => r.outdated.length),
+			modified: sum((r) => r.modified.length),
+			failed: sum((r) => r.error === null ? 0 : 1)
+		}
+	};
+}
 function createKernelAdminApi(kernel) {
 	const descriptor = {
 		label: "Kernel",
@@ -376,6 +413,8 @@ function createKernelAdminApi(kernel) {
 	* @param key - clé courte (`http`) ou nom de paquet (`@nodefony/redis`).
 	* @returns le dossier à lire, ou `null`.
 	*/
+	let frameworkRepository = null;
+	const inFrameworkRepository = () => frameworkRepository ??= isFrameworkRepository(kernel.path);
 	const resolveDocDir = (key) => resolveTarget(key)?.path ?? resolvePackageDir(key);
 	/**
 	* Ce qu'on peut proposer à qui s'est trompé de nom — les clés qui répondent.
@@ -402,7 +441,6 @@ function createKernelAdminApi(kernel) {
 	const devGuard = () => kernel.environment === "development" || Boolean(kernel.debug);
 	const repoRoot = process.cwd();
 	const relPath = (p) => p?.startsWith(repoRoot) ? p.slice(repoRoot.length).replace(/^[/\\]+/, "") || "." : p ?? null;
-	const redactInfraUrl = (url) => url.replace(/\/\/[^/@]*@/, "//***@");
 	const buildConfigEntries = () => {
 		const modules = kernel.getModules();
 		const entries = [];
@@ -538,6 +576,30 @@ function createKernelAdminApi(kernel) {
 				git: GitService.read()
 			})
 		},
+		{
+			path: "scaffold",
+			summary: "Files delivered by installed packages (dev only) — what `scaffold:sync --update` would do",
+			handler: async () => {
+				if (!devGuard()) return scaffoldRefused();
+				return scaffoldPayload(await runAppContributions(REPO_ROOT, true, true), true);
+			}
+		},
+		{
+			path: "scaffold/sync",
+			method: "POST",
+			summary: "Run `scaffold:sync` (dev only) — body `{ update?: boolean }`",
+			handler: async (request) => {
+				if (!devGuard()) return scaffoldRefused();
+				const body = request.body;
+				const update = typeof body === "object" && body !== null && "update" in body && body.update === true;
+				suspendSupervisor(REPO_ROOT, "synchronisation des fichiers livrés", update ? "scaffold:sync --update" : "scaffold:sync");
+				try {
+					return scaffoldPayload(await runAppContributions(REPO_ROOT, false, update), false);
+				} finally {
+					resumeSupervisor(REPO_ROOT);
+				}
+			}
+		},
 		{
 			path: "processes",
 			summary: "Dev process topology (supervisor → server → Vite) + server ports — `nodefony status` over the data plane",
@@ -673,8 +735,8 @@ function createKernelAdminApi(kernel) {
 			handler: () => {
 				const infra = kernel.infra;
 				const entriesBySeg = new Map(buildConfigEntries().map((e) => [e.seg, e]));
-				const dbUrl = infra.database ? redactInfraUrl(infra.database.url) : null;
-				const cacheUrl = infra.cache ? redactInfraUrl(infra.cache.url) : null;
+				const dbUrl = infra.database ? redactUrlCredentials(infra.database.url) : null;
+				const cacheUrl = infra.cache ? redactUrlCredentials(infra.cache.url) : null;
 				const storeEndpoint = (res) => {
 					if (res.location) return void 0;
 					if (res.resolved === "redis") return cacheUrl ?? void 0;
@@ -713,8 +775,8 @@ function createKernelAdminApi(kernel) {
 						} : null,
 						cache: infra.cache ? { url: cacheUrl } : null,
 						logs: infra.logs ? {
-							lokiUrl: infra.logs.lokiUrl ? redactInfraUrl(infra.logs.lokiUrl) : null,
-							opensearchUrl: infra.logs.opensearchUrl ? redactInfraUrl(infra.logs.opensearchUrl) : null
+							lokiUrl: infra.logs.lokiUrl ? redactUrlCredentials(infra.logs.lokiUrl) : null,
+							opensearchUrl: infra.logs.opensearchUrl ? redactUrlCredentials(infra.logs.opensearchUrl) : null
 						} : null
 					},
 					stores: kernel.storeResolutions.map((res) => {
@@ -927,7 +989,7 @@ function createKernelAdminApi(kernel) {
 						services: [],
 						config: {},
 						configSchema: null,
-						docsCount: await countModuleDocs(core.path),
+						docsCount: await countModuleDocs(core.path, inFrameworkRepository()),
 						symbolsCount: (await listModuleSymbols(CORE_PACKAGE)).length,
 						coverageLines: (await readCoverage(core.path)).total?.lines ?? null
 					};
@@ -959,7 +1021,7 @@ function createKernelAdminApi(kernel) {
 					provenance: cfg.provenance,
 					seg: cfg.seg,
 					envKeys: cfg.envKeys,
-					docsCount: await countModuleDocs(mod.path),
+					docsCount: await countModuleDocs(mod.path, inFrameworkRepository()),
 					symbolsCount: (await listModuleSymbols(cfg.name)).length,
 					coverageLines: (await readCoverage(mod.path)).total?.lines ?? null
 				};
@@ -1020,7 +1082,7 @@ function createKernelAdminApi(kernel) {
 				};
 				return {
 					key,
-					docs: await listModuleDocs(dir)
+					docs: await listModuleDocs(dir, false, inFrameworkRepository())
 				};
 			}
 		},
@@ -1038,14 +1100,14 @@ function createKernelAdminApi(kernel) {
 						available: docKeys()
 					}
 				};
-				const doc = await readModuleDoc(dir, request.params.slug ?? "");
+				const doc = await readModuleDoc(dir, request.params.slug ?? "", inFrameworkRepository());
 				if (!doc) return {
 					status: 404,
 					body: {
 						error: "Doc not found",
 						key,
 						slug: request.params.slug,
-						available: (await listModuleDocs(dir)).map((d) => d.slug)
+						available: (await listModuleDocs(dir, false, inFrameworkRepository())).map((d) => d.slug)
 					}
 				};
 				const wanted = typeof request.query.section === "string" ? request.query.section : "";
@@ -1085,7 +1147,7 @@ function createKernelAdminApi(kernel) {
 			handler: async () => {
 				const modules = [];
 				for (const target of docTargets()) {
-					const docs = await listModuleDocs(target.path);
+					const docs = await listModuleDocs(target.path, false, inFrameworkRepository());
 					if (docs.length > 0) modules.push({
 						key: target.key,
 						docs
@@ -1111,7 +1173,10 @@ function createKernelAdminApi(kernel) {
 					}
 				};
 				const limit = Number.parseInt(String(request.query.limit ?? ""), 10);
-				return searchModuleDocs(docTargets(), q, { limit: Number.isFinite(limit) && limit > 0 ? limit : void 0 });
+				return searchModuleDocs(docTargets(), q, {
+					limit: Number.isFinite(limit) && limit > 0 ? limit : void 0,
+					frameworkRepository: inFrameworkRepository()
+				});
 			}
 		},
 		{
@@ -1301,5 +1366,4 @@ function createKernelAdminApi(kernel) {
 		adminEndpoints: () => endpoints
 	};
 }
-//#endregion
 export { createKernelAdminApi, nodefonyPackageCandidates, safeConfig };

package/dist/nodefony/src/PlaygroundAdminApi.js

@@ -1,7 +1,8 @@
 import { extractActionScopes, resolveActionMeta } from "../decorators/routerDecorators.js";
 import router_default from "../service/router.js";
 import AdminApiController from "../controller/AdminApiController.js";
-//#region nodefony/src/PlaygroundAdminApi.ts
+import { standardJsonSchemaOf } from "nodefony";
+// nodefony/src/PlaygroundAdminApi.ts
 /** Normalise `requirements.methods` (string | string[]) → tableau majuscule. */
 function methodsOf(route) {
 	const m = route.requirements.methods ?? route.method;
@@ -15,11 +16,79 @@ function publicDefaults(route) {
 	for (const [k, v] of Object.entries(route.defaults)) if (k !== "controller") out[k] = v;
 	return out;
 }
+/** Source du formulaire pour chaque partie d'un schéma de route. */
+const PART_SOURCE = {
+	params: "param",
+	query: "query",
+	body: "body",
+	headers: "headers"
+};
+/** JSON Schema d'entrée d'un schéma, ou `null` s'il ne sait pas se décrire. */
+function describeSchema(schema) {
+	const converter = standardJsonSchemaOf(schema);
+	if (converter === null) return null;
+	try {
+		return converter.input({ target: "draft-2020-12" });
+	} catch {
+		return null;
+	}
+}
+/** Les champs de premier niveau d'un JSON Schema objet. */
+function propertiesOf(json) {
+	const properties = json?.properties;
+	return typeof properties === "object" && properties !== null ? Object.keys(properties) : [];
+}
+/**
+* Les entrées d'une action à schéma, au format des paramètres décorés, et le
+* contrat décrit partie par partie.
+*/
+function schemaParams(schema, bodyStream) {
+	const params = [];
+	const described = {};
+	for (const part of [
+		"params",
+		"query",
+		"body",
+		"headers"
+	]) {
+		const partSchema = schema[part];
+		if (partSchema === void 0) continue;
+		const json = describeSchema(partSchema);
+		described[part] = json;
+		const source = PART_SOURCE[part];
+		if (part === "body") {
+			params.push({
+				source,
+				key: null,
+				index: 0,
+				stream: false
+			});
+			continue;
+		}
+		for (const key of propertiesOf(json)) params.push({
+			source,
+			key,
+			index: 0,
+			stream: false
+		});
+	}
+	if (bodyStream) params.push({
+		source: "body",
+		key: null,
+		index: 0,
+		stream: true
+	});
+	return {
+		params,
+		described
+	};
+}
 /** Sérialise une route en action playground (métadonnées figées, JSON-safe). */
 function serializeAction(route) {
 	const meta = resolveActionMeta(route);
 	const methods = methodsOf(route);
 	const scopes = route.controller && route.classMethod ? extractActionScopes(route.controller, route.classMethod) : [];
+	const fromSchema = meta.schema !== null ? schemaParams(meta.schema, meta.bodyStream) : null;
 	return {
 		route: route.name,
 		path: route.path ?? null,
@@ -28,12 +97,13 @@ function serializeAction(route) {
 		action: route.classMethod ?? null,
 		variables: [...route.variables],
 		defaults: publicDefaults(route),
-		params: meta.paramsMeta?.map((p) => ({
+		params: fromSchema?.params ?? meta.paramsMeta?.map((p) => ({
 			source: p.source,
 			key: p.key ?? null,
 			index: p.index,
 			stream: p.stream === true
 		})).sort((a, b) => a.index - b.index) ?? [],
+		schema: fromSchema?.described ?? null,
 		guards: {
 			security: meta.security ? { clauses: meta.security.clauses.map((c) => ({
 				anyOf: [...c.anyOf],
@@ -93,5 +163,4 @@ function createPlaygroundEndpoints() {
 		handler: () => buildPlaygroundSnapshot()
 	}];
 }
-//#endregion
 export { buildPlaygroundSnapshot, createPlaygroundEndpoints };

package/dist/nodefony/src/RedisIdempotencyStore.js

@@ -1,5 +1,5 @@
 import { assertPageQuery } from "nodefony";
-//#region nodefony/src/RedisIdempotencyStore.ts
+// nodefony/src/RedisIdempotencyStore.ts
 /** Préfixe namespacé des clés d'idempotence dans Redis. */
 /**
 * Préfixe HISTORIQUE des clés d'idempotence. Utilisé tel quel par une application
@@ -42,6 +42,50 @@ function decodeCursor(cursor) {
 	};
 }
 /**
+* Reconstruit une entrée relue du store, ou `null` si sa forme est inattendue.
+* La valeur vient de Redis, pas de ce processus : une entrée « terminée » sans
+* réponse rejouerait `undefined` comme une réponse HTTP.
+*/
+function toEntry(v) {
+	if (typeof v !== "object" || v === null || !("s" in v) || !("f" in v)) return null;
+	const f = v.f;
+	if (typeof f !== "string") return null;
+	if (v.s === "if") return {
+		s: "if",
+		f
+	};
+	if (v.s !== "d" || !("r" in v)) return null;
+	const r = toResponse(v.r);
+	return r === null ? null : {
+		s: "d",
+		f,
+		r
+	};
+}
+/** Reconstruit une réponse mémorisée, ou `null` si sa forme est inattendue. */
+function toResponse(v) {
+	if (typeof v !== "object" || v === null || !("status" in v)) return null;
+	const status = v.status;
+	if (typeof status !== "number") return null;
+	const body = "body" in v ? v.body : void 0;
+	if (!("headers" in v) || v.headers === void 0) return {
+		status,
+		body
+	};
+	const headers = v.headers;
+	if (typeof headers !== "object" || headers === null) return null;
+	const copy = {};
+	for (const [name, value] of Object.entries(headers)) {
+		if (typeof value !== "string") return null;
+		copy[name] = value;
+	}
+	return {
+		status,
+		headers: copy,
+		body
+	};
+}
+/**
 * Store d'idempotence **Redis** (node-redis v6) — implémentation distribuée
 * d'{@link IIdempotencyStore} pour le cluster (dédup des mutations rejouées
 * PARTAGÉE cross-pod, là où l'impl mémoire par défaut reste affine à un pod).
@@ -183,8 +227,7 @@ var RedisIdempotencyStore = class {
 	#parse(raw) {
 		if (raw === null) return null;
 		try {
-			const v = JSON.parse(raw);
-			return v && (v.s === "if" || v.s === "d") ? v : null;
+			return toEntry(JSON.parse(raw));
 		} catch {
 			return null;
 		}
@@ -250,5 +293,4 @@ var RedisIdempotencyStore = class {
 		if (this.#pending > 0) this.#pending--;
 	}
 };
-//#endregion
 export { RedisIdempotencyStore };

package/dist/nodefony/src/Resolver.js

@@ -1,9 +1,11 @@
 import { guardSingletonState, isDevelopment } from "./singletonGuard.js";
-import { buildParamArgs, computeActionMeta, resolveActionMeta, resolveSessionIntent } from "../decorators/routerDecorators.js";
+import { validateRouteInput } from "./routeSchema.js";
+import { buildParamArgs, computeActionMeta, readInvocationBody, readRouteInput, resolveActionMeta, resolveSessionIntent } from "../decorators/routerDecorators.js";
 import { computeFingerprint, evaluateIdempotency, isMutationMethod, resolveIdempotencyKey, resolveIdentity } from "./idempotency.js";
+import { authenticationShortfall, stepUpChallenge } from "./requireAuthentication.js";
 import { RequestContext, finallyMaybe, identityHint, isArray, isPlainObject, isPromise, nodefonyError, thenMaybe, typeOf } from "nodefony";
 import { Http2Response, HttpResponse, WebsocketResponse } from "@nodefony/http";
-//#region nodefony/src/Resolver.ts
+// nodefony/src/Resolver.ts
 /**
 * Résout une route vers son couple controller/action et exécute l'action —
 * UN Resolver est alloué par requête HTTP (et par connexion WS, réutilisé
@@ -46,7 +48,7 @@ var Resolver = class {
 	/**
 	* Query d'une invocation **par message** (pont WS-RPC `api.request`) — pendant
 	* de `cleanPathOverride` pour le `?…` du path invoqué. Le contexte WS étant
-	* PARTAGÉ par la connexion (sa `queryGet` = celle du handshake), la query
+	* PARTAGÉ par la connexion (sa `query` = celle du handshake), la query
 	* per-invocation vit ici (le Resolver est per-invocation → zéro bleed entre
 	* requêtes concurrentes d'une même socket). `null` (hot path HTTP) = ignoré.
 	* Consommé par `@Query` (`_buildParamArgs`) et copié sur le controller
@@ -74,6 +76,11 @@ var Resolver = class {
 	* administrateurs.
 	*/
 	messageInvocation = false;
+	/**
+	* Les gardes de l'action ont été jugées favorables par {@link authorizeAction}
+	* et ne se rejugent pas à la prochaine exécution — consommé par elle.
+	*/
+	preAuthorized = false;
 	constructor(context) {
 		this.context = context;
 		this.injector = context.container?.get("injector") ?? null;
@@ -83,7 +90,7 @@ var Resolver = class {
 		if (match) {
 			this.variables = match;
 			this.route = route;
-			this.controller = route.controller;
+			this.controller = route.controller ?? null;
 			this.actionName = route.classMethod;
 			this.resolve = true;
 			this.bypassFirewall = this.route.bypassFirewall;
@@ -180,10 +187,20 @@ var Resolver = class {
 	* `instanceof` au message suivant — le hub était RÉINSTANCIÉ (DI +
 	* `initialize()`) à chaque frame qui suivait un `api.request`.
 	*
+	* Ni pour un `forward` sur une connexion WebSocket : son résolveur est neuf,
+	* pas une invocation par message, et réécrivait le pointeur que la poignée
+	* de main a posé — même réinstanciation à la frame suivante (#574). Une
+	* connexion garde le contrôleur qui l'a ouverte. Chemin froid : seulement
+	* quand un contrôleur est créé.
+	*
 	* @returns le controller reçu, pour enchaîner.
 	*/
 	_pinController(controller) {
-		if (!this.messageInvocation) this.context.container?.set("controller", controller);
+		if (this.messageInvocation) return controller;
+		const container = this.context.container;
+		if (!container) return controller;
+		if (this.context.method === "WEBSOCKET" && container.get("controller") !== null) return controller;
+		container.set("controller", controller);
 		return controller;
 	}
 	/**
@@ -220,7 +237,7 @@ var Resolver = class {
 	* @returns le controller reçu, pour enchaîner.
 	*/
 	_guardSingleton(controller, ctx) {
-		if (this.controller.scope === "singleton" && isDevelopment(ctx.kernel?.environment)) guardSingletonState(controller, controller.constructor.name);
+		if (this.controller?.scope === "singleton" && isDevelopment(ctx.kernel?.environment)) guardSingletonState(controller, controller.constructor.name);
 		return controller;
 	}
 	/**
@@ -245,9 +262,46 @@ var Resolver = class {
 	*/
 	executeAction(data, reload = false, metaArg) {
 		const meta = metaArg ?? (this.route ? resolveActionMeta(this.route) : computeActionMeta(this.controller, this.actionName));
+		let guarded;
+		if (this.preAuthorized) this.preAuthorized = false;
+		else guarded = this._enforceActionSecurity(meta);
+		const schema = meta.schema;
+		if (schema !== null) {
+			if (guarded !== void 0) return guarded.then(() => this._validateAndInvoke(schema, meta, data, reload));
+			return this._validateAndInvoke(schema, meta, data, reload);
+		}
+		if (guarded !== void 0) return guarded.then(() => this._acquireAndInvoke(meta, data, reload, null));
+		return this._acquireAndInvoke(meta, data, reload, null);
+	}
+	/**
+	* Valide l'entrée d'une action à schéma, puis l'exécute avec cette entrée
+	* pour argument unique. Synchrone tant que le validateur l'est.
+	*
+	* @throws SchemaValidationError (422) quand l'entrée viole le schéma.
+	*/
+	_validateAndInvoke(schema, meta, data, reload) {
+		const validated = validateRouteInput(schema, readRouteInput(this._zipRouteParams(), this.context.request, this.queryOverride ?? void 0, meta.bodyStream));
+		if (validated instanceof Promise) return validated.then((input) => this._acquireAndInvoke(meta, data, reload, input));
+		return this._acquireAndInvoke(meta, data, reload, validated);
+	}
+	/**
+	* Juge les gardes de l'action résolue SANS l'exécuter — appelé par le
+	* pipeline WebSocket AVANT d'accepter le handshake (#596), pour qu'un
+	* connecté sans le rôle reçoive son 403 en statut HTTP au lieu d'une
+	* ouverture suivie d'une fermeture. Un verdict favorable vaut pour la
+	* PROCHAINE exécution (l'action de handshake), qui ne le rejuge pas ; les
+	* messages suivants, eux, sont jugés chacun.
+	*
+	* @returns `undefined` quand l'action n'est pas gardée ; sinon la promesse du
+	*   verdict, rompue par un refus
+	*/
+	authorizeAction() {
+		const meta = this.route ? resolveActionMeta(this.route) : computeActionMeta(this.controller, this.actionName);
 		const guarded = this._enforceActionSecurity(meta);
-		if (guarded !== void 0) return guarded.then(() => this._acquireAndInvoke(meta, data, reload));
-		return this._acquireAndInvoke(meta, data, reload);
+		if (guarded === void 0) return void 0;
+		return guarded.then(() => {
+			this.preAuthorized = true;
+		});
 	}
 	/**
 	* Les gardes d'autorisation d'une action : `@IsGranted`/`@RequireScope`, puis
@@ -263,6 +317,7 @@ var Resolver = class {
 	*   lookup, ni attente) ; sinon la promesse du verdict, rompue par un refus.
 	*/
 	_enforceActionSecurity(meta) {
+		if (meta.authentication !== null) return this._enforceStepUp(meta);
 		if (meta.security === null) return this._enforceAreaSecurity();
 		const granted = this._enforceSecurity(meta.security);
 		return meta.security.hasRoleClause ? granted : granted.then(() => this._enforceAreaSecurity());
@@ -284,10 +339,10 @@ var Resolver = class {
 	* c'est la bonne classe, sinon une création —, puis l'action elle-même.
 	* N'attend que la création, et seulement quand elle attend.
 	*/
-	_acquireAndInvoke(meta, data, reload) {
+	_acquireAndInvoke(meta, data, reload, input) {
 		const pinned = this.context.container?.get("controller");
-		if (!pinned || reload || this.controller && !(pinned instanceof this.controller)) return thenMaybe(this.newController(), (controller) => this._invokeAction(controller, meta, data));
-		return this._invokeAction(pinned, meta, data);
+		if (!pinned || reload || this.controller && !(pinned instanceof this.controller)) return thenMaybe(this.newController(), (controller) => this._invokeAction(controller, meta, data, input));
+		return this._invokeAction(pinned, meta, data, input);
 	}
 	/**
 	* Appelle l'action sur l'instance : état de requête (portée `request`
@@ -296,17 +351,15 @@ var Resolver = class {
 	*
 	* @throws de façon SYNCHRONE ce que lève l'action, ou l'absence d'action.
 	*/
-	_invokeAction(controller, meta, data) {
+	_invokeAction(controller, meta, data, input) {
 		if (this.controller?.scope !== "singleton") {
 			controller.setRoute(this.route);
-			if (this.queryOverride !== null) {
-				controller.queryGet = this.queryOverride;
-				controller.query = this.queryOverride;
-			}
+			if (this.queryOverride !== null) controller.query = this.queryOverride;
 		}
 		const methodKey = this.actionName;
 		let args;
-		if (meta.paramsMeta) args = this._buildParamArgs(meta.paramsMeta);
+		if (input !== null) args = [input];
+		else if (meta.paramsMeta) args = this._buildParamArgs(meta.paramsMeta);
 		else if (data) args = [...this.variables, ...data];
 		else args = [...this.variables];
 		this._applyResponseMeta(meta);
@@ -381,18 +434,18 @@ var Resolver = class {
 		const als = RequestContext.get();
 		const httpReq = context.request;
 		const params = this._zipRouteParams();
-		const body = als?.body !== void 0 ? als.body : httpReq?.queryPost ?? null;
+		const body = readInvocationBody(httpReq) ?? null;
 		const store = context.container?.get("idempotencyStore");
 		const verdict = await evaluateIdempotency({
 			store,
-			identity: resolveIdentity(als?.user),
+			identity: resolveIdentity(),
 			clientKey: resolveIdempotencyKey(als?.idempotencyKey, httpReq?.headers?.["idempotency-key"]),
 			fingerprint: computeFingerprint([
 				this.route?.name ?? this.actionName,
 				params,
 				body
 			]),
-			isWs: Boolean(context.type?.startsWith("websocket")),
+			isWs: context.type === "websocket",
 			required: meta.idempotent?.required ?? true
 		});
 		if (verdict.kind === "reject") throw new nodefonyError(verdict.message, verdict.status);
@@ -526,16 +579,14 @@ var Resolver = class {
 		return idx === -1 ? void 0 : this.variables[idx];
 	}
 	_buildParamArgs(metas) {
-		const httpCtx = this.context;
-		const paramsMap = this._zipRouteParams();
-		const ctx = this.context;
+		const context = this.context;
 		return buildParamArgs(metas, {
-			paramsMap,
-			request: httpCtx.request,
-			response: httpCtx.response,
-			session: ctx.session,
+			paramsMap: this._zipRouteParams(),
+			request: context.request,
+			response: context.response,
+			session: context.session,
 			queryOverride: this.queryOverride ?? void 0,
-			getRequestCookies: (name) => ctx.getRequestCookies(name)
+			getRequestCookies: (name) => context.getRequestCookies(name)
 		});
 	}
 	/**
@@ -617,17 +668,11 @@ var Resolver = class {
 					return this.context.render(result);
 				}
 				switch (this.context.type) {
-					case "http":
-					case "http2":
-					case "http3":
-					case "https": this.context.waitAsync = true;
+					case "http": this.context.waitAsync = true;
 				}
 				return;
 			default: switch (this.context.type) {
 				case "http":
-				case "http2":
-				case "http3":
-				case "https":
 					if (this.context.sended) return;
 					if (this.context.isRedirect) return this.context.send();
 					if (NO_BODY_STATUS.has(this.getResponseStatus())) return this.context.send();
@@ -639,6 +684,31 @@ var Resolver = class {
 	getResponseStatus() {
 		return this.context.response?.statusCode ?? 0;
 	}
+	/**
+	* `@RequireAuthentication` — les gardes d'autorisation d'abord (un rôle
+	* absent reste un 403 définitif : inutile de faire redemander une connexion à
+	* qui n'aura pas le droit), PUIS l'âge et les moyens de la connexion.
+	*
+	* Le refus est un 401 « step-up » (RFC 9470) : le `WWW-Authenticate` porte
+	* `error="insufficient_user_authentication"` et, quand la route fixe un âge,
+	* `max_age` — le client redemande une connexion au lieu de conclure à un
+	* accès fermé. Cold path : seules les routes décorées y passent.
+	*
+	* @throws nodefonyError 401 si la connexion est trop ancienne ou trop faible.
+	*/
+	async _enforceStepUp(meta) {
+		const requirement = meta.authentication;
+		if (requirement === null) return;
+		await this._enforceActionSecurity({
+			...meta,
+			authentication: null
+		});
+		const cause = authenticationShortfall(this.context.session ?? null, requirement, Date.now());
+		if (cause === null) return;
+		const response = this.context.response;
+		if (response !== null && "setHeader" in response) response.setHeader("WWW-Authenticate", stepUpChallenge(requirement));
+		throw new nodefonyError(identityHint(this.context.kernel) === null ? "Authentication required" : `Authentication required — ${cause}. Reconnectez-vous (\`@RequireAuthentication\` de la route).`, 401);
+	}
 };
 /** Statuts dont la réponse n'a, par définition, pas de corps (RFC 9110). */
 const NO_BODY_STATUS = /* @__PURE__ */ new Set([
@@ -646,5 +716,4 @@ const NO_BODY_STATUS = /* @__PURE__ */ new Set([
 	205,
 	304
 ]);
-//#endregion
 export { Resolver as default };