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

package/dist/nodefony/src/proxy/rules.js

@@ -0,0 +1,188 @@
+import { isLoopbackHostname } from "nodefony";
+// nodefony/src/proxy/rules.ts
+/**
+* Règles d'un montage du proxy inverse — UNIQUE source, lue par le schéma de
+* configuration (`proxy.mounts`) ET par `ReverseProxy.mount()` : un montage
+* écrit dans la config et un montage posé par un module obéissent aux mêmes
+* refus, avec les mêmes mots.
+*
+* Pur : n'importe que le cœur, importable depuis `config/config.ts` sans
+* cycle.
+*/
+/**
+* Préfixes que le framework se réserve : un montage n'y est JAMAIS accepté.
+* `/nodefony/` porte la console d'administration et les API de Studio — les
+* relayer ailleurs détournerait une surface protégée par le pare-feu.
+*/
+const RESERVED_PROXY_PREFIXES = ["/nodefony/"];
+/**
+* Préfixes réservés aux montages POSÉS PAR UN MODULE : la configuration ne
+* peut pas les prendre. `/_vite/` appartient à `@nodefony/frontend`, qui y
+* relaie ses serveurs Vite de développement.
+*/
+const MODULE_PROXY_PREFIXES = ["/_vite/"];
+/** Jeton de méthode HTTP (RFC 9110 §9.1 → `token`, §5.6.2). */
+const METHOD_TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+/** Nom de champ d'en-tête (RFC 9110 §5.1 → `token`). */
+const HEADER_TOKEN = METHOD_TOKEN;
+/**
+* Normalise un préfixe d'URL : `/` en tête et en fin, sans `/` doublé. Règle
+* UNIQUE des montages statiques et du proxy inverse — deux écritures du même
+* préfixe doivent désigner la même entrée.
+*
+* @param prefix - préfixe tel qu'écrit (`"svc"`, `"/svc"`, `"/svc/"`)
+* @returns le préfixe normalisé (`"/svc/"`)
+*/
+function normalizePrefix(prefix) {
+	let p = prefix.trim();
+	if (!p.startsWith("/")) p = `/${p}`;
+	if (!p.endsWith("/")) p = `${p}/`;
+	return p.replace(/\/{2,}/g, "/");
+}
+/**
+* Analyse une origine d'amont. Seule une origine NUE est acceptée : un chemin,
+* une requête, un fragment ou des identifiants dans la cible déplaceraient en
+* silence toutes les URL relayées, ou feraient voyager un secret dans la
+* configuration.
+*
+* @param origin - `scheme://hôte[:port]`
+* @returns l'URL analysée, ou `null` si ce n'est pas une origine http(s) nue
+*/
+function parseProxyOrigin(origin) {
+	let url;
+	try {
+		url = new URL(origin);
+	} catch {
+		return null;
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+	if (!/^https?:\/\/[^/?#]+\/?$/i.test(origin.trim())) return null;
+	if (url.search !== "" || url.hash !== "") return null;
+	if (url.username !== "" || url.password !== "") return null;
+	return url;
+}
+/**
+* Examine un montage. Rend TOUS les refus, pas le premier : une configuration
+* se corrige en une passe.
+*
+* @param prefix - préfixe tel qu'écrit
+* @param mount - réglages du montage
+* @param source - `"config"` (déclaré dans `proxy.mounts`) ou `"module"`
+*   (posé par un module) — seuls les préfixes réservés aux modules diffèrent
+* @returns la liste des refus, vide si le montage est sain
+*/
+function proxyMountProblems(prefix, mount, source) {
+	const problems = [];
+	const raw = prefix.trim();
+	const p = normalizePrefix(raw);
+	if (p === "/") problems.push({
+		field: "prefix",
+		message: "le préfixe « / » relaierait TOUTE l'application, routes et pare-feu compris — monter un préfixe dédié (`/svc/`)"
+	});
+	else if (/[?#\s\\%]/.test(raw) || p.split("/").some((s) => s === "." || s === "..")) problems.push({
+		field: "prefix",
+		message: `préfixe « ${raw} » invalide — un chemin littéral, sans « ? », « # », « % », « \\ », espace ni segment « . » / « .. »`
+	});
+	else if (RESERVED_PROXY_PREFIXES.some((r) => p.startsWith(r))) problems.push({
+		field: "prefix",
+		message: `le préfixe « ${p} » est réservé au framework (console d'administration)`
+	});
+	else if (source === "config" && MODULE_PROXY_PREFIXES.some((r) => p.startsWith(r))) problems.push({
+		field: "prefix",
+		message: `le préfixe « ${p} » est réservé à @nodefony/frontend (serveurs Vite de développement), qui le monte lui-même`
+	});
+	let target = null;
+	if (typeof mount.target === "string") {
+		target = parseProxyOrigin(mount.target);
+		if (target === null) problems.push({
+			field: "target",
+			message: `cible « ${mount.target} » invalide — attendu une origine http(s) nue (\`scheme://hôte[:port]\`), sans chemin, requête ni identifiants`
+		});
+	} else if (typeof mount.target !== "function") problems.push({
+		field: "target",
+		message: "cible absente — une origine `scheme://hôte[:port]`"
+	});
+	if (mount.secure === false && target !== null) {
+		if (target.protocol !== "https:") problems.push({
+			field: "secure",
+			message: "`secure: false` ne concerne qu'une cible https: — le retirer"
+		});
+		else if (!isLoopbackHostname(target.hostname)) problems.push({
+			field: "secure",
+			message: `\`secure: false\` refusé vers « ${target.hostname} » : sans vérification de certificat, n'importe qui sur le chemin réseau se fait passer pour l'amont. Réservé à la boucle locale — sinon, fournir l'autorité de certification de l'amont au processus (\`http.certificates.extraCaFiles\`, ou NODE_EXTRA_CA_CERTS)`
+		});
+	}
+	if (mount.methods !== void 0) {
+		if (mount.methods.length === 0) problems.push({
+			field: "methods",
+			message: "liste de méthodes vide : rien ne serait relayé — retirer `methods` pour toutes"
+		});
+		for (const m of mount.methods) if (!METHOD_TOKEN.test(m)) problems.push({
+			field: "methods",
+			message: `méthode « ${m} » invalide (RFC 9110 §9.1)`
+		});
+	}
+	for (const h of mount.stripHeaders ?? []) if (!HEADER_TOKEN.test(h)) problems.push({
+		field: "stripHeaders",
+		message: `nom d'en-tête « ${h} » invalide`
+	});
+	else if (h.toLowerCase() === "host") problems.push({
+		field: "stripHeaders",
+		message: "« host » ne se retire pas : il est toujours posé — voir `preserveHost`"
+	});
+	if (mount.timeoutMs !== void 0 && (!Number.isInteger(mount.timeoutMs) || mount.timeoutMs <= 0)) problems.push({
+		field: "timeoutMs",
+		message: `délai « ${mount.timeoutMs} » invalide — un entier de millisecondes > 0`
+	});
+	return problems;
+}
+/** Encodages qui changent le SENS d'un chemin selon qui le décode. */
+const AMBIGUOUS_ENCODING = /%(?:2e|2f|5c|00|25)/i;
+/**
+* Le chemin d'une requête relayée est-il ambigu ? Un chemin que le proxy et
+* l'amont pourraient lire différemment — segment `.`/`..`, barre inverse,
+* octet nul, ou leur forme encodée (`%2e`, `%2f`, `%5c`, `%00`, `%25`) — est
+* REFUSÉ (400), jamais normalisé en silence : c'est le défaut de Traefik, et
+* la parade aux contournements de préfixe (`/svc/..%2fadmin`).
+*
+* @param url - cible brute de la requête (chemin + requête éventuelle)
+* @returns `true` si le chemin doit être refusé
+*/
+function isAmbiguousPath(url) {
+	const q = url.indexOf("?");
+	const path = q === -1 ? url : url.slice(0, q);
+	if (path.includes("\\") || path.includes("\0")) return true;
+	if (AMBIGUOUS_ENCODING.test(path)) return true;
+	for (const segment of path.split("/")) if (segment === "." || segment === "..") return true;
+	return false;
+}
+/** Clé de handshake : 16 octets en base64 (RFC 6455 §4.1, §4.2.1). */
+const WS_KEY = /^\s*[A-Za-z0-9+/]{22}==\s*$/;
+/** `Upgrade: websocket`, casse et blancs indifférents. */
+const UPGRADE_WEBSOCKET = /^\s*websocket\s*$/i;
+/** Le jeton `upgrade` dans une liste `Connection` (RFC 9110 §7.6.1). */
+const CONNECTION_UPGRADE = /(?:^|,)\s*upgrade\s*(?:,|$)/i;
+/**
+* Un upgrade est-il un handshake WebSocket conforme (RFC 6455 §4.2.1) ? Seul
+* un tel handshake est relayé : un `Upgrade` quelconque (`h2c`…) raccordé
+* octet pour octet ouvrirait un tunnel que rien n'inspecte.
+*
+* Appelé à CHAQUE handshake (proxy inverse et routes de Nodefony) : aucune
+* allocation — des expressions testées, jamais de découpe de chaîne.
+*
+* @param method - méthode de la requête
+* @param headers - en-têtes reçus
+* @returns la raison du refus, ou `null` si le handshake est conforme
+*/
+function websocketHandshakeProblem(method, headers) {
+	if (method !== "GET") return "méthode autre que GET";
+	const upgrade = headers.upgrade;
+	if (typeof upgrade !== "string" || !UPGRADE_WEBSOCKET.test(upgrade)) return "Upgrade autre que websocket";
+	const connection = headers.connection;
+	if (!(typeof connection === "string" ? CONNECTION_UPGRADE.test(connection) : Array.isArray(connection) && connection.some((token) => CONNECTION_UPGRADE.test(token)))) return "Connection sans upgrade";
+	if (headers["sec-websocket-version"] !== "13") return "Sec-WebSocket-Version ≠ 13";
+	const key = headers["sec-websocket-key"];
+	if (typeof key !== "string" || !WS_KEY.test(key)) return "Sec-WebSocket-Key invalide";
+	return null;
+}
+export { MODULE_PROXY_PREFIXES, RESERVED_PROXY_PREFIXES, isAmbiguousPath, normalizePrefix, parseProxyOrigin, proxyMountProblems, websocketHandshakeProblem };

package/dist/nodefony/src/rateLimit/MemoryRateLimitStore.js

@@ -1,5 +1,5 @@
 import { assertPageQuery } from "nodefony";
-//#region nodefony/src/rateLimit/MemoryRateLimitStore.ts
+// nodefony/src/rateLimit/MemoryRateLimitStore.ts
 /**
 * Store de rate-limit **en mémoire** — algorithme *fixed window* par clé (IP).
 *
@@ -142,5 +142,4 @@ var MemoryRateLimitStore = class {
 		}
 	}
 };
-//#endregion
 export { MemoryRateLimitStore };

package/dist/nodefony/src/rateLimit/WsConnectionCounter.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/rateLimit/WsConnectionCounter.ts
+// nodefony/src/rateLimit/WsConnectionCounter.ts
 /**
 * Compteur de connexions WebSocket CONCURRENTES par IP — backstop opt-in
 * (F6c, revue 0.6). Distinct du {@link MemoryRateLimitStore} : celui-ci compte un
@@ -60,5 +60,4 @@ var WsConnectionCounter = class {
 		return this.#rejectedTotal;
 	}
 };
-//#endregion
 export { WsConnectionCounter, WsConnectionCounter as default };

package/dist/nodefony/src/rateLimit/rateLimitFilters.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/rateLimit/rateLimitFilters.ts
+// nodefony/src/rateLimit/rateLimitFilters.ts
 /**
 * **Le vocabulaire de filtre du registre de rate-limit**, en noms PUBLICS —
 * celui que la console écrit dans l'URL (`?limited=true`).
@@ -16,5 +16,4 @@
 const RATE_LIMIT_FILTERS = { 
 /** `true` = seulement les clés au plafond, `false` = seulement les autres. */
 limited: "boolean" };
-//#endregion
 export { RATE_LIMIT_FILTERS };

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

@@ -0,0 +1,50 @@
+// nodefony/src/servers/http2Limits.ts
+/**
+* Limites anti-DoS d'un serveur HTTP/2, lues dans la section `http2` du module :
+* `maxSessionMemory` (amplification mémoire) et `maxConcurrentStreams` dans les
+* SETTINGS (CVE-2023-44487, Rapid Reset). Règle UNIQUE des serveurs HTTP/2 — TLS
+* (5152) comme h2c — : une limite oubliée sur l'un d'eux en ferait la porte de
+* l'attaque.
+*
+* Une limite absente garde le défaut de Node (aucune régression).
+*
+* @param limits - `module.options.http2`.
+* @returns les options à fusionner dans celles de `createServer`/`createSecureServer`.
+*/
+function http2ServerLimits(limits) {
+	const options = {};
+	if (limits?.maxSessionMemory) options.maxSessionMemory = limits.maxSessionMemory;
+	if (limits?.maxConcurrentStreams) options.settings = { maxConcurrentStreams: limits.maxConcurrentStreams };
+	return options;
+}
+/**
+* Borne l'inactivité des sessions d'un serveur HTTP/2 — TLS (5152) comme h2c —
+* et contourne un défaut de Node qui garde chaque session fermée en vie jusqu'à
+* l'échéance de ce délai.
+*
+* Le défaut (Node 24, 26) : `closeSession` (`internal/http2/core`) marque la
+* session détruite PUIS appelle `session.setTimeout(0)` ; or `setStreamTimeout`
+* sort aussitôt sur un objet détruit. Le minuteur n'est jamais désarmé et retient
+* la session (~2,4 Ko) pendant `timeoutMs` : sous un flux de connexions neuves,
+* connexions/s × délai × 2,4 Ko. Signalé à Node : https://github.com/nodejs/node/issues/66885
+*
+* Le contournement : désarmer à la réception du GOAWAY, AVANT la destruction —
+* c'est ainsi que ferment un proxy et un client Node, même par `destroy()`. Rien
+* n'est retiré à la protection : Node n'agit déjà plus à l'échéance sur une
+* session fermée (`sessionOnTimeout` sort sur `closed`). Une coupure TCP sans
+* GOAWAY garde la rétention, bornée au délai.
+*
+* @param server - le serveur HTTP/2.
+* @param timeoutMs - délai d'inactivité ; 0 ou absent le laisse désactivé.
+* @param onTimeout - appelé à l'échéance (événement `timeout` du serveur).
+*/
+function setHttp2SessionTimeout(server, timeoutMs, onTimeout) {
+	if (!timeoutMs) return;
+	server.setTimeout(timeoutMs, onTimeout);
+	server.on("session", (session) => {
+		session.once("goaway", () => {
+			session.setTimeout(0);
+		});
+	});
+}
+export { http2ServerLimits, setHttp2SessionTimeout };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/servers/kernelServers.ts
+// 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`.
@@ -13,6 +13,15 @@ function asServersConfig(servers) {
 	return servers !== null && typeof servers === "object" ? servers : void 0;
 }
 /**
+* Le serveur h2c démarre-t-il ? Seul un `enabled: true` EXPLICITE l'allume : la
+* section existe toujours (défauts), un port seul ne vaut pas activation.
+*
+* @param entry - `servers.h2c`.
+*/
+function isH2cEnabled(entry) {
+	return entry?.enabled === true;
+}
+/**
 * Port DEMANDÉ pour un serveur (`servers.<type>.port`), ou `undefined` si le
 * serveur est désactivé, absent, ou sans port numérique.
 *
@@ -22,8 +31,8 @@ function asServersConfig(servers) {
 function configuredServerPort(servers, type) {
 	const entry = servers?.[type];
 	if (!entry) return void 0;
+	if (type === "h2c" && !isH2cEnabled(servers.h2c)) return void 0;
 	const port = entry.port;
 	return typeof port === "number" ? port : void 0;
 }
-//#endregion
-export { asServersConfig, configuredServerPort };
+export { asServersConfig, configuredServerPort, isH2cEnabled };

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

@@ -1,6 +1,7 @@
+import { isH2cEnabled } from "./kernelServers.js";
 import { isPortListening, resolvePortPolicy } from "nodefony";
 import cluster from "node:cluster";
-//#region nodefony/src/servers/portBinder.ts
+// nodefony/src/servers/portBinder.ts
 /**
 * **portBinder** — écoute sur le port désiré, ou sur le prochain port libre.
 *
@@ -48,27 +49,58 @@ import cluster from "node:cluster";
 */
 /** Nombre de ports essayés après le désiré, en `auto`. */
 const DEFAULT_PORT_RETRY_ATTEMPTS = 20;
+const BOUND_SERVERS = [
+	"http",
+	"https",
+	"h2c"
+];
 /** Port configuré d'un serveur, ou `0` (désactivé / non précisé → choix noyau). */
-function configuredPort(entry) {
+function configuredPort(servers, which) {
+	if (which === "h2c") {
+		const entry = servers?.h2c;
+		return isH2cEnabled(entry) ? entry?.port ?? 0 : 0;
+	}
+	const entry = servers?.[which];
 	if (!entry) return 0;
 	return entry.port ?? 0;
 }
 /**
+* Serveur actif qui convoite le MÊME port que h2c, ou `null`.
+*
+* Un port partagé avec h2c n'est pas un conflit à contourner : sur ce port, le
+* client HTTP/1.1 et le proxy h2c se marchent dessus, et le repli `auto` ferait
+* glisser l'un des deux là où personne ne l'attend. Le boot le refuse.
+*
+* @param servers - `kernel.options.servers`.
+* @returns `"http"` ou `"https"` en conflit, sinon `null` (h2c inactif, port 0).
+*/
+function h2cPortConflict(servers) {
+	const port = configuredPort(servers, "h2c");
+	if (port === 0) return null;
+	if (configuredPort(servers, "http") === port) return "http";
+	if (configuredPort(servers, "https") === port) return "https";
+	return null;
+}
+/**
 * Compose le plan de bind d'un serveur depuis la config du kernel — source UNIQUE
-* (les deux serveurs l'appellent ; la politique n'est décidée qu'ici).
+* (les serveurs l'appellent ; la politique n'est décidée qu'ici).
 *
 * @param which - le serveur qu'on borne.
 * @param servers - `kernel.options.servers`.
 * @param environment - `kernel.environment` (arbitre le défaut de la politique).
 */
 function buildBindPlan(which, servers, environment) {
-	const desired = configuredPort(servers?.[which]);
-	const other = configuredPort(servers?.[which === "http" ? "https" : "http"]);
-	const policy = resolvePortPolicy(environment, servers?.portPolicy);
+	const desired = configuredPort(servers, which);
+	const reserved = [];
+	for (const other of BOUND_SERVERS) {
+		if (other === which) continue;
+		const port = configuredPort(servers, other);
+		if (port > 0 && port !== desired) reserved.push(port);
+	}
 	return {
 		desired,
-		reserved: other > 0 && other !== desired ? [other] : [],
-		attempts: policy === "auto" ? servers?.portRetryAttempts ?? 20 : 0
+		reserved,
+		attempts: resolvePortPolicy(environment, servers?.portPolicy) === "auto" ? servers?.portRetryAttempts ?? 20 : 0
 	};
 }
 /** Adresses qui désignent « toutes les interfaces » — rien ne s'y connecte. */
@@ -224,5 +256,4 @@ async function bindWithFallback(server, host, plan, probe = isPortListening, sha
 		candidate = next;
 	}
 }
-//#endregion
-export { DEFAULT_PORT_RETRY_ATTEMPTS, bindWithFallback, buildBindPlan, conflictProbeTargets, detectPortConflict, resolvePortPolicy };
+export { DEFAULT_PORT_RETRY_ATTEMPTS, bindWithFallback, buildBindPlan, conflictProbeTargets, detectPortConflict, h2cPortConflict, resolvePortPolicy };

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

@@ -0,0 +1,128 @@
+import { websocketHandshakeProblem } from "../proxy/rules.js";
+import { refuseUpgrade } from "../proxy/forward.js";
+import { STATUS_CODES } from "node:http";
+// nodefony/src/servers/upgradeDispatch.ts
+/** Défaut sans noyau : tout upgrade conforme est accepté puis émis en `connection`. */
+function acceptAll(wss) {
+	return (req, admission) => {
+		const accepted = admission.accept();
+		if (accepted instanceof Promise) accepted.then((ws) => {
+			if (ws !== null) wss.emit("connection", ws, req);
+		});
+		else if (accepted !== null) wss.emit("connection", accepted, req);
+	};
+}
+/**
+* Le verdict d'UN upgrade. Pendant que le noyau décide, le socket n'a plus
+* d'écouteur `error` (`node:http` retire les siens à l'émission d'`upgrade`,
+* `ws` ne pose les siens qu'à `handleUpgrade`) : une coupure du client
+* (`ECONNRESET`) y deviendrait une erreur non gérée qui abat le process. D'où
+* l'écouteur de la fenêtre d'attente, retiré quand le verdict tombe.
+*
+* Une classe, pas un objet de fermetures : une allocation par handshake (plus
+* l'écouteur), méthodes partagées par le prototype.
+*/
+var UpgradeAdmission = class {
+	wss;
+	req;
+	socket;
+	head;
+	#accepted = void 0;
+	#settled = false;
+	#onPendingError;
+	constructor(wss, req, socket, head) {
+		this.wss = wss;
+		this.req = req;
+		this.socket = socket;
+		this.head = head;
+		this.#onPendingError = () => socket.destroy();
+		socket.on("error", this.#onPendingError);
+	}
+	#settle() {
+		if (this.#settled) return false;
+		this.#settled = true;
+		this.socket.removeListener("error", this.#onPendingError);
+		return true;
+	}
+	accept() {
+		if (this.#accepted !== void 0) return this.#accepted;
+		if (!this.#settle()) return this.#accepted = null;
+		const { socket } = this;
+		if (socket.destroyed || !socket.writable) {
+			socket.destroy();
+			return this.#accepted = null;
+		}
+		let ws;
+		let late = null;
+		const onClose = () => late?.(null);
+		this.wss.handleUpgrade(this.req, socket, this.head, (accepted) => {
+			if (late === null) {
+				ws = accepted;
+				return;
+			}
+			socket.removeListener("close", onClose);
+			late(accepted);
+		});
+		if (ws !== void 0) return this.#accepted = ws;
+		socket.once("close", onClose);
+		return this.#accepted = new Promise((resolve) => {
+			late = resolve;
+		});
+	}
+	refuse(status, headers) {
+		if (!this.#settle()) return;
+		refuseUpgrade(this.socket, status, STATUS_CODES[status] ?? "Refused", headers);
+	}
+};
+/**
+* Pose l'UNIQUE écouteur `upgrade` d'un serveur : le proxy inverse d'abord,
+* puis le serveur WebSocket de Nodefony.
+*
+* Pourquoi un seul écouteur : `ws` attaché par son option `server` prend TOUS
+* les upgrades et répond `400` à ceux qu'il ne reconnaît pas. Un second
+* écouteur, même posé avant, ne l'empêcherait pas de répondre sur un socket
+* déjà relayé. Le serveur `ws` est donc créé en `noServer`, et c'est ici que
+* l'upgrade lui est confié — avec ses propres contrôles intacts (`path`,
+* `verifyClient`, `maxPayload`…), que `handleUpgrade` applique.
+*
+* Entre les deux, `refusal` tranche ce qui doit être refusé AVANT le `101`
+* (RFC 6455 §4.2.2) : un chemin sans route WebSocket reçoit un statut HTTP,
+* jamais une ouverture suivie d'une fermeture. Puis la FORME du handshake est
+* contrôlée (`websocketHandshakeProblem`, la règle du proxy inverse) : un
+* handshake malformé reçoit `400` sans jamais atteindre le noyau. Enfin
+* `admit` décide — pare-feu, garde de l'action — et seul son verdict ouvre.
+*
+* Sans montage, le coût par connexion est une lecture de champ.
+*
+* @param server - serveur HTTP(S) qui reçoit les upgrades
+* @param wss - serveur WebSocket de Nodefony (`noServer: true`)
+* @param relay - proxy inverse, lu à chaque upgrade (il peut naître après)
+* @param refusal - statut HTTP qui refuse l'upgrade, `null` pour l'admettre
+*   (cf `HttpKernel.websocketUpgradeRefusal`)
+* @param admit - décide d'un upgrade admis (cf `HttpKernel.onWebsocketUpgrade`) ;
+*   par défaut, tout upgrade conforme est accepté et émis en `connection`
+* @returns la fonction qui retire l'écouteur — à appeler à l'arrêt
+*/
+function attachUpgradeDispatch(server, wss, relay, refusal, admit = acceptAll(wss)) {
+	const onUpgrade = (req, socket, head) => {
+		const proxy = relay();
+		if (proxy !== null && proxy.mounts !== null) {
+			if (proxy.handleUpgrade(req, socket, head)) return;
+		}
+		const status = refusal(req);
+		if (status !== null) {
+			refuseUpgrade(socket, status, STATUS_CODES[status] ?? "Refused");
+			return;
+		}
+		if (websocketHandshakeProblem(req.method, req.headers) !== null) {
+			refuseUpgrade(socket, 400, STATUS_CODES[400] ?? "Bad Request");
+			return;
+		}
+		admit(req, new UpgradeAdmission(wss, req, socket, head));
+	};
+	server.on("upgrade", onUpgrade);
+	return () => {
+		server.removeListener("upgrade", onUpgrade);
+	};
+}
+export { attachUpgradeDispatch };

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

@@ -1,7 +1,7 @@
 import Cookie from "../cookies/cookie.js";
 import { extend } from "nodefony";
 import { randomBytes } from "node:crypto";
-//#region nodefony/src/session/session.ts
+// nodefony/src/session/session.ts
 const defaultSessionOptions = {
 	name: "nodefony",
 	strictMode: true,
@@ -9,6 +9,20 @@ const defaultSessionOptions = {
 };
 /** Taille de l'identifiant opaque (octets CSPRNG → base64url, 43 chars). */
 const SESSION_ID_BYTES = 32;
+/** Un sac de session relu du storage : objet, ni `null` ni tableau. */
+function isBag(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+* Une date relue du storage : `Date` d'un store mémoire, chaîne ou nombre d'un
+* store sérialisé. Toute autre forme → `undefined` (la valeur courante reste).
+* Convertie UNE fois à la lecture : `created`/`updated` sont alors toujours des
+* `Date`, et les contrôles du chemin chaud lisent `getTime()` sans allouer.
+*/
+function toDate(v) {
+	if (v instanceof Date) return v;
+	return typeof v === "string" || typeof v === "number" ? new Date(v) : void 0;
+}
 /**
 * Session serveur Nodefony — état persistant lié à une identité, indexé par un
 * identifiant **opaque** (porté par le cookie) dans un {@link ISessionStorage}
@@ -157,16 +171,19 @@ var Session = class {
 	* `onSaveSession`.
 	*
 	* @param user - principal authentifié (string) lié au blob ; défaut courant.
+	*   Fourni, il DEVIENT le principal de la session : une sauvegarde suivante,
+	*   dans la même requête, le garde sans qu'on le lui redonne.
 	*/
 	async save(user) {
+		if (user !== void 0) this.user = user;
 		if (this.readOnly) {
 			if (this.mutated) this.log(`READONLY SESSION mutated — write skipped : ${this.name}`, "WARNING");
 			return this;
 		}
 		if (!this.mutated) return this;
 		const stored = await this.storage.write(this.id, this.serialize(user));
-		this.created = stored.createdAt ?? this.created;
-		this.updated = stored.updatedAt ?? this.updated;
+		this.created = toDate(stored.createdAt) ?? this.created;
+		this.updated = toDate(stored.updatedAt) ?? this.updated;
 		this.mutated = false;
 		this.saved = true;
 		if (this.context) await this.context.fireAsync("onSaveSession", this);
@@ -221,7 +238,7 @@ var Session = class {
 	}
 	isValidSession(_data, context) {
 		if (this.options.refererCheck) {
-			let sameHost = false;
+			let sameHost;
 			try {
 				sameHost = this.checkSecureReferer(context);
 			} catch {
@@ -234,15 +251,14 @@ var Session = class {
 		}
 		const now = Date.now();
 		if (this.options.absoluteTimeoutS && this.created) {
-			if (now - new Date(this.created).getTime() > this.options.absoluteTimeoutS * 1e3) {
+			if (!(now - this.created.getTime() <= this.options.absoluteTimeoutS * 1e3)) {
 				this.log(`SESSION EXPIRED (absolute) ==> ${this.name} : ${this.id}`, "WARNING");
 				return false;
 			}
 		}
 		const idleS = this.options.idleTimeoutS;
 		if (idleS && idleS > 0 && this.updated) {
-			const lastUsed = new Date(this.updated).getTime();
-			if (lastUsed && lastUsed + idleS * 1e3 < now) {
+			if (!(this.updated.getTime() + idleS * 1e3 >= now)) {
 				this.log(`SESSION EXPIRED (idle) ==> ${this.name} : ${this.id}`, "WARNING");
 				return false;
 			}
@@ -270,7 +286,7 @@ var Session = class {
 		if (typeof storage.touch !== "function") return;
 		if (!this.updated) return;
 		const now = Date.now();
-		const lastUsed = new Date(this.updated).getTime();
+		const lastUsed = this.updated.getTime();
 		if (lastUsed && now - lastUsed < idleS * 1e3 / 2) return;
 		await storage.touch(this.id, idleS);
 		this.updated = new Date(now);
@@ -356,12 +372,12 @@ var Session = class {
 	}
 	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];
-		this.created = data.createdAt ?? this.created;
-		this.updated = data.updatedAt ?? this.updated;
-		if (data.user) this.user = data.user;
+		if (isBag(data.Attributes)) for (const k in data.Attributes) this.attributesBag[k] = data.Attributes[k];
+		if (isBag(data.metaBag)) for (const k in data.metaBag) this.metaBagStore[k] = data.metaBag[k];
+		if (isBag(data.flashBag)) for (const k in data.flashBag) this.flashBag[k] = data.flashBag[k];
+		this.created = toDate(data.createdAt) ?? this.created;
+		this.updated = toDate(data.updatedAt) ?? this.updated;
+		if (typeof data.user === "string" && data.user) this.user = data.user;
 	}
 	/** Réinitialise les trois sacs (attributs, métas, flash) — état vide. */
 	clear() {
@@ -394,5 +410,4 @@ var Session = class {
 		}
 	}
 };
-//#endregion
 export { Session as default };

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

@@ -1,5 +1,5 @@
 import { thrownMessage } from "../errors/thrownMessage.js";
-//#region nodefony/src/session/sessionStoreFailure.ts
+// nodefony/src/session/sessionStoreFailure.ts
 /**
 * Reconnaît une table de session absente, quel que soit le dialecte.
 *
@@ -26,5 +26,4 @@ function describeSessionStoreFailure(error) {
 		message: `La session n'a pas pu être persistée — la requête est servie en 500 plutôt que laissée sans réponse. Cause : ${cause}.${looksLikeMissingTable(cause) ? " La table de session est probablement absente : appliquer les migrations (`nodefony orm:migrate`) avant de servir, ou choisir un autre stockage (`http.session.store`)." : " Vérifier que le stockage de session déclaré sous `http.session.store` est joignable ; à défaut, appliquer les migrations (`nodefony orm:migrate`)."}`
 	};
 }
-//#endregion
 export { describeSessionStoreFailure };

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

@@ -1,6 +1,6 @@
 import { SESSION_DEFAULT_ORDER, SESSION_SORTABLE_FIELDS } from "./sessionSort.js";
 import { assertPageQuery, compareByOrder, pickOrder } from "nodefony";
-//#region nodefony/src/session/storage/MemorySessionStorage.ts
+// nodefony/src/session/storage/MemorySessionStorage.ts
 /**
 * Store de sessions **en mémoire** (Map process) — implémentation de référence
 * d'{@link ISessionStorage}, pendant `session` des `Memory*Store` de sécurité.
@@ -181,5 +181,4 @@ var MemorySessionStorage = class {
 		return Promise.resolve(users.size);
 	}
 };
-//#endregion
 export { MemorySessionStorage as default };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/session/storage/RevocationGuardStorage.ts
+// nodefony/src/session/storage/RevocationGuardStorage.ts
 /**
 * Durée de vie (ms) d'une pierre tombale de révocation. Couvre la fenêtre
 * pendant laquelle une requête « en vol » — qui avait chargé la session AVANT
@@ -148,5 +148,4 @@ var RevocationGuardStorage = class {
 		if (t.size === 0) this.#tombstones = null;
 	}
 };
-//#endregion
 export { RevocationGuardStorage as default };