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

package/dist/nodefony/service/reverse-proxy.js

@@ -0,0 +1,336 @@
+import { isAmbiguousPath, normalizePrefix, parseProxyOrigin, proxyMountProblems, websocketHandshakeProblem } from "../src/proxy/rules.js";
+import { forwardRequest, forwardUpgrade, refuseUpgrade } from "../src/proxy/forward.js";
+import { Service } from "nodefony";
+import http from "node:http";
+import { randomBytes } from "node:crypto";
+import https from "node:https";
+import { TLSSocket } from "node:tls";
+//#region nodefony/service/reverse-proxy.ts
+/** Replis si la section `proxy` manque (module construit hors configuration). */
+const DEFAULT_TIMEOUT_MS = 3e4;
+const DEFAULT_CONNECT_TIMEOUT_MS = 5e3;
+const DEFAULT_MAX_SOCKETS = 256;
+/**
+* Proxy inverse de Nodefony : relaie un préfixe d'URL vers un autre serveur
+* HTTP — requêtes ET, sur demande, upgrades WebSocket — sur la MÊME origine
+* que la page. Le client ne voit qu'un serveur, un certificat ; l'amont peut
+* rester sur la boucle locale.
+*
+* Deux sources de montages, mêmes règles (`src/proxy/rules.ts`) : la section
+* `proxy.mounts` de la configuration, lue à la construction, et
+* {@link ReverseProxy.mount}, appelé par un module (`@nodefony/frontend` y
+* relaie `/_vite/<famille>/` vers ses serveurs Vite de développement). Un
+* module se résout ce service par NOM (`container.get("reverse-proxy")`) :
+* il n'a pas à importer `@nodefony/http`.
+*
+* Consulté AVANT le routage : une route attrape-tout de l'application ne peut
+* pas avaler un préfixe relayé. Sans montage, le pipeline ne paie qu'une
+* lecture de champ (`mounts === null`) — c'est le cas de toute application
+* qui ne s'en sert pas.
+*
+* Règles communes à tout montage : en-têtes de connexion jamais transmis
+* (RFC 9110 §7.6.1), `X-Forwarded-For/-Proto/-Host` et `Via` posés par le
+* proxy, Host hors `trustedHosts` jamais relayé (même barrière, même 421 que
+* toute requête), amont injoignable → 502, amont muet → 504, boucle → 508.
+*/
+var ReverseProxy = class extends Service {
+	module;
+	/**
+	* Montages actifs, du préfixe le PLUS LONG au plus court : le premier qui
+	* couvre une URL est le plus spécifique. `null` tant qu'il n'y en a aucun.
+	*/
+	mounts = null;
+	/** Délai d'inactivité appliqué aux montages qui n'en fixent pas (`proxy.timeoutMs`). */
+	defaultTimeoutMs;
+	/** Délai d'établissement de la connexion amont (`proxy.connectTimeoutMs`). */
+	connectTimeoutMs;
+	/** Connexions simultanées par amont (`proxy.maxSockets`) : pool ET tunnels WebSocket. */
+	maxSockets;
+	/**
+	* Arrêt engagé ({@link closeAll}) : un relais encore en vol ne recrée plus
+	* de pool — il passerait après la fermeture et garderait ses sockets.
+	*/
+	#closing = false;
+	/**
+	* Nom de CE processus dans `Via` (RFC 9110 §7.6.3) : tiré au hasard au
+	* démarrage, il ne dit rien de la machine et distingue deux instances —
+	* un message qui le porte déjà est une boucle (508).
+	*/
+	pseudonym = `nodefony-${randomBytes(4).toString("hex")}`;
+	constructor(module) {
+		const container = module.container ?? void 0;
+		const event = container?.get("notificationsCenter");
+		super("reverse-proxy", container, event, {});
+		this.module = module;
+		const section = module.options.proxy;
+		this.defaultTimeoutMs = section?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+		this.connectTimeoutMs = section?.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+		this.maxSockets = section?.maxSockets ?? DEFAULT_MAX_SOCKETS;
+		this.kernel?.prependOnceListener("onTerminate", () => this.closeAll());
+		for (const [prefix, mount] of Object.entries(section?.mounts ?? {})) this.#add(prefix, mount, "config");
+	}
+	/**
+	* Relaie un préfixe d'URL vers un amont. Idempotent pour un même module :
+	* un même préfixe est remplacé. Un module qui recouvre un préfixe de la
+	* CONFIGURATION le remplace aussi, mais le dit — l'auteur de l'application
+	* doit pouvoir lire pourquoi son montage ne sert plus.
+	*
+	* @param prefix - préfixe d'URL (normalisé : `/` en tête et en fin)
+	* @param options - cible et réglages du montage
+	* @throws Error qui nomme chaque refus (préfixe `/` ou réservé, cible qui
+	*   n'est pas une origine http(s) nue, `secure: false` hors boucle locale…)
+	*/
+	mount(prefix, options) {
+		this.#add(prefix, options, "module");
+	}
+	#add(prefix, options, source) {
+		const problems = proxyMountProblems(prefix, options, source);
+		if (problems.length > 0) throw new Error(`reverse-proxy : montage « ${prefix} » refusé — ` + problems.map((p) => `${p.field} : ${p.message}`).join(" ; "));
+		const p = normalizePrefix(prefix);
+		const record = {
+			...options,
+			prefix: p,
+			source,
+			lastOrigin: void 0,
+			lastUrl: void 0,
+			agent: null,
+			tunnels: 0
+		};
+		if (options.methods) record.methods = options.methods.map((m) => m.toUpperCase());
+		if (options.stripHeaders) record.stripHeaders = options.stripHeaders.map((h) => h.toLowerCase());
+		record.timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
+		const mounts = this.mounts ??= [];
+		const i = mounts.findIndex((m) => m.prefix === p);
+		if (i >= 0) {
+			const previous = mounts[i];
+			if (previous?.source === "config" && source === "module") this.log(`le montage « ${p} » de la configuration est remplacé par un module`, "WARNING");
+			previous?.agent?.destroy();
+			mounts[i] = record;
+		} else {
+			mounts.push(record);
+			mounts.sort((a, b) => b.prefix.length - a.prefix.length);
+		}
+		this.log(`mount ${p} (${source})`, "DEBUG");
+	}
+	/**
+	* Retire un montage. Le dernier retiré rend `mounts` à `null` : le pipeline
+	* cesse alors de le consulter.
+	*
+	* @param prefix - préfixe tel que monté (normalisé de la même façon)
+	*/
+	unmount(prefix) {
+		if (this.mounts === null) return;
+		const p = normalizePrefix(prefix);
+		const kept = [];
+		for (const m of this.mounts) if (m.prefix === p) m.agent?.destroy();
+		else kept.push(m);
+		this.mounts = kept.length > 0 ? kept : null;
+	}
+	/**
+	* Ferme tous les pools (arrêt du noyau). Les montages restent déclarés ; un
+	* relais encore en vol part ensuite sur une connexion à usage unique.
+	*/
+	closeAll() {
+		this.#closing = true;
+		for (const m of this.mounts ?? []) {
+			m.agent?.destroy();
+			m.agent = null;
+		}
+	}
+	/**
+	* Montage le plus spécifique qui couvre une URL, s'il y en a un.
+	*
+	* @param url - cible brute de la requête (chemin + requête)
+	* @returns le montage au préfixe le plus long qui couvre l'URL
+	*/
+	match(url) {
+		const mounts = this.mounts;
+		if (mounts === null || url === void 0) return void 0;
+		for (const m of mounts) if (url.startsWith(m.prefix)) return m;
+	}
+	/**
+	* Origine courante d'un montage, analysée — mise en cache tant que la cible
+	* rend la même chaîne.
+	*
+	* @returns l'URL de l'amont, ou `undefined` si rien n'est relayable
+	*/
+	targetOf(mount) {
+		const origin = typeof mount.target === "string" ? mount.target : mount.target();
+		if (origin === void 0) return void 0;
+		if (origin === mount.lastOrigin) return mount.lastUrl;
+		const url = parseProxyOrigin(origin) ?? void 0;
+		if (url === void 0) this.log(`cible « ${origin} » invalide pour ${mount.prefix} — non relayé`, "WARNING");
+		mount.lastOrigin = origin;
+		mount.lastUrl = url;
+		return url;
+	}
+	/**
+	* Pool de connexions d'un montage, créé au premier relais et recréé si la
+	* cible change de scheme.
+	*
+	* Un `Agent` DÉDIÉ, jamais l'agent global : sous `NODE_USE_ENV_PROXY`, cas
+	* courant d'un poste d'entreprise, l'agent global envoie tout vers
+	* `HTTP_PROXY` — un amont sur la boucle locale serait demandé au proxy de
+	* l'entreprise. Un agent construit ici n'a pas de `proxyEnv` : il va droit
+	* à la cible. Keep-alive borné (`maxSockets`), `lifo` : le socket le plus
+	* récent, le moins susceptible d'avoir été fermé par l'amont.
+	*/
+	agentFor(mount, target) {
+		if (this.#closing) return false;
+		const wantsTls = target.protocol === "https:";
+		const agent = mount.agent;
+		if (agent !== null && agent instanceof https.Agent === wantsTls) return agent;
+		agent?.destroy();
+		const options = {
+			keepAlive: true,
+			maxSockets: this.maxSockets,
+			maxFreeSockets: Math.min(32, this.maxSockets),
+			scheduling: "lifo"
+		};
+		mount.agent = wantsTls ? new https.Agent(options) : new http.Agent(options);
+		return mount.agent;
+	}
+	/** Réglages de relais d'un montage. */
+	relayFor(mount, target) {
+		return {
+			pseudonym: this.pseudonym,
+			connectTimeoutMs: this.connectTimeoutMs,
+			agent: this.agentFor(mount, target)
+		};
+	}
+	/** Règles du noyau HTTP (résolues par nom), `undefined` hors serveur. */
+	rules() {
+		return this.container?.get("HttpKernel") ?? void 0;
+	}
+	/** Ce que le proxy annonce à l'amont sur le client. */
+	fromOf(req, scheme, host) {
+		const address = req.socket.remoteAddress;
+		return {
+			remoteAddress: address,
+			scheme,
+			host,
+			trustedPeer: this.rules()?.getTrustProxyChecker().isTrusted(address) === true,
+			httpVersion: req.httpVersion
+		};
+	}
+	/**
+	* Relaie une requête HTTP si un montage la couvre — méthode comprise. Cible
+	* pas encore connue → `503` + `Retry-After`, sans aller jusqu'au routage.
+	*
+	* L'appelant a déjà tranché la barrière d'hôte : c'est le pipeline HTTP, qui
+	* la calcule pour toute requête (`Context.validDomain`). Un chemin ambigu
+	* sous un préfixe monté rend 400, sans contacter l'amont.
+	*
+	* ⚠️ Un préfixe monté est servi AVANT le pare-feu, la CSRF et les en-têtes
+	* de sécurité applicatifs : c'est une surface publique pour qui atteint
+	* Nodefony. L'amont porte sa propre politique d'accès.
+	*
+	* @param req - requête du client
+	* @param res - réponse au client
+	* @param scheme - scheme par lequel le client est arrivé
+	* @returns la promesse de fin d'échange, ou `undefined` si la requête n'est
+	*   pas relayée (hors préfixe ou méthode non relayée : elle suit alors son
+	*   chemin normal)
+	*/
+	forward(req, res, scheme) {
+		const mount = this.match(req.url);
+		if (mount === void 0) return void 0;
+		const method = req.method ?? "GET";
+		if (mount.methods && !mount.methods.includes(method)) return void 0;
+		const target = this.targetOf(mount);
+		if (target === void 0) return answerPlain(res, 503, "Service Unavailable", "1");
+		if (isAmbiguousPath(req.url ?? "/")) return answerPlain(res, 400, "Bad Request");
+		const host = req.headers.host ?? req.headers[":authority"];
+		return forwardRequest(req, res, mount, target, this.fromOf(req, scheme, host), this.relayFor(mount, target));
+	}
+	/**
+	* Relaie un upgrade WebSocket si un montage `websocket` couvre son URL.
+	* Appelé par le répartiteur d'`upgrade` des serveurs WebSocket, AVANT le
+	* serveur WebSocket de Nodefony.
+	*
+	* Contrôles, dans l'ordre, chacun avec la réponse que rendrait le serveur
+	* WebSocket de Nodefony : cible pas encore connue → 503 ; `Host` hors `trustedHosts` (si `domainCheck`) →
+	* 421 ; chemin ambigu ou handshake non conforme (RFC 6455 §4.2.1 — seul
+	* `Upgrade: websocket` est relayé, jamais un tunnel `h2c`) → 400 ;
+	* `Origin` refusée par la MÊME règle que le serveur WebSocket (anti-CSWSH,
+	* RFC 6455 §10.2) → 403 ; `maxSockets` tunnels déjà ouverts vers l'amont →
+	* 503 ; quotas par IP du noyau (débit de handshakes, connexions
+	* simultanées) → 429. Le socket est alors consommé.
+	*
+	* @returns `true` si le proxy a pris le socket en charge
+	*/
+	handleUpgrade(req, socket, head) {
+		const mount = this.match(req.url);
+		if (mount?.websocket !== true) return false;
+		const target = this.targetOf(mount);
+		if (target === void 0) {
+			refuseUpgrade(socket, 503, "Service Unavailable");
+			return true;
+		}
+		const host = req.headers.host;
+		const hostname = hostnameOf(host);
+		const rules = this.rules();
+		if (this.kernel?.options.domainCheck && (hostname === null || rules?.isTrustedHostname(hostname) !== true)) {
+			refuseUpgrade(socket, 421, "Misdirected Request");
+			return true;
+		}
+		if (hostname === null || isAmbiguousPath(req.url ?? "/") || websocketHandshakeProblem(req.method, req.headers) !== null) {
+			refuseUpgrade(socket, 400, "Bad Request");
+			return true;
+		}
+		const secure = req.socket instanceof TLSSocket;
+		if (rules !== void 0 && !rules.isWebsocketOriginAllowed(req.headers.origin, hostname, secure)) {
+			refuseUpgrade(socket, 403, "Forbidden");
+			return true;
+		}
+		if (mount.tunnels >= this.maxSockets) {
+			refuseUpgrade(socket, 503, "Service Unavailable");
+			return true;
+		}
+		if (rules?.websocketQuotaRefusal(req, socket) != null) {
+			refuseUpgrade(socket, 429, "Too Many Requests");
+			return true;
+		}
+		mount.tunnels++;
+		socket.once("close", () => {
+			mount.tunnels--;
+		});
+		forwardUpgrade(req, socket, head, mount, target, this.fromOf(req, secure ? "https" : "http", host), this.relayFor(mount, target));
+		return true;
+	}
+};
+/**
+* Nom d'hôte d'une autorité `Host`, sans port (`[::1]` garde ses crochets,
+* comme `URL.hostname`).
+*
+* @returns le nom, ou `null` si l'autorité est absente ou invalide
+*/
+/**
+* Répond au client sans contacter l'amont : texte brut, jamais mis en cache.
+*
+* @param res - réponse au client (HTTP/1.1 ou HTTP/2, API de compatibilité)
+* @param status - statut rendu
+* @param body - corps texte
+* @param retryAfter - valeur de `Retry-After` (secondes), si le refus est passager
+* @returns une promesse déjà résolue — l'échange est terminé
+*/
+function answerPlain(res, status, body, retryAfter) {
+	const out = res;
+	out.writeHead(status, {
+		"content-type": "text/plain; charset=utf-8",
+		"cache-control": "no-store",
+		...retryAfter === void 0 ? {} : { "retry-after": retryAfter }
+	});
+	out.end(body);
+	return Promise.resolve();
+}
+function hostnameOf(host) {
+	if (!host) return null;
+	try {
+		return new URL(`http://${host}`).hostname;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { ReverseProxy as default };

package/dist/nodefony/service/servers/server-http.js

@@ -1,11 +1,11 @@
 import { asServersConfig, configuredServerPort } from "../../src/servers/kernelServers.js";
-import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorate.js";
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
 import http_kernel_default from "../http-kernel.js";
 import { handleClientError } from "./clientError.js";
 import { createDrainTerminator } from "./serverShutdown.js";
 import { bindWithFallback, buildBindPlan } from "../../src/servers/portBinder.js";
-import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateParam.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateParam.js";
 import { Module, Service, extend, inject, nodefonyError } from "nodefony";
 import http from "node:http";
 //#region nodefony/service/servers/server-http.ts

package/dist/nodefony/service/servers/server-https.js

@@ -1,11 +1,11 @@
 import { asServersConfig, configuredServerPort } from "../../src/servers/kernelServers.js";
-import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorate.js";
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
 import http_kernel_default from "../http-kernel.js";
 import { handleClientError } from "./clientError.js";
 import { createDrainTerminator } from "./serverShutdown.js";
 import { bindWithFallback, buildBindPlan } from "../../src/servers/portBinder.js";
-import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateParam.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateParam.js";
 import { Module, Service, extend, inject, nodefonyError } from "nodefony";
 import http2 from "node:http2";
 import https from "node:https";

package/dist/nodefony/service/servers/server-static.js

@@ -1,10 +1,11 @@
+import { normalizePrefix } from "../../src/proxy/rules.js";
 import { Service, extend } from "nodefony";
 import http from "node:http";
+import http2 from "node:http2";
 import { URL } from "node:url";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import mime from "mime-types";
-import http2 from "node:http2";
 import tls from "node:tls";
 import serveStatic from "serve-static";
 //#region nodefony/service/servers/server-static.ts
@@ -109,14 +110,10 @@ var Statics = class extends Service {
 	* @param dir dossier absolu à servir
 	*/
 	addMount(prefix, dir) {
-		let p = prefix.trim();
-		if (!p.startsWith("/")) p = `/${p}`;
-		if (!p.endsWith("/")) p = `${p}/`;
-		p = p.replace(/\/{2,}/g, "/");
-		const server = serveStatic(dir, extend({}, this.defaultOptions));
+		const p = normalizePrefix(prefix);
 		const entry = {
 			prefix: p,
-			server,
+			server: serveStatic(dir, extend({}, this.defaultOptions)),
 			dir
 		};
 		const i = this.mounts.findIndex((m) => m.prefix === p);

package/dist/nodefony/service/servers/server-websocket-secure.js

@@ -1,9 +1,10 @@
 import { asServersConfig, configuredServerPort } from "../../src/servers/kernelServers.js";
-import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorate.js";
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
 import http_kernel_default from "../http-kernel.js";
-import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateParam.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateParam.js";
 import { startHeartbeat, trackPong } from "./wsHeartbeat.js";
+import { attachUpgradeDispatch } from "../../src/servers/upgradeDispatch.js";
 import { Module, Service, inject } from "nodefony";
 import Ws, { WebSocketServer } from "ws";
 //#region nodefony/service/servers/server-websocket-secure.ts
@@ -12,6 +13,8 @@ let WebsocketSecure = class WebsocketSecure extends Service {
 	module;
 	ready = false;
 	server = null;
+	/** Retire l'écouteur `upgrade` posé par {@link attachUpgradeDispatch}. */
+	#detachUpgrade = null;
 	port;
 	domain;
 	protocol = "1.1";
@@ -46,9 +49,10 @@ let WebsocketSecure = class WebsocketSecure extends Service {
 				}
 				this.server = new WebSocketServer({
 					...this.options,
-					server: serverHttps.server,
+					noServer: true,
 					clientTracking: true
 				});
+				this.#detachUpgrade = attachUpgradeDispatch(serverHttps.server, this.server, () => this.httpKernel.reverseProxy, (req) => this.httpKernel.websocketUpgradeRefusal(req));
 				this.server.on("connection", this.onConnection.bind(this));
 				this.heartbeatTimer = startHeartbeat(this.server, this.options);
 				this.kernel?.prependOnceListener("onTerminate", this.terminate.bind(this));
@@ -83,6 +87,8 @@ let WebsocketSecure = class WebsocketSecure extends Service {
 				});
 				setTimeout(() => {
 					try {
+						this.#detachUpgrade?.();
+						this.#detachUpgrade = null;
 						this.server?.close();
 						this.log(` SHUTDOWN WEBSOCKET Server is listening on DOMAIN : ${this.domain}    PORT : ${this.port}`, "INFO");
 						return resolve(true);
@@ -92,6 +98,8 @@ let WebsocketSecure = class WebsocketSecure extends Service {
 				}, 300);
 				return;
 			}
+			this.#detachUpgrade?.();
+			this.#detachUpgrade = null;
 			return resolve(true);
 		});
 	}

package/dist/nodefony/service/servers/server-websocket.js

@@ -1,9 +1,10 @@
 import { asServersConfig, configuredServerPort } from "../../src/servers/kernelServers.js";
-import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorate.js";
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
 import http_kernel_default from "../http-kernel.js";
-import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateParam.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateParam.js";
 import { startHeartbeat, trackPong } from "./wsHeartbeat.js";
+import { attachUpgradeDispatch } from "../../src/servers/upgradeDispatch.js";
 import { Module, Service, inject } from "nodefony";
 import Ws, { WebSocketServer } from "ws";
 //#region nodefony/service/servers/server-websocket.ts
@@ -12,6 +13,8 @@ let Websocket = class Websocket extends Service {
 	module;
 	ready = false;
 	server = null;
+	/** Retire l'écouteur `upgrade` posé par {@link attachUpgradeDispatch}. */
+	#detachUpgrade = null;
 	port;
 	domain;
 	protocol = "1.1";
@@ -46,9 +49,10 @@ let Websocket = class Websocket extends Service {
 				}
 				this.server = new WebSocketServer({
 					...this.options,
-					server: serverHttp.server,
+					noServer: true,
 					clientTracking: true
 				});
+				this.#detachUpgrade = attachUpgradeDispatch(serverHttp.server, this.server, () => this.httpKernel.reverseProxy, (req) => this.httpKernel.websocketUpgradeRefusal(req));
 				this.server.on("connection", this.onConnection.bind(this));
 				this.heartbeatTimer = startHeartbeat(this.server, this.options);
 				this.kernel?.prependOnceListener("onTerminate", this.terminate.bind(this));
@@ -83,6 +87,8 @@ let Websocket = class Websocket extends Service {
 				});
 				setTimeout(() => {
 					try {
+						this.#detachUpgrade?.();
+						this.#detachUpgrade = null;
 						this.server?.close();
 						this.log(` SHUTDOWN WEBSOCKET Server is listening on DOMAIN : ${this.domain}    PORT : ${this.port}`, "INFO");
 						return resolve(true);
@@ -92,6 +98,8 @@ let Websocket = class Websocket extends Service {
 				}, 300);
 				return;
 			}
+			this.#detachUpgrade?.();
+			this.#detachUpgrade = null;
 			return resolve(true);
 		});
 	}

