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

package/dist/nodefony/src/context/websocket/WebsocketContext.js

@@ -1,5 +1,6 @@
 import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
 import Context from "../Context.js";
+import { toWsCloseReason } from "./wsCloseReason.js";
 import WebsocketResponse from "./Response.js";
 import { sanitizeRequestId } from "../requestId.js";
 import { FrameProfile } from "../../profiler/FrameProfile.js";
@@ -10,6 +11,24 @@ import { AsyncResource } from "node:async_hooks";
 import url, { URL } from "node:url";
 //#region nodefony/src/context/websocket/WebsocketContext.ts
 /**
+* Appelle l'action résolue et rend TOUJOURS une promesse.
+*
+* `callController` rend une valeur ou une promesse, et peut lever de façon
+* synchrone (#505). Démarré dans l'exécuteur d'une promesse, l'appel transforme
+* une exception synchrone en REJET : les deux sites WS la traitent comme avant
+* — le handshake par son `catch` de fermeture RFC 6455, le message en la
+* rendant à l'appelant sans passer par le `catch` 1011.
+*
+* @param resolver - le résolveur de la connexion.
+* @param data - les arguments de l'action (message reçu).
+* @returns la promesse du rendu, rompue par toute erreur de l'action.
+*/
+function callAsPromise(resolver, data) {
+	return new Promise((resolve) => {
+		resolve(resolver.callController(data));
+	});
+}
+/**
 * Coerce un code (applicatif / HTTP / WS) en code de fermeture WebSocket VALIDE
 * et conforme RFC 6455 §7.4, en PRÉFÉRANT les codes standard §7.4.1 quand le
 * sens existe :
@@ -65,7 +84,7 @@ var WebsocketContext = class extends Context {
 		this.method = this.getMethod();
 		this.origin = req.headers.origin ?? "";
 		const checker = this.httpKernel?.getTrustProxyChecker();
-		const socketAddress = req.socket?.remoteAddress;
+		const socketAddress = req.socket.remoteAddress;
 		if (checker && checker.isTrusted(socketAddress) && hasForwardingHeaders(req.headers)) this.forwarded = resolveForwarded(req.headers, socketAddress, checker);
 		this.remoteAddress = this.getRemoteAddress();
 		this.acceptedProtocol = req.headers["sec-websocket-protocol"];
@@ -104,7 +123,7 @@ var WebsocketContext = class extends Context {
 				proxyHost: fwd.host ?? req.headers["x-forwarded-host"],
 				proxyVia: req.headers.via
 			};
-			this.log(`PROXY WEBSOCKET REQUEST ${fwd.fromStandard ? "Forwarded (RFC 7239)" : "x-forwarded"} VIA : ${this.proxy?.proxyVia}`, "DEBUG");
+			this.log(`PROXY WEBSOCKET REQUEST ${fwd.fromStandard ? "Forwarded (RFC 7239)" : "x-forwarded"} VIA : ${this.proxy.proxyVia}`, "DEBUG");
 		}
 	}
 	log(pci, severity, msgid, msg) {
@@ -117,9 +136,11 @@ var WebsocketContext = class extends Context {
 			if (!logger) return;
 			const entry = logger.renderWebsocket(this, httpError ?? null, acceptedProtocol ?? null);
 			const pdu = this.log(entry.text, entry.severity, entry.msgid);
-			if (pdu && pdu.requestId === void 0) pdu.requestId = this.requestId;
+			pdu.requestId ??= this.requestId;
 			return pdu;
-		} catch {}
+		} catch {
+			return;
+		}
 	}
 	async connect() {
 		if (!this.response || !this.request || !this.connection) throw new Error("Nodefony Websocket Bad request/response/connection");
@@ -140,37 +161,38 @@ var WebsocketContext = class extends Context {
 			this.webSocketState = "error";
 			throw new Error("Nodefony Websocket rejected");
 		}
-		if (!this.resolver) this.resolver = this.router?.resolve(this);
+		if (!this.resolver) this.resolver = this.router?.resolve(this) ?? null;
 		else try {
 			this.resolver.match(this.resolver.route, this);
 		} catch (e) {
-			if (!this.rejected) this.reject(e.code ?? void 0, e.message);
+			if (!this.isRejected()) this.reject(e.code ?? void 0, e.message);
 			throw e;
 		}
 		await this.fireAsync("onRequest", this, this.resolver);
 		await this.kernel?.fireAsync("onRequest", this, this.resolver);
-		if (this.resolver && this.resolver.resolve) {
+		if (this.resolver?.resolve) {
 			this.setMetaData({ nodefony: { websocket: {
 				state: this.webSocketState,
 				protocol: this.acceptedProtocol
 			} } });
-			await this.resolver.callController(data).then(async () => {
+			await callAsPromise(this.resolver, data).then(async () => {
 				await this.saveSession().then((session) => {
 					if (session) this.log(`SAVE SESSION ID : ${session.id}`, "DEBUG");
-				}).catch((e) => {
-					throw e;
 				});
 				return this;
 			}).catch((error) => {
 				if (!this.rejected) {
-					if (this.requestEnded) throw this.close(error.code, error.message);
+					if (this.requestEnded) {
+						this.close(error.code, error.message);
+						throw error;
+					}
 					this.reject(error.code ?? void 0, error.message);
 					this.rejected = true;
 					this.webSocketState = "error";
 					throw error;
 				}
 			});
-		} else if (!this.rejected) {
+		} else if (!this.isRejected()) {
 			this.reject(4004, "Not Found");
 			this.rejected = true;
 			this.webSocketState = "error";
@@ -204,7 +226,8 @@ var WebsocketContext = class extends Context {
 				this.logMessageContent("BROADCAST", payload);
 				this.fire("onMessage", payload, this, "BROADCAST");
 				this.fire("onBroadcast", payload, this);
-				return this.response.broadcast(payload, encoding);
+				this.response.broadcast(payload, encoding);
+				return;
 			}
 		}
 		return null;
@@ -219,7 +242,7 @@ var WebsocketContext = class extends Context {
 	* @param data - charge utile (string, Buffer binaire, objet, ou null).
 	*/
 	logMessageContent(dir, data) {
-		if (wsContentLogging === null) wsContentLogging = this.kernel?.environment !== "production";
+		wsContentLogging ??= this.kernel?.environment !== "production";
 		if (!wsContentLogging) return;
 		this.log(formatWsLogContent(data), "DEBUG", `WS ${dir}`);
 	}
