@nodefony/framework 10.0.0-alpha.9 → 10.0.0-beta.2

package/dist/nodefony/src/Resolver.js

@@ -1,6 +1,7 @@
+import { guardSingletonState, isDevelopment } from "./singletonGuard.js";
 import { buildParamArgs, computeActionMeta, resolveActionMeta, resolveSessionIntent } from "../decorators/routerDecorators.js";
 import { computeFingerprint, evaluateIdempotency, isMutationMethod, resolveIdempotencyKey, resolveIdentity } from "./idempotency.js";
-import { RequestContext, identityHint, isArray, isPlainObject, isPromise, nodefonyError, typeOf } from "nodefony";
+import { RequestContext, finallyMaybe, identityHint, isArray, isPlainObject, isPromise, nodefonyError, thenMaybe, typeOf } from "nodefony";
 import { Http2Response, HttpResponse, WebsocketResponse } from "@nodefony/http";
 //#region nodefony/src/Resolver.ts
 /**
@@ -21,6 +22,15 @@ import { Http2Response, HttpResponse, WebsocketResponse } from "@nodefony/http";
 * cohabitent dans une même suite de tests.
 */
 const areaRequirements = /* @__PURE__ */ new WeakMap();
+/**
+* Le controller expose-t-il un hook `initialize()` (appelé une fois à sa création) ?
+*
+* @param controller - instance fraîchement créée par l'injecteur.
+* @returns `true` si `initialize` est une méthode.
+*/
+function hasInitialize(controller) {
+	return typeof Reflect.get(controller, "initialize") === "function";
+}
 var Resolver = class {
 	injector;
 	controller = null;
@@ -68,8 +78,8 @@ var Resolver = class {
 		this.context = context;
 		this.injector = context.container?.get("injector") ?? null;
 	}
-	match(route, context, cleanPath) {
-		const match = route.match(context, cleanPath, this.methodOverride ?? void 0);
+	match(route, context, cleanPath, literal) {
+		const match = route.match(context, cleanPath, this.methodOverride ?? void 0, literal);
 		if (match) {
 			this.variables = match;
 			this.route = route;
@@ -96,45 +106,84 @@ var Resolver = class {
 	* `Context.setMetaData()` pour exposer `msg.nodefony.route.variablesMap`.
 	*/
 	getMatchedParams() {
-		const names = this.route?.variables ?? [];
-		const params = {};
-		for (let i = 0; i < names.length; i++) params[names[i]] = this.variables[i];
+		const params = this._zipRouteParams();
 		const wildcard = this.variables["*"];
 		if (wildcard !== void 0) params["*"] = wildcard;
 		return params;
 	}
+	/**
+	* Associe chaque nom de variable de la route à la valeur capturée au match.
+	*
+	* @returns la table nom → valeur (vide sans route)
+	*/
+	_zipRouteParams() {
+		const names = this.route?.variables ?? [];
+		const params = {};
+		for (let i = 0; i < names.length; i++) {
+			const name = names[i];
+			if (name !== void 0) params[name] = this.variables[i];
+		}
+		return params;
+	}
 	parsePathernController(name) {
-		let module;
-		let tab = [];
 		if (typeof name !== "string") throw new Error(`Invalid name parameter: expected a string`);
-		tab = name.split(":");
+		const tab = name.split(":");
+		const [moduleName = "", controllerName = "", actionName = ""] = tab;
 		if (tab.length !== 3) throw new Error(`Invalid name format: expected "module:controller:action"`);
-		module = this.context.kernel?.getModule(tab[0]);
-		if (!module) throw new Error(`Module not found: ${tab[0]}`);
-		this.controller = module.getController(tab[1]);
-		if (!this.controller) throw new Error(`Controller not found in module: ${tab[1]}`);
-		this.action = this.getAction(tab[2]);
-		if (!this.action) throw new Error(`Action not found in controller ${tab[1]}: ${tab[2]}`);
-		this.actionName = tab[2];
+		const module = this.context.kernel?.getModule(moduleName);
+		if (!module) throw new Error(`Module not found: ${moduleName}`);
+		this.controller = module.getController(controllerName);
+		const action = this.getAction(actionName);
+		if (!action) throw new Error(`Action not found in controller ${controllerName}: ${actionName}`);
+		this.action = action;
+		this.actionName = actionName;
 		this.resolve = true;
-		if (this.controller) this.context.sessionIntent = resolveSessionIntent(this.controller, this.actionName);
+		this.context.sessionIntent = resolveSessionIntent(this.controller, this.actionName);
 	}
 	getAction(name) {
 		if (!this.controller) throw new Error(`Controller not set`);
-		const methodNames = Object.getOwnPropertyNames(this.controller.prototype);
-		for (const methodName of methodNames) if (typeof this.controller.prototype[methodName] === "function" && methodName === name) return this.controller.prototype[methodName];
-		return null;
+		const proto = this.controller.prototype;
+		if (!Object.hasOwn(proto, name)) return null;
+		const member = Reflect.get(proto, name);
+		return typeof member === "function" ? member : null;
 	}
-	async newController(context) {
+	/**
+	* L'instance du controller de la route, posée sur le container du contexte.
+	*
+	* Singleton (le défaut) : l'instance partagée du cache du Router — rendue
+	* DIRECTEMENT une fois créée, sans promesse à attendre (#505). Portée
+	* `request` : une instance neuve, synchrone tant que son `initialize()` ne
+	* rend pas de promesse.
+	*
+	* @param context - le contexte à injecter (celui du résolveur par défaut).
+	* @returns l'instance, ou la promesse de l'instance quand sa création attend
+	*   (`initialize()` asynchrone).
+	* @throws de façon SYNCHRONE si la route n'a pas de controller, ou si sa
+	*   construction lève ; un `initialize()` qui échoue rompt la promesse rendue.
+	*/
+	newController(context) {
 		if (!this.controller) throw new Error(`Route Controller not found`);
+		let created;
 		if (this.controller.scope === "singleton") {
 			const router = this.context.router;
-			const controller = router ? await router.getSingletonController(this.controller, () => this._createController(context)) : await this._createController(context);
-			this.context.container?.set("controller", controller);
-			return controller;
-		}
-		const controller = await this._createController(context);
-		this.context.container?.set("controller", controller);
+			created = router ? router.getSingletonController(this.controller, () => this._createController(context)) : this._createController(context);
+		} else created = this._createController(context);
+		return thenMaybe(created, (controller) => this._pinController(controller));
+	}
+	/**
+	* Pose le pointeur `"controller"` sur le container du contexte : un message
+	* WS suivant ou un forward (`reload`) retrouve l'instance par ce chemin.
+	*
+	* SAUF pour une invocation par message (pont `api.request`) : le container
+	* est alors celui de la CONNEXION, et son pointeur désigne le contrôleur qui
+	* la sert (le hub). L'écraser par la cible de l'appel faisait échouer le test
+	* `instanceof` au message suivant — le hub était RÉINSTANCIÉ (DI +
+	* `initialize()`) à chaque frame qui suivait un `api.request`.
+	*
+	* @returns le controller reçu, pour enchaîner.
+	*/
+	_pinController(controller) {
+		if (!this.messageInvocation) this.context.container?.set("controller", controller);
 		return controller;
 	}
 	/**
@@ -143,19 +192,36 @@ var Resolver = class {
 	* requête dans `executeAction`) puis `initialize()`. Pour un singleton,
 	* `initialize()` n'est donc appelé qu'UNE fois, à la création (sémantique
 	* boot) — le per-request y lit l'ALS s'il a besoin de la requête.
+	*
+	* @returns le controller prêt ; sa promesse seulement quand `initialize()`
+	*   en rend une.
+	* @throws de façon SYNCHRONE ce que lèvent la DI, le constructeur ou un
+	*   `initialize()` synchrone ; un `initialize()` asynchrone qui échoue rompt
+	*   la promesse rendue.
 	*/
-	async _createController(context) {
-		const ctx = context || this.context;
+	_createController(context) {
+		const ctx = context ?? this.context;
 		ctx.phaseStart("initialize");
-		try {
+		return finallyMaybe(() => {
 			const controller = this.injector?.instantiate(this.controller, ctx);
 			if (!controller) throw new Error(`Route Controller not found`);
 			if (this.controller?.prototype.module) controller.module = this.controller.prototype.module;
-			if ("initialize" in controller && typeof controller.initialize === "function") await controller.initialize();
-			return controller;
-		} finally {
-			ctx.phaseEnd("initialize");
-		}
+			const initialized = hasInitialize(controller) ? controller.initialize() : void 0;
+			return thenMaybe(initialized, () => this._guardSingleton(controller, ctx));
+		}, () => ctx.phaseEnd("initialize"));
+	}
+	/**
+	* Filet de DÉVELOPPEMENT : un singleton sert toutes les requêtes, donc une
+	* écriture sur l'un de ses champs, à partir d'ici, fuirait vers la suivante.
+	* Posé APRÈS `initialize()`, qui prépare légitimement un état de démarrage.
+	* Jamais hors développement : les champs y deviennent des accesseurs, un coût
+	* que la production ne paie pas.
+	*
+	* @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);
+		return controller;
 	}
 	/**
 	* Exécute l'action résolue et retourne sa **valeur brute**, SANS la rendre sur
@@ -165,19 +231,72 @@ var Resolver = class {
 	* (`{ id, result }`, champ GraphQL…). Le pipeline HTTP/WS normal passe par
 	* {@link callController} (= `executeAction` + rendu).
 	*
+	* Synchrone tant que rien n'est à attendre (#505) : la garde d'autorisation
+	* n'est attendue que sur une route gardée, l'instance que si elle est à
+	* créer. La valeur de l'action est rendue BRUTE — une promesse si l'action
+	* est asynchrone ; c'est le rendu qui la démêle.
+	*
 	* @param data - args supplémentaires (message WS brut legacy) concaténés aux variables de route.
 	* @param reload - force `newController()` (le container peut déjà porter un AUTRE controller).
-	* @returns la valeur retournée par l'action + son `RedirectMeta` éventuel.
+	* @returns la valeur retournée par l'action + son `RedirectMeta` éventuel —
+	*   ou la promesse de ce couple quand la garde ou la création attendent.
+	* @throws de façon SYNCHRONE ce que lève une action synchrone (ou l'absence
+	*   d'action) ; un refus d'autorisation rompt la promesse rendue.
 	*/
-	async executeAction(data, reload = false, metaArg) {
+	executeAction(data, reload = false, metaArg) {
 		const meta = metaArg ?? (this.route ? resolveActionMeta(this.route) : computeActionMeta(this.controller, this.actionName));
-		if (meta.security !== null) await this._enforceSecurity(meta.security);
-		if (meta.security === null || !meta.security.hasRoleClause) {
-			const area = this._areaSecurity();
-			if (area !== null) await this._enforceSecurity(area);
-		}
-		let controller = this.context.container?.get("controller");
-		if (!controller || reload || this.controller && !(controller instanceof this.controller)) controller = await this.newController();
+		const guarded = this._enforceActionSecurity(meta);
+		if (guarded !== void 0) return guarded.then(() => this._acquireAndInvoke(meta, data, reload));
+		return this._acquireAndInvoke(meta, data, reload);
+	}
+	/**
+	* Les gardes d'autorisation d'une action : `@IsGranted`/`@RequireScope`, puis
+	* le filet de la ZONE quand aucune garde n'a décidé du RÔLE.
+	*
+	* ⚠️ Vrai du trajet HTTP SEULEMENT. Le kernel y arme la route sans instancier
+	* (`http-kernel.ts` `prepareFrontController`), donc ce court-circuit est celui
+	* de bout en bout. En **WebSocket**, le controller est instancié au HANDSHAKE
+	* — avant qu'une frame ne soit gardée : sur ce transport, un refus n'évite
+	* ni la DI ni `initialize()`, qui ont déjà tourné.
+	*
+	* @returns `undefined` quand la route n'est pas gardée (le cas nominal : ni
+	*   lookup, ni attente) ; sinon la promesse du verdict, rompue par un refus.
+	*/
+	_enforceActionSecurity(meta) {
+		if (meta.security === null) return this._enforceAreaSecurity();
+		const granted = this._enforceSecurity(meta.security);
+		return meta.security.hasRoleClause ? granted : granted.then(() => this._enforceAreaSecurity());
+	}
+	/**
+	* Filet de la ZONE : une route dont personne n'a décidé le RÔLE hérite de
+	* celui de sa zone du firewall, au lieu d'être ouverte à tout compte
+	* authentifié.
+	*
+	* @returns `undefined` sur l'immense majorité des routes (aucune zone, ou
+	*   zone sans rôle) ; sinon la promesse du verdict.
+	*/
+	_enforceAreaSecurity() {
+		const area = this._areaSecurity();
+		return area !== null ? this._enforceSecurity(area) : void 0;
+	}
+	/**
+	* L'instance qui sert l'action — celle déjà posée sur le container quand
+	* 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) {
+		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);
+	}
+	/**
+	* Appelle l'action sur l'instance : état de requête (portée `request`
+	* seulement), arguments, méta de réponse (`@HttpCode`, `@Header`), puis
+	* l'appel — synchrone, sa valeur rendue brute.
+	*
+	* @throws de façon SYNCHRONE ce que lève l'action, ou l'absence d'action.
+	*/
+	_invokeAction(controller, meta, data) {
 		if (this.controller?.scope !== "singleton") {
 			controller.setRoute(this.route);
 			if (this.queryOverride !== null) {
@@ -202,10 +321,22 @@ var Resolver = class {
 		};
 		throw new Error(`Route Action not found`);
 	}
-	async callController(data, reload = false) {
+	/**
+	* Exécute l'action PUIS rend sa valeur sur le transport.
+	*
+	* Synchrone de bout en bout quand rien n'attend — route non gardée,
+	* controller déjà créé, action synchrone, rendu synchrone (#505).
+	*
+	* @param data - args supplémentaires (message WS brut legacy).
+	* @param reload - force une nouvelle instance (forward).
+	* @returns le résultat du rendu, ou sa promesse dès qu'une étape attend.
+	* @throws de façon SYNCHRONE ce que lève une étape synchrone (action,
+	*   construction) ; les échecs asynchrones rompent la promesse rendue.
+	*/
+	callController(data, reload = false) {
 		const meta = this.route ? resolveActionMeta(this.route) : computeActionMeta(this.controller, this.actionName);
-		const { result, redirectMeta } = meta.idempotent !== null ? await this._callWithIdempotency(meta, data, reload) : await this.executeAction(data, reload, meta);
-		return this._handleRedirect(result, redirectMeta);
+		const outcome = meta.idempotent !== null ? this._callWithIdempotency(meta, data, reload) : this.executeAction(data, reload, meta);
+		return thenMaybe(outcome, (done) => this._handleRedirect(done.result, done.redirectMeta));
 	}
 	/**
 	* Exécute l'action AVEC la porte d'idempotence mais SANS rendu
@@ -249,9 +380,7 @@ var Resolver = class {
 		if (!isMutationMethod(this.methodOverride ?? context.method)) return this.executeAction(data, reload, meta);
 		const als = RequestContext.get();
 		const httpReq = context.request;
-		const names = this.route?.variables ?? [];
-		const params = {};
-		for (let i = 0; i < names.length; i++) params[names[i]] = this.variables[i];
+		const params = this._zipRouteParams();
 		const body = als?.body !== void 0 ? als.body : httpReq?.queryPost ?? null;
 		const store = context.container?.get("idempotencyStore");
 		const verdict = await evaluateIdempotency({
@@ -271,7 +400,11 @@ var Resolver = class {
 			const { status, headers, body: memo } = verdict.response;
 			const response = context.response;
 			response?.setStatusCode(status);
-			if (headers) for (const k in headers) response?.setHeader(k, headers[k]);
+			if (headers) for (const k in headers) {
+				const value = headers[k];
+				if (value === void 0) continue;
+				response?.setHeader(k, value);
+			}
 			return {
 				result: memo,
 				redirectMeta: void 0
@@ -355,12 +488,11 @@ var Resolver = class {
 		const token = RequestContext.get()?.token;
 		if (!authz || token === void 0) throw new nodefonyError(this._accessDenied(!authz ? `aucun moteur d'autorisation n'est posé sur cette requête` : "aucune identité n'est résolue sur cette requête — la route est-elle couverte par une zone du firewall ?"), 403);
 		const clauses = req.clauses;
-		for (let i = 0; i < clauses.length; i++) {
-			const clause = clauses[i];
+		for (const clause of clauses) {
 			const subject = clause.subjectParam !== void 0 ? this._resolveSubject(clause.subjectParam) : void 0;
 			let ok = false;
 			const anyOf = clause.anyOf;
-			for (let j = 0; j < anyOf.length; j++) if (await authz.decide(token, anyOf[j], subject)) {
+			for (const attribute of anyOf) if (await authz.decide(token, attribute, subject)) {
 				ok = true;
 				break;
 			}
@@ -395,17 +527,15 @@ var Resolver = class {
 	}
 	_buildParamArgs(metas) {
 		const httpCtx = this.context;
-		const varNames = this.route?.variables ?? [];
-		const paramsMap = {};
-		for (let i = 0; i < varNames.length; i++) paramsMap[varNames[i]] = this.variables[i];
+		const paramsMap = this._zipRouteParams();
 		const ctx = this.context;
 		return buildParamArgs(metas, {
 			paramsMap,
-			request: httpCtx?.request,
-			response: httpCtx?.response,
-			session: ctx?.session,
+			request: httpCtx.request,
+			response: httpCtx.response,
+			session: ctx.session,
 			queryOverride: this.queryOverride ?? void 0,
-			getRequestCookies: (name) => ctx?.getRequestCookies ? ctx.getRequestCookies(name) : void 0
+			getRequestCookies: (name) => ctx.getRequestCookies(name)
 		});
 	}
 	/**
@@ -419,11 +549,23 @@ var Resolver = class {
 		const response = this.context.response;
 		if (meta.httpCode !== null) response?.setStatusCode(meta.httpCode);
 		const entries = meta.headerEntries;
-		if (entries) for (let i = 0; i < entries.length; i++) response?.setHeader(entries[i][0], entries[i][1]);
+		if (entries) for (const [name, value] of entries) response?.setHeader(name, value);
 	}
-	async _handleRedirect(actionResult, redirectMeta) {
+	/**
+	* Applique `@Redirect` à la valeur de l'action, puis la rend.
+	*
+	* Sans `@Redirect` (le cas nominal), rend directement. Avec, la valeur est
+	* attendue seulement si c'est une promesse — une action synchrone qui rend
+	* `undefined` redirige sans suspension.
+	*
+	* @returns le résultat du rendu, ou sa promesse.
+	*/
+	_handleRedirect(actionResult, redirectMeta) {
 		if (!redirectMeta) return this.returnController(actionResult);
-		const resolved = await Promise.resolve(actionResult);
+		return thenMaybe(actionResult, (resolved) => this._redirectOrReturn(resolved, redirectMeta));
+	}
+	/** Suite de {@link _handleRedirect}, la valeur de l'action connue. */
+	_redirectOrReturn(resolved, redirectMeta) {
 		if (resolved !== null && resolved !== void 0 && typeof resolved === "object" && "url" in resolved) {
 			const override = resolved;
 			this.context.redirect(override.url, override.statusCode ?? redirectMeta.statusCode);
@@ -435,7 +577,21 @@ var Resolver = class {
 		}
 		return this.returnController(resolved);
 	}
-	async returnController(result) {
+	/**
+	* Rend la valeur d'une action sur le transport, selon sa nature : promesse
+	* (démêlée puis re-rendue), texte, Buffer, réponse déjà construite, scalaire
+	* ou objet (auto-JSON), rien (l'action envoie elle-même).
+	*
+	* Pas `async` : l'envelopper dans une promesse de plus ne changeait rien au
+	* rendu, et coûtait une suspension à chaque requête (#505). La valeur n'est
+	* attendue que si c'en est une.
+	*
+	* @param result - la valeur rendue par l'action.
+	* @returns ce que rend l'envoi (souvent sa promesse), ou `undefined` quand il
+	*   n'y a rien à envoyer.
+	* @throws de façon SYNCHRONE ce que lève un envoi synchrone.
+	*/
+	returnController(result) {
 		const type = typeOf(result);
 		switch (true) {
 			case result instanceof Promise:

package/dist/nodefony/src/Route.js

@@ -177,7 +177,7 @@ var Route = class Route {
 			this.method = obj.method;
 			this.setHostname(obj.host);
 			this.setDefaults(obj.defaults);
-			this.requirements = obj.requirements || {};
+			this.requirements = obj.requirements ?? {};
 			this.bypassFirewall = obj.bypassFirewall ?? false;
 			this.areaRoleExempt = obj.areaRoleExempt ?? false;
 			this.compile();
@@ -203,10 +203,29 @@ var Route = class Route {
 		if (!reqUrl) return;
 		return stripTrailingSlashes(reqUrl.pathname);
 	}
-	match(context, cleanPath, methodOverride) {
+	/**
+	* Confronte la requête à cette route : chemin, hôte, puis exigences.
+	*
+	* @param context - contexte HTTP/WS courant.
+	* @param cleanPath - pathname déjà normalisé par l'appelant (sinon recalculé).
+	* @param methodOverride - méthode logique du pont WS-RPC (cf `Resolver`).
+	* @param literal - l'appelant GARANTIT que le chemin de la route ne porte
+	*   aucune syntaxe de motif (`{}`, `*`…) — c'est le cas d'une route trouvée
+	*   par l'index des littérales du `Router`. Le motif n'est alors pas exécuté
+	*   quand le chemin est identique à la lettre.
+	* @returns les valeurs capturées (tableau + accès par nom), ou `null`/`undefined`
+	*   quand le chemin ne correspond pas.
+	* @throws 403/405/1002 quand le chemin correspond mais pas l'hôte ou les exigences.
+	*/
+	match(context, cleanPath, methodOverride, literal) {
 		let res;
 		if (context.request && this.pattern) {
-			const url = cleanPath !== void 0 ? cleanPath : Route.cleanPathname(context);
+			const url = cleanPath ?? Route.cleanPathname(context);
+			if (literal === true && url === this.path && !this.#hasPositionalDefaults()) {
+				this.matchHostname(context);
+				this.matchRequirements(context, methodOverride);
+				return [];
+			}
 			if (url !== void 0) res = url.match(this.pattern);
 		}
 		if (!res) return res;
@@ -228,7 +247,7 @@ var Route = class Route {
 						else throw { BreakException: `Requirement Routing config Exception variable : ${k} must be RegExp or string : ${typeOf(req)}` };
 					}
 					result = compiled.test(param ?? "");
-					if (!result) throw { BreakException: `Requirement Exception variable : ${k} ==> ${param} doesn't match with ${String(req)}` };
+					if (!result) throw { BreakException: `Requirement Exception variable : ${k} ==> ${param} doesn't match with ${typeof req === "string" ? req : String(compiled)}` };
 				}
 				const index = map.push(param);
 				map[k] = map[index - 1];
@@ -237,7 +256,7 @@ var Route = class Route {
 			if (e && typeof e === "object" && "BreakException" in e) throw e.BreakException;
 			throw e;
 		}
-		if (map && map.wildcard) map["*"] = map.wildcard;
+		if (map.wildcard) map["*"] = map.wildcard;
 		return map;
 	}
 	/**
@@ -264,11 +283,12 @@ var Route = class Route {
 		REG_ROUTE.lastIndex = 0;
 		let found;
 		while ((found = REG_ROUTE.exec(this.path)) !== null) {
+			const [match, slash, dot, key = "", capture, opt] = found;
 			const literal = this.path.slice(from, found.index);
 			this.#collectUnreachable(literal);
 			pattern += compileLiteral(literal, wildcard);
-			pattern += replaceCallback.call(this, found[0], found[1], found[2], found[3], found[4], found[5], found.index);
-			from = found.index + found[0].length;
+			pattern += replaceCallback.call(this, match, slash, dot, key, capture, opt, found.index);
+			from = found.index + match.length;
 		}
 		const tail = this.path.slice(from);
 		this.#collectUnreachable(tail);
@@ -290,13 +310,12 @@ var Route = class Route {
 		this.methodsSet = void 0;
 		this.methodsAllow = void 0;
 		this.varRegexp = void 0;
-		const methods = this.requirements?.methods;
-		if (typeof methods === "string") {
-			const list = methods.replace(/\s/g, "").toUpperCase().split(",");
-			this.methodsSet = new Set(list);
-			this.methodsAllow = list.join(",");
-		} else if (Array.isArray(methods)) {
-			const list = methods.map((m) => String(m).toUpperCase());
+		const methods = this.requirements.methods;
+		let list;
+		if (typeof methods === "string") list = methods.replace(/\s/g, "").toUpperCase().split(",");
+		else if (Array.isArray(methods)) list = methods.map((m) => m.toUpperCase());
+		if (list) {
+			if (list.includes("GET") && !list.includes("HEAD")) list.push("HEAD");
 			this.methodsSet = new Set(list);
 			this.methodsAllow = list.join(",");
 		}
@@ -307,12 +326,18 @@ var Route = class Route {
 			if (compiled) (this.varRegexp ??= Object.create(null))[k] = compiled;
 		}
 	}
+	#hasPositionalDefaults() {
+		for (const def in this.defaults) if (def !== "controller") return true;
+		return false;
+	}
 	hydrateDefaultParameters(res) {
-		if (this.variables.length) {
-			for (let i = 0; i < this.variables.length; i++) if (this.defaults[this.variables[i]]) {
-				if (res[i + 1] === "") res[i + 1] = this.defaults[this.variables[i]];
+		if (this.variables.length) for (let i = 0; i < this.variables.length; i++) {
+			const name = this.variables[i];
+			if (name !== void 0 && this.defaults[name]) {
+				if (res[i + 1] === "") res[i + 1] = this.defaults[name];
 			}
-		} else for (const def in this.defaults) switch (def) {
+		}
+		else for (const def in this.defaults) switch (def) {
 			case "controller": continue;
 			default: res.push(this.defaults[def]);
 		}
@@ -336,8 +361,7 @@ var Route = class Route {
 	* `this.module` à `onBoot` — appel via le décorateur `@controllers` du module.
 	*/
 	toLogLine() {
-		const m = Array.isArray(this.requirements?.methods) ? this.requirements.methods.join("|") : this.requirements?.methods || this.method || "ANY";
-		const method = `[${String(m)}]`.padEnd(10);
+		const method = `[${Array.isArray(this.requirements.methods) ? this.requirements.methods.join("|") : this.requirements.methods || this.method || "ANY"}]`.padEnd(10);
 		const ctrl = this.controller?.name || "?";
 		const action = this.classMethod || this.name;
 		const mod = this.module?.name ? `@${this.module.name}/` : "";
@@ -388,14 +412,14 @@ var Route = class Route {
 	compileHost() {
 		const patterns = [];
 		if (this.host) patterns.push(this.host);
-		const reqDomain = this.requirements?.domain;
+		const reqDomain = this.requirements.domain;
 		if (reqDomain) patterns.push(reqDomain);
 		this.hostRegexp = patterns.length ? compileDomainPatterns(patterns.flat()) : void 0;
 	}
 	matchHostname(context) {
 		if (this.hostRegexp) {
 			if (isDomainAllowed(this.hostRegexp, context.domain)) return true;
-			const error = new HttpError(`Domain ${context.domain} Unauthorized`);
+			const error = new HttpError(`Domain ${context.domain} Forbidden for this route`);
 			error.code = 403;
 			error.type = "domain";
 			throw error;
@@ -422,7 +446,7 @@ var Route = class Route {
 		return this.hash;
 	}
 	addRequirement(key, value) {
-		if (key && value) {
+		if (value) {
 			this.requirements[key] = value;
 			this.compileRequirements();
 			return value;
@@ -437,10 +461,10 @@ var Route = class Route {
 	matchRequirements(context, methodOverride) {
 		if (this.hasRequirements()) for (const i in this.requirements) switch (i) {
 			case "methods":
-				if (!this.methodsSet) throw new Error(`Bad config route method : ${this.requirements[i]}`);
+				if (!this.methodsSet) throw new Error(`Bad config route method : ${String(this.requirements.methods)}`);
 				if (methodOverride !== void 0) {
 					if (!this.methodsSet.has("WEBSOCKET") || !this.methodsSet.has(methodOverride)) {
-						const error = new HttpError(`Method ${methodOverride} Unauthorized`);
+						const error = new HttpError(`Method ${methodOverride} Not Allowed`);
 						error.code = 405;
 						error.type = "method";
 						error.allow = this.methodsAllow ?? "";
@@ -449,7 +473,7 @@ var Route = class Route {
 					break;
 				}
 				if (!this.methodsSet.has(context.method)) {
-					const error = new HttpError(`Method ${context.method} Unauthorized`);
+					const error = new HttpError(`Method ${context.method} Not Allowed`);
 					error.code = 405;
 					error.type = "method";
 					error.allow = this.methodsAllow ?? "";
@@ -457,23 +481,22 @@ var Route = class Route {
 				}
 				break;
 			case "domain": break;
-			case "protocol": switch (context.method) {
-				case "WEBSOCKET":
-					let requirement = this.requirements[i];
-					if (!requirement) return true;
-					if (typeof requirement === "string") {
-						if (context.acceptedProtocol !== requirement) {
-							const error = new HttpError(`Protocol ${context.acceptedProtocol} Unauthorized`);
-							error.code = 1002;
-							error.type = "protocol";
-							throw error;
-						}
-					} else {
-						const error = new HttpError(`Protocol ${context.acceptedProtocol} Unauthorized`);
+			case "protocol": if (context.method === "WEBSOCKET") {
+				const requirement = this.requirements[i];
+				if (!requirement) return true;
+				if (typeof requirement === "string") {
+					if (context.acceptedProtocol !== requirement) {
+						const error = new HttpError(`Protocol ${context.acceptedProtocol} Not Supported`);
 						error.code = 1002;
 						error.type = "protocol";
 						throw error;
 					}
+				} else {
+					const error = new HttpError(`Protocol ${context.acceptedProtocol} Not Supported`);
+					error.code = 1002;
+					error.type = "protocol";
+					throw error;
+				}
 			}
 		}
 		return true;

package/dist/nodefony/src/SyslogAdminApi.js

@@ -36,7 +36,7 @@ function createSyslogAdminApi(syslog, options = {}) {
 	/** Lit un entier de query (`?limit=50`), borné, avec défaut. */
 	const intParam = (req, key, def, max) => {
 		const raw = req.query[key];
-		const v = Array.isArray(raw) ? raw[0] : raw;
+		const v = Array.isArray(raw) ? raw.at(0) : raw;
 		const n = v !== void 0 ? Number.parseInt(v, 10) : NaN;
 		if (Number.isNaN(n) || n <= 0) return def;
 		return Math.min(n, max);
@@ -176,7 +176,7 @@ function createSyslogAdminApi(syslog, options = {}) {
 						driver: driver?.name ?? wanted ?? null
 					}
 				};
-				return await driver.query(buildCriteria(request, ["driver", "scope"]));
+				return driver.query(buildCriteria(request, ["driver", "scope"]));
 			}
 		},
 		{
@@ -233,7 +233,7 @@ function createSyslogAdminApi(syslog, options = {}) {
 						local: "destination locale (pas de réseau)"
 					}
 				};
-				return await driver.probe();
+				return driver.probe();
 			}
 		},
 		{
@@ -307,7 +307,7 @@ function createSyslogAdminApi(syslog, options = {}) {
 					status: 400,
 					body: { error: "missing enabled (boolean)" }
 				};
-				if (body.enabled === false) syslog.log(`sink texte « ${Syslog.logSinkName} » coupé (console/fichier)`, "NOTICE", "LOG-BACKPLANE");
+				if (!body.enabled) syslog.log(`sink texte « ${Syslog.logSinkName} » coupé (console/fichier)`, "NOTICE", "LOG-BACKPLANE");
 				const changed = Syslog.setSinkEnabled(body.enabled);
 				if (changed && body.enabled) syslog.log("sink texte rétabli", "NOTICE", "LOG-BACKPLANE");
 				return {