package/dist/nodefony/service/servers/wsHeartbeat.js

@@ -19,6 +19,35 @@ const trackPong = (ws) => {
 	});
 };
 /**
+* Un tick du keep-alive : pingue les connexions muettes depuis `interval`, et
+* coupe celles dont le ping attend sa réponse depuis plus de `grace`.
+*
+* Fonction PURE du temps : l'horloge est passée en argument, si bien que la
+* règle se prouve pas à pas, sans minuteur réel — un banc qui la prouverait à
+* l'horloge murale confondrait une boucle d'événements chargée avec un zombie.
+*
+* @param clients - les connexions du serveur
+* @param now - l'instant du tick (`performance.now()` en production)
+* @param interval - délai sans signe de vie avant un ping, ms
+* @param grace - délai accordé au pong avant de couper, ms
+*/
+const heartbeatTick = (clients, now, interval, grace) => {
+	for (const client of clients) {
+		if (client.readyState !== Ws.OPEN) continue;
+		const sock = client;
+		sock._nfLastPong ??= now;
+		const pingedAt = sock._nfPingedAt ?? 0;
+		if (pingedAt > sock._nfLastPong) {
+			if (now - pingedAt > grace) client.terminate();
+			continue;
+		}
+		if (now - sock._nfLastPong >= interval) {
+			sock._nfPingedAt = now;
+			client.ping();
+		}
+	}
+};
+/**
 * Démarre le heartbeat keep-alive du serveur : détecte les connexions zombies
 * (half-open — TCP encore ouvert mais le pair a disparu sans frame Close) et les
 * `terminate()` pour libérer slot mémoire + descripteur de fichier.
@@ -42,23 +71,10 @@ const startHeartbeat = (server, options) => {
 	if (interval <= 0) return null;
 	const grace = options.keepaliveGracePeriod ?? 0;
 	const timer = setInterval(() => {
-		const now = performance.now();
-		for (const client of server.clients) {
-			if (client.readyState !== Ws.OPEN) continue;
-			const sock = client;
-			sock._nfLastPong ??= now;
-			if ((sock._nfPingedAt ?? 0) > sock._nfLastPong) {
-				if (now - sock._nfPingedAt > grace) client.terminate();
-				continue;
-			}
-			if (now - sock._nfLastPong >= interval) {
-				sock._nfPingedAt = now;
-				client.ping();
-			}
-		}
+		heartbeatTick(server.clients, performance.now(), interval, grace);
 	}, Math.max(250, grace > 0 ? Math.min(interval, grace) : interval));
 	timer.unref();
 	return timer;
 };
 //#endregion
-export { startHeartbeat, trackPong };
+export { heartbeatTick, startHeartbeat, trackPong };

package/dist/nodefony/service/sessions/sessions-service.js

@@ -1,8 +1,8 @@
 import { SESSION_FACETS } from "../../src/session/storage/sessionFilters.js";
-import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorate.js";
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
 import http_kernel_default from "../http-kernel.js";
-import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateParam.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateParam.js";
 import Session from "../../src/session/session.js";
 import MemorySessionStorage from "../../src/session/storage/MemorySessionStorage.js";
 import RevocationGuardStorage from "../../src/session/storage/RevocationGuardStorage.js";
@@ -481,23 +481,44 @@ let SessionsService = class SessionsService extends Service {
 		return destroyed;
 	}
 	/**
-	* « Déconnexion partout » : détruit TOUTES les sessions d'un utilisateur (scan
-	* O(N) — pas d'index inverse, acceptable en admin). Renvoie le nombre détruit.
+	* Détruit TOUTES les sessions dont le contenu satisfait `match` — la primitive
+	* des révocations groupées (« déconnecter partout », déconnexion demandée par
+	* un fournisseur d'identité). Ni journal ni audit : l'appelant, qui connaît le
+	* motif, les émet.
+	*
+	* @remarks Quand la méthode rend la main, il ne reste AUCUNE session qui
+	* satisfait `match` (au plus `MAX_LOGOUT_PASSES` passages). Une révocation qui
+	* en laisse une seule n'est pas une imprécision, c'est une faille.
+	*
+	* @param filter - restriction poussée au store (`user` : WHERE indexable) ;
+	*   `undefined` parcourt tout le parc.
+	* @param match - prédicat sur la session sérialisée — il doit RE-VÉRIFIER ce
+	*   que `filter` exprime, un store pouvant l'ignorer.
+	* @returns le nombre de sessions détruites.
+	* @throws Error si le store actif ne sait pas énumérer ses sessions.
 	*/