@@ -292,23 +315,22 @@ var WebsocketContext = class extends Context {
 		this.webSocketState = "message";
 		const message = isBinary ? data : data.toString();
 		this.logMessageContent("RECEIVE", message);
-		if (this.response) this.response.body = Buffer.isBuffer(data) ? data : Buffer.from(data.toString());
+		if (this.response) this.response.body = Buffer.isBuffer(data) ? data : Buffer.from(data);
 		try {
-			if (!this.resolver) this.resolver = this.router?.resolve(this);
-			else this.resolver.match(this.resolver?.route, this);
+			if (!this.resolver) this.resolver = this.router?.resolve(this) ?? null;
+			else this.resolver.match(this.resolver.route, this);
 			await this.fireAsync("onMessage", message, this, "RECEIVE");
-			if (this.resolver.resolve) {
+			if (this.resolver?.resolve) {
 				this.setMetaData({ nodefony: { websocket: {
 					state: this.webSocketState,
 					protocol: this.acceptedProtocol
 				} } });
-				return this.resolver.callController([message]).catch((e) => {
-					throw e;
-				});
+				return callAsPromise(this.resolver, [message]);
 			} else if (!this.rejected) {
 				this.reject(4004, "Not Found");
 				this.rejected = true;
 			}
+			return;
 		} catch (e) {
 			this.reject(1011, "Internal Error");
 			throw e;
@@ -338,7 +360,7 @@ var WebsocketContext = class extends Context {
 	*/
 	onConnectionError(error) {
 		this.webSocketState = "error";
-		this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("error")} : ${error?.message}`, "ERROR", `${this.type} ${logColor.red("SOCKET ERROR")} ${this.method}`);
+		this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("error")} : ${error.message}`, "ERROR", `${this.type} ${logColor.red("SOCKET ERROR")} ${this.method}`);
 		this.fire("onError", error, this);
 	}
 	setScheme() {
@@ -346,7 +368,7 @@ var WebsocketContext = class extends Context {
 	}
 	getRemoteAddress() {
 		if (this.forwarded) return this.forwarded.clientIp;
-		return this.request?.socket?.remoteAddress ?? null;
+		return this.request?.socket.remoteAddress ?? null;
 	}
 	getHost() {
 		return this.request?.headers.host;
@@ -372,15 +394,26 @@ var WebsocketContext = class extends Context {
 		super.clean();
 	}
 	close(reasonCode, description) {
-		if (this.response) return this.response.close(toWsCloseCode(reasonCode), description);
+		if (this.response) this.response.close(toWsCloseCode(reasonCode), description);
 	}
 	drop(reasonCode, description) {
-		if (this.response) return this.response.drop(reasonCode, description);
+		if (this.response) this.response.drop(reasonCode, description);
+	}
+	/**
+	* Relit `rejected` sans le rétrécissement de TypeScript : après la garde
+	* d'entrée de {@link handle}, le compilateur le croit `false` pour toute la
+	* méthode, alors qu'un écouteur `onRequest` (pare-feu) ou le `match` du
+	* resolver peut avoir rejeté entre-temps.
+	*
+	* @returns `true` si la connexion a été rejetée.
+	*/
+	isRejected() {
+		return this.rejected;
 	}
 	reject(code, message) {
 		if (this.connection && this.connection.readyState === Ws.OPEN) {
 			const raw = typeof code === "string" ? parseInt(code, 10) : code;
-			this.connection.close(toWsCloseCode(raw), message ?? "Rejected");
+			this.connection.close(toWsCloseCode(raw), toWsCloseReason(message ?? "Rejected"));
 		}
 		this.rejected = true;
 	}

package/dist/nodefony/src/context/websocket/wsCloseReason.js

@@ -0,0 +1,41 @@
+//#region nodefony/src/context/websocket/wsCloseReason.ts
+/**
+* Taille maximale, en octets UTF-8, de la raison d'une trame Close (RFC 6455
+* §5.5 : charge d'une trame de contrôle ≤ 125 octets, dont 2 pour le code).
+*/
+const MAX_WS_CLOSE_REASON_BYTES = 123;
+/** Marqueur de troncature : « … » (U+2026) pèse 3 octets en UTF-8. */
+const ELLIPSIS = "…";
+/**
+* Borne la raison d'une fermeture WebSocket à 123 octets UTF-8, coupée sur une
+* frontière de caractère.
+*
+* `ws.close(code, reason)` LÈVE une `RangeError` au-delà de 123 octets, et la
+* connexion n'est alors PAS fermée : jusqu'en `ws` 8.21 elle restait en
+* `CLOSING` sans trame Close ni minuterie — hors de portée de toute garde
+* `readyState === OPEN` et du heartbeat, donc ouverte jusqu'à la mort TCP ;
+* depuis 8.22 elle reste `OPEN`. Or la raison porte souvent un message
+* d'erreur, dont rien ne borne la longueur.
+*
+* @param reason - raison candidate (message d'erreur, libellé…)
+* @returns la raison telle quelle si elle tient, sinon tronquée et terminée
+*          par « … » ; chaîne vide si elle n'est pas une chaîne.
+*/
+function toWsCloseReason(reason) {
+	if (typeof reason !== "string") return "";
+	if (reason.length <= 41) return reason;
+	if (Buffer.byteLength(reason, "utf8") <= 123) return reason;
+	const budget = 120;
+	let bytes = 0;
+	let end = 0;
+	for (const char of reason) {
+		const cp = char.codePointAt(0);
+		const size = cp < 128 ? 1 : cp < 2048 ? 2 : cp < 65536 ? 3 : 4;
+		if (bytes + size > budget) break;
+		bytes += size;
+		end += char.length;
+	}
+	return reason.slice(0, end) + ELLIPSIS;
+}
+//#endregion
+export { MAX_WS_CLOSE_REASON_BYTES, toWsCloseReason };

package/dist/nodefony/src/cookies/cookie.js

@@ -25,7 +25,7 @@ function cookiesParser(context) {
 		case "http":
 		case "https":
 		case "http2":
-			if (context.request.request && context.request.request.headers.cookie) cookies = context.request.request.headers.cookie;
+			if (context.request.request.headers.cookie) cookies = context.request.request.headers.cookie;
 			if (cookies) {
 				const obj = parser(cookies);
 				for (const cookie in obj) {
@@ -37,7 +37,7 @@ function cookiesParser(context) {
 			break;
 		case "websocket":
 		case "websocket-secure": {
-			const cookieHeader = context.request?.headers?.cookie;
+			const cookieHeader = context.request?.headers.cookie;
 			if (cookieHeader) {
 				const parsed = parser(cookieHeader);
 				for (const name in parsed) {
@@ -65,7 +65,7 @@ var Cookie = class Cookie {
 	sameSite;
 	priority;
 	constructor(cookiesOrName, value, options) {
-		this.options = extend({}, cookieDefaultSettings, options || {});
+		this.options = extend({}, cookieDefaultSettings, options ?? {});
 		if (!cookiesOrName) throw new Error("cookie must have name");
 		this.name = cookiesOrName;
 		if (typeof cookiesOrName === "string") {

package/dist/nodefony/src/errors/httpError.js

@@ -32,16 +32,16 @@ var HttpError = class extends nodefonyError {
 	constructor(message, code, context) {
 		super(message, code);
 		this.context = context;
-		this.response = context?.response;
-		this.request = context?.request;
+		const res = context?.response;
+		this.response = res ?? void 0;
+		this.request = context?.request ?? void 0;
 		this.url = this.context?.url;
-		if (this.response && code) this.response.statusCode = code;
-		if (!this.message) this.message = (context?.response)?.body?.toString() || (context?.response)?.statusMessage || (context?.response)?.getStatusMessage();
+		if (res && code) res.statusCode = code;
+		if (!this.message && res) this.message = res.body?.toString() || res.statusMessage || res.getStatusMessage();
 		const resolver = context?.resolver;
 		this.controller = resolver?.controller?.name ?? void 0;
 		this.action = resolver?.actionName ?? void 0;
-		const res = context?.response;
-		if (res) this.jsonResponse = `${res.statusCode} ${res.statusMessage ?? ""}`.trim();
+		if (res) this.jsonResponse = `${res.statusCode} ${res.statusMessage}`.trim();
 	}
 	toString() {
 		if (this.context) return `${clc.red(this.message)}

package/dist/nodefony/src/errors/thrownMessage.js

@@ -0,0 +1,27 @@
+//#region nodefony/src/errors/thrownMessage.ts
+/**
+* Message lisible d'une valeur LEVÉE (`catch`, rejet) dont on ignore le type.
+*
+* Même rendu que `String(value)` pour une `Error` (son `message`) et pour les
+* primitives ; un objet quelconque rend son étiquette (`[object Object]`) sans
+* appeler un `toString` arbitraire ni sérialiser son contenu — ce texte peut
+* finir dans une réponse ou un journal, il ne doit rien divulguer.
+*
+* @param value - la valeur levée.
+* @returns un texte court, jamais vide pour une valeur définie.
+*/
+function thrownMessage(value) {
+	if (value instanceof Error) return value.message;
+	switch (typeof value) {
+		case "string": return value;
+		case "number":
+		case "boolean":
+		case "bigint":
+		case "symbol":
+		case "undefined": return String(value);
+		case "object":
+		case "function": return value === null ? "null" : Object.prototype.toString.call(value);
+	}
+}
+//#endregion
+export { thrownMessage };

package/dist/nodefony/src/profiler/FrameProfile.js

@@ -1,3 +1,4 @@
+import { thrownMessage } from "../errors/thrownMessage.js";
 //#region nodefony/src/profiler/FrameProfile.ts
 /**
 * Profil d'**une invocation** du pont RPC (une frame `api.request`), et non de
@@ -72,8 +73,8 @@ var FrameProfile = class {
 	phaseEnd(name) {
 		if (!this.timing) return;
 		for (let i = this.phases.length - 1; i >= 0; i--) {
-			const p = this.phases[i];
-			if (p.name === name && p.endMs === void 0) {
+			const p = this.phases.at(i);
+			if (p?.name === name && p.endMs === void 0) {
 				p.endMs = performance.now();
 				p.durationMs = p.endMs - p.startMs;
 				return;
@@ -88,7 +89,7 @@ var FrameProfile = class {
 	*/
 	finish(status, error) {
 		this.response = { statusCode: status };
-		if (error !== void 0 && error !== null) this.error = { message: error instanceof Error ? error.message : String(error) };
+		if (error !== void 0 && error !== null) this.error = { message: thrownMessage(error) };
 	}
 };
 //#endregion

package/dist/nodefony/src/profiler/Profiler.js

@@ -2,8 +2,8 @@
 /** Durée totale = (fin de la dernière phase terminée) − (début de la 1ère). */
 function totalDuration(phases) {
 	if (phases.length === 0) return null;
-	const first = phases[0];
-	if (typeof first.startMs !== "number") return null;
+	const first = phases.at(0);
+	if (first === void 0 || typeof first.startMs !== "number") return null;
 	let end = first.startMs;
 	for (const p of phases) {
 		const e = p.startMs + (p.durationMs ?? 0);
@@ -71,8 +71,8 @@ var Profiler = class {
 	recent(limit = 60) {
 		const out = [];
 		const entries = [...this._buf.values()];
-		for (let i = entries.length - 1; i >= 0 && out.length < limit; i--) {
-			const e = entries[i];
+		for (const e of entries.reverse()) {
+			if (out.length >= limit) break;
 			out.push({
 				requestId: e.requestId,
 				ts: e.ts,

package/dist/nodefony/src/servers/kernelServers.js

@@ -0,0 +1,29 @@
+//#region nodefony/src/servers/kernelServers.ts
+/**
+* Rétrécit la section `servers` de la configuration du kernel (lue dans le sac
+* de config non typé du cœur) en {@link ServersConfig}, sans propager `any`.
+*
+* Seule lecture de `kernel.options.servers` dans `@nodefony/http` : les serveurs
+* et le `HttpKernel` passent tous par ici.
+*
+* @param servers - la valeur brute de `kernel.options.servers`.
+* @returns la section typée, ou `undefined` si elle est absente ou n'est pas un objet.
+*/
+function asServersConfig(servers) {
+	return servers !== null && typeof servers === "object" ? servers : void 0;
+}
+/**
+* Port DEMANDÉ pour un serveur (`servers.<type>.port`), ou `undefined` si le
+* serveur est désactivé, absent, ou sans port numérique.
+*
+* @param servers - section `servers` déjà rétrécie ({@link asServersConfig}).
+* @param type - le serveur visé.
+*/
+function configuredServerPort(servers, type) {
+	const entry = servers?.[type];
+	if (!entry) return void 0;
+	const port = entry.port;
+	return typeof port === "number" ? port : void 0;
+}
+//#endregion
+export { asServersConfig, configuredServerPort };

package/dist/nodefony/src/servers/portBinder.js

@@ -1,25 +1,53 @@
-import { isPortListening } from "nodefony";
+import { isPortListening, resolvePortPolicy } from "nodefony";
+import cluster from "node:cluster";
 //#region nodefony/src/servers/portBinder.ts
-/** Nombre de ports essayés après le désiré, en `auto`. */
-const DEFAULT_PORT_RETRY_ATTEMPTS = 20;
 /**
-* Politique de port effective.
-*
-* Le défaut dépend de l'environnement, et ce n'est pas de la coquetterie :
-* - **production** → `strict`. Le port y est un contrat (service k8s, ingress,
-*   sonde de santé). Un bind silencieux ailleurs donnerait un pod déclaré sain
-*   que personne n'atteint : une panne invisible, le pire des deux mondes.
-* - **test** → `strict`. Un port occupé veut dire « un serveur est resté debout » ;
-*   le banc doit s'arrêter, pas viser à côté (il taperait le serveur du voisin).
-* - **développement** → `auto`. Ici un port pris n'est qu'une nuisance.
-*
-* @param environment - `kernel.environment` (normalisé `development`/`production`/`test`).
-* @param explicit - `servers.portPolicy` s'il est configuré (il gagne toujours).
+* **portBinder** — écoute sur le port désiré, ou sur le prochain port libre.
+*
+* Pourquoi ce fichier existe : lancer deux apps Nodefony côte à côte (le repo et
+* une app générée, deux projets, un banc et une démo…) faisait mourir la seconde
+* en `EADDRINUSE`. Le port désiré est une PRÉFÉRENCE en développement ; il reste
+* un CONTRAT en production.
+*
+* ## Pourquoi retenter au `listen()` plutôt que sonder d'abord
+*
+* La tentation est d'appeler « le port 5151 est-il libre ? » puis de binder. C'est
+* une **course** (TOCTOU) : entre la réponse et le bind, un autre process peut
+* prendre le port — et on échoue quand même, après avoir cru le contraire. Le
+* `listen()` est, lui, **atomique** : soit il réussit, soit le noyau dit
+* `EADDRINUSE`. On retente donc sur l'échec réel, jamais sur une prédiction.
+*
+* ## Pourquoi une SONDE malgré cela
+*
+* Le `listen()` est atomique, mais il ne dit pas tout : un port peut être **déjà
+* servi** et le noyau l'accorder quand même. Lier `0.0.0.0:P` alors qu'un autre
+* processus tient `127.0.0.1:P` **réussit** sur macOS et les BSD — ce sont deux
+* liaisons distinctes, et les connexions locales partent à la PLUS SPÉCIFIQUE.
+* Entre familles d'adresses (`::1` tenu, `0.0.0.0` demandé), même linux
+* l'accorde. L'application annonce alors `READY`, publie ses ports… et ne reçoit
+* rien : une panne muette, et un banc qui interroge le serveur du VOISIN.
+*
+* On constate donc, AVANT de binder, qu'aucun serveur ne répond déjà là où notre
+* liaison va recevoir (`isPortListening` — une connexion en boucle locale, aucun
+* outil système, même verdict sur les trois plateformes). Ce n'est pas la sonde
+* « ce port est-il libre ? » écartée plus haut : elle ne remplace pas le repli
+* atomique, qui reste le seul à trancher la course — elle ajoute le seul conflit
+* que le noyau n'exprime JAMAIS. La course résiduelle (un tiers prend le port
+* entre la sonde et le bind) retombe donc sur `EADDRINUSE`, inchangé.
+*
+* ## Pourquoi sauter les ports réservés
+*
+* HTTP veut 5151, HTTPS veut 5152. Si 5151 est pris, incrémenter naïvement ferait
+* voler 5152 à HTTPS — qui se décalerait à son tour, en cascade. Les ports que les
+* AUTRES serveurs convoitent sont donc sautés d'emblée.
+*
+* ## Fail-loud
+*
+* Un décalage est TOUJOURS annoncé (`onShift`) : une app qui écoute ailleurs que
+* là où on l'attend sans le dire est une dégradation silencieuse.
 */
-function resolvePortPolicy(environment, explicit) {
-	if (explicit === "auto" || explicit === "strict") return explicit;
-	return environment === "development" ? "auto" : "strict";
-}
+/** Nombre de ports essayés après le désiré, en `auto`. */
+const DEFAULT_PORT_RETRY_ATTEMPTS = 20;
 /** Port configuré d'un serveur, ou `0` (désactivé / non précisé → choix noyau). */
 function configuredPort(entry) {
 	if (!entry) return 0;
@@ -106,6 +134,8 @@ function portConflictError(port, host) {
 	error.code = "EADDRINUSE";
 	return error;
 }
+/** Plus grand numéro de port TCP (RFC 793) : au-delà, `listen` lève un `RangeError`. */
+const MAX_PORT = 65535;
 /** Prochain candidat : incrémente, en sautant ce que les autres serveurs veulent. */
 function nextCandidate(from, reserved) {
 	let port = from + 1;
@@ -143,12 +173,21 @@ function isPortUnavailable(code, port) {
 * handler d'erreur durable s'installe APRÈS, sur le serveur qui écoute — sinon il
 * verrait passer les `EADDRINUSE` de repli et croirait à une panne).
 *
+* @param server - serveur à mettre en écoute.
+* @param host - hôte passé à `listen`.
+* @param plan - port désiré et nombre de replis permis.
+* @param probe - sonde de présence (injectée par le banc).
+* @param sharedListener - vrai dans un worker `node:cluster` : le port y est
+*   PARTAGÉ par le maître, et un voisin qui y répond est un frère, pas un
+*   conflit. Sans cette exception, `nodefony cluster -w N` ne gardait qu'un
+*   worker en vie — les autres mouraient sur « port déjà servi » et
+*   bouclaient en relance.
 * @returns l'adresse obtenue + le port désiré si un décalage a eu lieu.
 * @throws l'erreur de `listen` : soit un code qui ne dit pas « ce port est pris »
 *   (`ENOTFOUND`, `EACCES` sous 1024 — cf `isPortUnavailable`), soit un port
 *   indisponible après épuisement des essais (le fallback n'est PAS infini).
 */
-async function bindWithFallback(server, host, plan, probe = isPortListening) {
+async function bindWithFallback(server, host, plan, probe = isPortListening, sharedListener = cluster.isWorker) {
 	let candidate = plan.desired;
 	let used = 0;
 	/**
@@ -170,16 +209,19 @@ async function bindWithFallback(server, host, plan, probe = isPortListening) {
 		server.listen(port, host);
 	});
 	for (;;) {
-		const conflict = plan.desired === 0 || candidate !== plan.desired ? null : await detectPortConflict(candidate, host, probe);
+		const conflict = sharedListener || plan.desired === 0 || candidate !== plan.desired ? null : await detectPortConflict(candidate, host, probe);
 		const failure = conflict ? portConflictError(candidate, conflict) : await listenOnce(candidate);
 		if (failure === null) return {
 			address: server.address(),
 			shiftedFrom: candidate === plan.desired ? null : plan.desired
 		};
-		if (!conflict && !isPortUnavailable(failure.code, candidate)) throw failure;
+		const code = failure.code;
+		if (!conflict && !isPortUnavailable(typeof code === "string" ? code : void 0, candidate)) throw failure;
 		if (plan.desired === 0 || used >= plan.attempts) throw failure;
 		used += 1;
-		candidate = nextCandidate(candidate, plan.reserved);
+		const next = nextCandidate(candidate, plan.reserved);
+		if (next > MAX_PORT) throw failure;
+		candidate = next;
 	}
 }
 //#endregion

package/dist/nodefony/src/session/session.js

@@ -57,8 +57,9 @@ var Session = class {
 	constructor(name, options, manager) {
 		this.options = extend({}, defaultSessionOptions, options);
 		this.manager = manager;
-		this.storage = this.manager.storage;
-		if (!this.storage) this.status = "disabled";
+		const storage = this.manager.storage;
+		this.storage = storage;
+		if (!storage) this.status = "disabled";
 		this.setName(name);
 		this.strategy = this.manager.sessionStrategy;
 	}
@@ -195,7 +196,7 @@ var Session = class {
 		return true;
 	}
 	setCookieSession(leftTime, options = {}) {
-		if (this.context && this.context.response) {
+		if (this.context?.response) {
 			const settings = extend({}, this.options.cookie, options);
 			if (leftTime) settings.maxAge = leftTime;
 			const cookie = new Cookie(this.context.getSessionCookieName(), this.id, settings);
@@ -207,7 +208,7 @@ var Session = class {
 		return null;
 	}
 	deleteCookieSession() {
-		if (this.context && this.context.response) {
+		if (this.context?.response) {
 			let cookie = this.cookieSession;
 			if (cookie) cookie.expires = /* @__PURE__ */ new Date(0);
 			else cookie = new Cookie(this.context.getSessionCookieName(), "", { expires: /* @__PURE__ */ new Date(0) });
@@ -219,11 +220,17 @@ var Session = class {
 		return this.cookieSession;
 	}
 	isValidSession(_data, context) {
-		if (this.options.refererCheck) try {
-			return this.checkSecureReferer(context);
-		} catch {
-			this.log(`SESSION REFERER MISMATCH ==> ${this.name} : ${this.id}`, "WARNING");
-			return false;
+		if (this.options.refererCheck) {
+			let sameHost = false;
+			try {
+				sameHost = this.checkSecureReferer(context);
+			} catch {
+				sameHost = false;
+			}
+			if (!sameHost) {
+				this.log(`SESSION REFERER MISMATCH ==> ${this.name} : ${this.id}`, "WARNING");
+				return false;
+			}
 		}
 		const now = Date.now();
 		if (this.options.absoluteTimeoutS && this.created) {
@@ -347,7 +354,8 @@ var Session = class {
 			user: user ?? this.user ?? ""
 		};
 	}
-	deSerialize(data) {
+	deSerialize(serialized) {
+		const data = serialized;
 		if (data.Attributes) for (const k in data.Attributes) this.attributesBag[k] = data.Attributes[k];
 		if (data.metaBag) for (const k in data.metaBag) this.metaBagStore[k] = data.metaBag[k];
 		if (data.flashBag) for (const k in data.flashBag) this.flashBag[k] = data.flashBag[k];

package/dist/nodefony/src/session/sessionStoreFailure.js

@@ -1,3 +1,4 @@
+import { thrownMessage } from "../errors/thrownMessage.js";
 //#region nodefony/src/session/sessionStoreFailure.ts
 /**
 * Reconnaît une table de session absente, quel que soit le dialecte.
@@ -18,7 +19,7 @@ function looksLikeMissingTable(text) {
 * @returns le statut, le corps à servir, et la ligne de journal.
 */
 function describeSessionStoreFailure(error) {
-	const cause = error instanceof Error ? error.message : String(error ?? "cause inconnue");
+	const cause = error === null || error === void 0 ? "cause inconnue" : thrownMessage(error);
 	return {
 		statusCode: 500,
 		body: "Internal Server Error — session store unavailable",

package/dist/nodefony/src/session/storage/RevocationGuardStorage.js

@@ -82,14 +82,29 @@ var RevocationGuardStorage = class {
 	constructor(inner) {
 		this.inner = inner;
 		this.sortableFields = inner.sortableFields;
-		if (typeof inner.listAll === "function") this.listAll = (filter) => inner.listAll(filter);
-		if (typeof inner.listPage === "function") this.listPage = (query) => inner.listPage(query);
-		if (typeof inner.countSessions === "function") this.countSessions = (query) => inner.countSessions(query);
-		if (typeof inner.countDistinctUsers === "function") this.countDistinctUsers = (query) => inner.countDistinctUsers(query);
-		if (typeof inner.touch === "function") this.touch = (id, idleSeconds) => {
-			if (this.#isRevoked(id)) return Promise.resolve();
-			return inner.touch(id, idleSeconds);
-		};
+		if (typeof inner.listAll === "function") {
+			const src = inner;
+			this.listAll = (filter) => src.listAll(filter);
+		}
+		if (typeof inner.listPage === "function") {
+			const src = inner;
+			this.listPage = (query) => src.listPage(query);
+		}
+		if (typeof inner.countSessions === "function") {
+			const src = inner;
+			this.countSessions = (query) => src.countSessions(query);
+		}
+		if (typeof inner.countDistinctUsers === "function") {
+			const src = inner;
+			this.countDistinctUsers = (query) => src.countDistinctUsers(query);
+		}
+		if (typeof inner.touch === "function") {
+			const src = inner;
+			this.touch = (id, idleSeconds) => {
+				if (this.#isRevoked(id)) return Promise.resolve();
+				return src.touch(id, idleSeconds);
+			};
+		}
 	}
 	read(id) {
 		return this.inner.read(id);
@@ -117,7 +132,7 @@ var RevocationGuardStorage = class {
 	#revoke(id) {
 		const now = Date.now();
 		this.#purgeExpired(now);
-		if (this.#tombstones === null) this.#tombstones = /* @__PURE__ */ new Map();
+		this.#tombstones ??= /* @__PURE__ */ new Map();
 		this.#tombstones.set(id, now + TOMBSTONE_TTL_MS);
 	}
 	#isRevoked(id) {