-	async destroyByUser(identifier, actor) {
+	async destroyWhere(filter, match) {
 		const storage = this.enumerable();
 		let destroyed = 0;
 		for (let pass = 0; pass < MAX_LOGOUT_PASSES; pass += 1) {
 			let destroyedThisPass = 0;
-			await this.eachSessionRecord({ user: identifier }, async (rec) => {
-				if (rec.data.user !== identifier) return false;
+			await this.eachSessionRecord(filter, async (rec) => {
+				if (!match(rec.data)) return false;
 				if (await storage.destroy(rec.id)) destroyedThisPass += 1;
 				return false;
 			});
 			destroyed += destroyedThisPass;
 			if (destroyedThisPass === 0) break;
-			if (pass === 9) this.log(`sessions: logout-all interrompu après ${MAX_LOGOUT_PASSES} passages — user=${identifier} (révocation potentiellement incomplète)`, "WARNING");
+			if (pass === 9) this.log(`sessions: révocation groupée interrompue après ${MAX_LOGOUT_PASSES} passages — filtre=${JSON.stringify(filter ?? {})} (révocation potentiellement incomplète)`, "WARNING");
 		}
+		return destroyed;
+	}
+	/**
+	* « Déconnexion partout » : détruit TOUTES les sessions d'un utilisateur (scan
+	* O(N) — pas d'index inverse, acceptable en admin). Renvoie le nombre détruit.
+	*/
+	async destroyByUser(identifier, actor) {
+		const destroyed = await this.destroyWhere({ user: identifier }, (data) => data.user === identifier);
 		if (destroyed > 0) {
 			this.log(`sessions revoked by admin (logout-all) — user=${identifier} count=${destroyed} actor=${actor ?? "admin"}`, "INFO");
 			this.emitAudit({

package/dist/nodefony/service/upload/upload-service.js

@@ -1,7 +1,7 @@
-import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorate.js";
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
 import http_kernel_default from "../http-kernel.js";
-import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.152.0/helpers/esm/decorateParam.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorateParam.js";
 import { Cli, FileClass, Module, Service, inject } from "nodefony";
 import fs from "node:fs";
 import fsp from "node:fs/promises";