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

package/dist/nodefony/service/http-kernel.js

@@ -4,21 +4,22 @@ import { resolveForwarded } from "../src/context/forwarded.js";
 import { MemoryRateLimitStore } from "../src/rateLimit/MemoryRateLimitStore.js";
 import { WsConnectionCounter } from "../src/rateLimit/WsConnectionCounter.js";
 import { compileDomainPatterns, compileTrustedHosts, isDomainAllowed } from "../src/context/domainMatcher.js";
-import WebsocketContext from "../src/context/websocket/WebsocketContext.js";
+import { responseEnded } from "../src/context/responseEnded.js";
+import { parseWebsocketUrl } from "../src/context/websocket/websocketUrl.js";
+import WebsocketContext, { toHandshakeStatus } from "../src/context/websocket/WebsocketContext.js";
+import { trackPong } from "./servers/wsHeartbeat.js";
 import HttpContext from "../src/context/http/HttpContext.js";
 import DefaultErrorRenderer from "./error-renderer.js";
-import DefaultRequestLogger from "./request-logger.js";
 import JsonAuditLogger from "./audit-logger.js";
+import DefaultRequestLogger from "./request-logger.js";
 import PrettyRequestLogger from "./pretty-request-logger.js";
 import { resolveTraceparent } from "./trace.js";
 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 { GcScheduler, Module, RequestContext, Service, finallyMaybe, injectable, isPromise, logColor, nodefonyError, servedUrl, thenMaybe, writeRuntimeState } from "nodefony";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
+import { GcScheduler, IDENTITY_CHANGED_EVENT, RequestContext, RevocationWatch, Service, finallyMaybe, injectable, isPromise, logColor, nodefonyError, servedUrl, thenMaybe, writeRuntimeState } from "nodefony";
 import cluster from "node:cluster";
 import http from "node:http";
-import Ws from "ws";
-//#region nodefony/service/http-kernel.ts
+// nodefony/service/http-kernel.ts
 const HEALTH_HEADERS = {
 	"content-type": "application/json",
 	"cache-control": "no-store"
@@ -67,13 +68,37 @@ let HttpKernel = class HttpKernel extends Service {
 	cert = "";
 	ca = "";
 	serverStatic = null;
+	/**
+	* Proxy inverse (`reverse-proxy`) — lu à chaque requête avant le routage ;
+	* `mounts === null` tant que personne n'a monté de préfixe.
+	*/
+	reverseProxy = null;
 	domain = "";
 	trustedHosts;
-	domainCheck = false;
+	/**
+	* Contrôle de domaine actif (`domainCheck` de la config d'application) —
+	* lu à la source, pour le HTTP comme pour le handshake WebSocket.
+	*/
+	get domainCheck() {
+		return this.kernel?.options.domainCheck === true;
+	}
 	regAlias = [];
 	module;
-	httpsPort;
-	httpPort;
+	/**
+	* Port du serveur HTTPS effectivement lié, `undefined` s'il est inactif —
+	* lu sur le serveur, jamais recopié (lu par `HttpContext.redirectHttps`).
+	*/
+	get httpsPort() {
+		return this.boundPort("server-https");
+	}
+	/** Port du serveur HTTP effectivement lié, `undefined` s'il est inactif. */
+	get httpPort() {
+		return this.boundPort("server-http");
+	}
+	boundPort(name) {
+		const server = this.get(name);
+		return server?.active === true && server.port > 0 ? server.port : void 0;
+	}
 	responseTimeout;
 	closeTimeOutWs;
 	secContentTypeOptions = null;
@@ -90,6 +115,7 @@ let HttpKernel = class HttpKernel extends Service {
 	rateLimiter = null;
 	rateLimitGc = null;
 	#wsConnCounter = null;
+	#streams = null;
 	#healthPaths = null;
 	#healthShutdownDelay = 0;
 	#terminating = false;
@@ -99,15 +125,16 @@ let HttpKernel = class HttpKernel extends Service {
 		this.container?.addScope("request");
 		this.responseTimeout = {
 			http: this.options.http.responseTimeout,
-			https: this.options.https.responseTimeout,
-			http2: this.options.https.responseTimeout,
-			http3: this.options.https.responseTimeout
+			https: this.options.https.responseTimeout
 		};
 		this.closeTimeOutWs = {
 			ws: this.options.websocket.closeTimeout,
 			wss: this.options.websocketSecure.closeTimeout
 		};
 		this.computeSecurityHeaderCaches();
+		this.kernel?.on(IDENTITY_CHANGED_EVENT, (event) => {
+			this.#streams?.refreshIdentity(event.identifier);
+		});
 	}
 	/**
 	* (Re)calcule les caches dérivés des en-têtes de sécurité depuis `this.options`
@@ -244,6 +271,7 @@ let HttpKernel = class HttpKernel extends Service {
 		this.kernel?.prependOnceListener("onReady", () => {
 			this.serviceCerticats = this.get("certificates");
 			this.serverStatic = this.get("server-static");
+			this.reverseProxy = this.get("reverse-proxy");
 			this.domain = this.kernel?.domain;
 			this.trustedHosts = this.options.trustedHosts;
 			this.regAlias = this.compileAlias();
@@ -307,6 +335,35 @@ let HttpKernel = class HttpKernel extends Service {
 		return policy;
 	}
 	/**
+	* L'`Origin` d'un handshake WebSocket est-elle acceptée ? Règle UNIQUE,
+	* interrogeable SANS contexte : le serveur WebSocket de Nodefony
+	* ({@link checkWebsocketOrigin}) et le proxy inverse, qui relaie un upgrade
+	* avant qu'aucun contexte n'existe, décident par elle.
+	*
+	* Same-origin (nom de l'`Origin` = nom servi, port ignoré), loopback toléré
+	* en development, allowlist `allowedOrigins` ; sans `Origin` (client
+	* non-navigateur) → acceptée. Doctrine complète : {@link checkWebsocketOrigin}.
+	*
+	* @param origin - valeur brute de l'en-tête `Origin`
+	* @param hostname - nom d'hôte servi, sans port (`Context.domain`)
+	* @param secure - handshake reçu en TLS (politique `websocketSecure`)
+	* @returns `true` si le handshake peut se poursuivre
+	*/
+	isWebsocketOriginAllowed(origin, hostname, secure) {
+		const policy = this.getWsOriginPolicy(secure ? "websocketSecure" : "websocket");
+		if (policy.disabled) return true;
+		if (!origin) return true;
+		let originHost;
+		try {
+			originHost = new URL(origin).hostname;
+		} catch {
+			return false;
+		}
+		if (originHost === hostname) return true;
+		if (this.kernel?.environment === "development" && WS_DEV_LOOPBACK.has(originHost)) return true;
+		return policy.extra.length > 0 && isDomainAllowed(policy.extra, originHost);
+	}
+	/**
 	* B4 — Validation d'`Origin` au handshake WebSocket (anti-CSWSH, OWASP
 	* WSTG-CLNT-10). Les navigateurs n'appliquent PAS CORS aux WebSockets : sans
 	* ce contrôle, une page tierce peut ouvrir un WS **authentifié par le cookie de
@@ -322,22 +379,9 @@ let HttpKernel = class HttpKernel extends Service {
 	* @throws {HttpError} code WS 1008 (Policy Violation) si l'Origin est refusée.
 	*/
 	checkWebsocketOrigin(context) {
-		const cfgKey = context.type === "websocket-secure" ? "websocketSecure" : "websocket";
-		const policy = this.getWsOriginPolicy(cfgKey);
-		if (policy.disabled) return;
+		const secure = context.serverType === "wss";
 		const raw = context.origin;
-		if (!raw) return;
-		let originHost = null;
-		try {
-			originHost = new URL(raw).hostname;
-		} catch {
-			originHost = null;
-		}
-		if (originHost) {
-			if (originHost === context.domain) return;
-			if (this.kernel?.environment === "development" && WS_DEV_LOOPBACK.has(originHost)) return;
-			if (policy.extra.length && isDomainAllowed(policy.extra, originHost)) return;
-		}
+		if (this.isWebsocketOriginAllowed(raw, context.domain, secure)) return;
 		const error = new HttpError(`WebSocket Origin "${raw}" not allowed (CSWSH protection)`, 1008, context);
 		error.type = "origin";
 		throw error;
@@ -434,7 +478,14 @@ let HttpKernel = class HttpKernel extends Service {
 			context.resolver = resolver;
 			return resolver;
 		}
-		if (resolver.exception) throw resolver.exception;
+		if (resolver.exception) {
+			const exception = resolver.exception;
+			if (context.secure && "code" in exception && exception.code === 426) {
+				context.resolver = resolver;
+				return resolver;
+			}
+			throw resolver.exception;
+		}
 		throw new HttpError("Not Found", 404, context);
 	}
 	/**
@@ -483,7 +534,7 @@ let HttpKernel = class HttpKernel extends Service {
 	*/
 	/**
 	* Override the default error renderer — e.g. to hide stack traces in prod
-	* or emit RFC 7807 problem+json. Stateless singleton expected.
+	* or emit RFC 9457 problem+json. Stateless singleton expected.
 	*/
 	setErrorRenderer(renderer) {
 		this.errorRenderer = renderer;
@@ -504,6 +555,10 @@ let HttpKernel = class HttpKernel extends Service {
 	async onError(error, context, _extraHeaders) {
 		if (context) context.error = error;
 		if (context instanceof HttpContext) {
+			if (context.isRedirect && error.code === 401) {
+				if (!(context.finished || context.sended)) await context.send();
+				return context;
+			}
 			const result = this.errorRenderer.renderHttp(error, context);
 			if (error instanceof HttpError || error instanceof nodefonyError) error.code = result.status;
 			context.response.setStatusCode(result.status, http.STATUS_CODES[result.status] ?? "Unknown Error");
@@ -514,6 +569,10 @@ let HttpKernel = class HttpKernel extends Service {
 				return context;
 			}
 			if (!context.response.isHeaderSent()) {
+				if (context.isRedirect) {
+					context.isRedirect = false;
+					context.response.response?.removeHeader("Location");
+				}
 				try {
 					await context.render(result.body);
 				} catch (e) {
@@ -525,18 +584,26 @@ let HttpKernel = class HttpKernel extends Service {
 			await context.close();
 			return context;
 		}
-		if (context instanceof WebsocketContext) try {
-			const wsResult = this.errorRenderer.renderWebsocket(error, context);
-			if (context.response?.connection) {
-				context.close(wsResult.code, wsResult.reason);
+		if (context instanceof WebsocketContext) {
+			if (context.admission !== null) {
+				const status = toHandshakeStatus("code" in error && typeof error.code === "number" ? error.code : void 0);
+				context.refuseHandshake(status);
+				if (this.kernel?.debug) this.log(`${status} ${error.message}`, "DEBUG", "WEBSOCKET REFUSED");
 				return context;
 			}
-			if (context.request && !context.rejected) {
-				context.reject(wsResult.code, wsResult.reason);
-				return context;
+			try {
+				const wsResult = this.errorRenderer.renderWebsocket(error, context);
+				if (context.response?.connection) {
+					context.close(wsResult.code, wsResult.reason);
+					return context;
+				}
+				if (context.request && !context.rejected) {
+					context.reject(wsResult.code, wsResult.reason);
+					return context;
+				}
+			} catch {
+				throw error;
 			}
-		} catch {
-			throw error;
 		}
 		throw error;
 	}
@@ -578,7 +645,7 @@ let HttpKernel = class HttpKernel extends Service {
 		if (headerServer != null && headerServer !== "") response.setHeader("Server", headerServer);
 		if (this.secContentTypeOptions !== null) response.setHeader("X-Content-Type-Options", this.secContentTypeOptions);
 		if (this.secFrameOptions !== null) response.setHeader("X-Frame-Options", this.secFrameOptions);
-		if (this.secHsts !== null && (type === "https" || type === "http2")) response.setHeader("Strict-Transport-Security", this.secHsts);
+		if (this.secHsts !== null && type === "https") response.setHeader("Strict-Transport-Security", this.secHsts);
 		if (this.#healthPaths !== null) {
 			const url = request.url;
 			if (url === this.#healthPaths.liveness) {
@@ -621,6 +688,11 @@ let HttpKernel = class HttpKernel extends Service {
 			await serverHttps.createServer();
 			servers.push(serverHttps);
 		}
+		const serverH2c = this.get("server-h2c");
+		if (serverH2c?.active) {
+			await serverH2c.createServer();
+			servers.push(serverH2c);
+		}
 		const serverWebsocket = this.get("server-websocket");
 		if (serverWebsocket && serverHttp?.active) {
 			await serverWebsocket.createServer(serverHttp);
@@ -631,7 +703,7 @@ let HttpKernel = class HttpKernel extends Service {
 			await serverWebsocketSecure.createServer(serverHttps);
 			servers.push(serverWebsocketSecure);
 		}
-		this.publishRuntimePorts(serverHttp, serverHttps);
+		this.publishRuntimePorts(serverHttp, serverHttps, serverH2c);
 		return servers;
 	}
 	/**
@@ -665,7 +737,7 @@ let HttpKernel = class HttpKernel extends Service {
 	* {@link readRuntimeState} — `status`/`stop` redeviendraient aveugles alors que
 	* l'app écoute toujours. Le master, lui, est le propriétaire du runtime.
 	*/
-	publishRuntimePorts(serverHttp, serverHttps) {
+	publishRuntimePorts(serverHttp, serverHttps, serverH2c) {
 		const ports = [];
 		const desired = [];
 		const urls = [];
@@ -681,6 +753,11 @@ let HttpKernel = class HttpKernel extends Service {
 			const port = configuredServerPort(asServersConfig(this.kernel?.options.servers), "https");
 			if (port) desired.push(port);
 		}
+		if (serverH2c?.active && serverH2c.port > 0) {
+			ports.push(serverH2c.port);
+			const port = configuredServerPort(asServersConfig(this.kernel?.options.servers), "h2c");
+			if (port) desired.push(port);
+		}
 		if (ports.length === 0) return;
 		writeRuntimeState(process.cwd(), {
 			pid: cluster.isWorker ? process.ppid : process.pid,
@@ -799,9 +876,9 @@ let HttpKernel = class HttpKernel extends Service {
 				perfProbe.t0 = 0n;
 			} else context = new HttpContext(scope, request, response, type);
 			response.on("close", () => {
-				if (!response.writableEnded) {
+				if (!responseEnded(response)) {
 					context._abortIfPending("Connection closed before response finished");
-					if (!context.sended) context.response.statusCode = 499;
+					if (context.response.statusCode < 400) context.response.statusCode = 499;
 				}
 				this.teardownHttp(context, scope);
 			});
@@ -842,14 +919,16 @@ let HttpKernel = class HttpKernel extends Service {
 		const profilerQueries = this.profiler ? [] : null;
 		context.profilerQueries = profilerQueries;
 		context.profiling = profilerQueries !== null;
-		return RequestContext.run({
+		const store = {
 			requestId: context.requestId,
 			scheme: context.scheme,
 			traceparent: context.traceparent,
 			queries: profilerQueries ?? void 0,
 			context,
 			scope
-		}, () => this.runHttpPipeline(context, request, response));
+		};
+		context.holdRequestStore(store);
+		return RequestContext.run(store, () => this.runHttpPipeline(context, request, response));
 	}
 	/**
 	* Chemin d'erreur de {@link handleHttp} : libère le scope d'un contexte qui
@@ -887,6 +966,10 @@ let HttpKernel = class HttpKernel extends Service {
 	* N'attend que le repli statique, et seulement quand aucune route ne matche.
 	*/
 	routeHttpRequest(httpContext, request, response) {
+		if (this.reverseProxy !== null && this.reverseProxy.mounts !== null && (httpContext.validDomain || !this.domainCheck)) {
+			const relayed = this.reverseProxy.forward(request, response, httpContext.scheme);
+			if (relayed !== void 0) return relayed.then(() => httpContext);
+		}
 		httpContext.phaseStart("resolve");
 		httpContext.resolver = this.router ? this.router.resolve(httpContext) : null;
 		httpContext.phaseEnd("resolve");
@@ -931,7 +1014,7 @@ let HttpKernel = class HttpKernel extends Service {
 		if (error) throw error;
 		const schemeHeaders = context.scheme === "https" ? this.options.https.headers : context.scheme === "http" ? this.options.http.headers : null;
 		if (schemeHeaders) context.response.setHeaders(schemeHeaders);
-		if (this.kernel?.options.domainCheck) this.checkValidDomain(context);
+		if (this.domainCheck) this.checkValidDomain(context);
 		if (this.listenerCount("beforeResolve")) return this.fireAsync("beforeResolve", context).then(() => this.armAndGuard(context));
 		return this.armAndGuard(context);
 	}
@@ -942,7 +1025,7 @@ let HttpKernel = class HttpKernel extends Service {
 	armAndGuard(context) {
 		this.prepareFrontController(context);
 		this.firewall?.enforceCsrf(context);
-		return thenMaybe(this.startSession(context), () => context.secure || context.isControlledAccess ? this.runFirewall(context) : context);
+		return thenMaybe(this.startSession(context), () => context.secure ? this.runFirewall(context) : context);
 	}
 	/**
 	* Le pare-feu d'une requête en zone protégée : `handleSecurity`, puis les
@@ -958,9 +1041,15 @@ let HttpKernel = class HttpKernel extends Service {
 				await this.firewall?.handleSecurity(context);
 				if (this.listenerCount("afterAuth")) await this.fireAsync("afterAuth", context);
 			} catch (authError) {
+				if (context.resolver?.exception) {
+					context.response.response?.removeHeader("Upgrade");
+					context.response.response?.removeHeader("Connection");
+				}
 				await this.fireAsync("onAuthFailure", context, authError).catch((e) => this.log(e, "ERROR", "onAuthFailure"));
 				throw authError;
 			}
+			const pending = context.resolver?.exception;
+			if (pending) throw pending;
 		} finally {
 			context.phaseEnd("firewall");
 		}
@@ -996,33 +1085,48 @@ let HttpKernel = class HttpKernel extends Service {
 			this.log(e, "ERROR", "WS onFinish");
 		}
 	}
-	async onWebsocketRequest(ws, req, type) {
-		const wsConnCounter = this.#wsConnCounter;
-		if (this.rateLimiter !== null || wsConnCounter !== null) {
-			const ip = resolveForwarded(req.headers, req.socket.remoteAddress, this.getTrustProxyChecker()).clientIp;
-			if (ip !== null) {
-				if (this.rateLimiter?.hit(ip).limited) {
-					if (ws.readyState === Ws.OPEN) ws.close(1013, "rate limit");
-					return;
-				}
-				if (wsConnCounter !== null) {
-					if (!wsConnCounter.tryAcquire(ip)) {
-						if (ws.readyState === Ws.OPEN) ws.close(1013, "too many connections");
-						return;
-					}
-					ws.once("close", () => wsConnCounter.release(ip));
-				}
-			}
+	/**
+	* Point d'entrée d'un upgrade vers une route WebSocket de Nodefony, appelé
+	* par le répartiteur d'upgrade AVANT le `101` (#596) : rien ne s'ouvre tant
+	* que le pipeline n'a pas dit oui.
+	*
+	* Les bornes par IP passent en premier, avant tout scope, ALS ou pipeline
+	* (symétrie avec le 429 HTTP et avec le proxy inverse) : le vrai vecteur DoS
+	* est d'accumuler des sockets ouvertes. La place est rendue à la fermeture du
+	* socket du client — même règle que pour un tunnel relayé.
+	*
+	* @param req - requête d'upgrade
+	* @param admission - le verdict à rendre : accepter (`101`) ou refuser (HTTP)
+	* @param type - serveur qui a reçu l'upgrade
+	* @returns la promesse du traitement de la connexion
+	*/
+	async onWebsocketUpgrade(req, admission, type) {
+		if (this.websocketQuotaRefusal(req, req.socket) !== null) {
+			admission.refuse(429);
+			return;
 		}
 		await this.fireAsync("onServerRequest", req, null, type);
 		const scope = this.container?.enterScope("request");
-		return this.handleWebsocket(scope, ws, req, type);
+		return this.handleWebsocket(scope, req, admission, type);
 	}
-	async handleWebsocket(scope, ws, req, type) {
+	/**
+	* Pipeline d'un handshake WebSocket, dans la bulle ALS de la connexion :
+	* jugement (`onConnect`), pare-feu, gardes de l'action — PUIS seulement
+	* l'acceptation, la socket et l'action de handshake. Tout refus antérieur à
+	* l'acceptation part en statut HTTP (`onError` → `refuseHandshake`).
+	*
+	* @param scope - scope DI de la connexion
+	* @param req - requête d'upgrade
+	* @param admission - le verdict à rendre
+	* @param type - serveur qui a reçu l'upgrade
+	* @returns ce que rend l'action de handshake
+	*/
+	async handleWebsocket(scope, req, admission, type) {
 		let context = null;
 		let error = null;
 		try {
-			context = this.createWebsocketContext(scope, req, ws, type);
+			context = this.createWebsocketContext(scope, req, null, type);
+			context.admission = admission;
 		} catch (e) {
 			error = e;
 		}
@@ -1034,15 +1138,17 @@ let HttpKernel = class HttpKernel extends Service {
 			const wsRunId = context?.requestId ?? "ws-no-ctx";
 			const wsScheme = context?.scheme ?? "ws";
 			const wsTrace = context?.traceparent ?? null;
-			return await RequestContext.run({
+			const store = {
 				requestId: wsRunId,
 				scheme: wsScheme,
 				...wsTrace ? { traceparent: wsTrace } : {},
 				context,
 				scope
-			}, async () => {
+			};
+			context?.holdRequestStore(store);
+			return await RequestContext.run(store, async () => {
 				await this.onConnect(context, error);
-				if (this.firewall && (context?.secure || context?.isControlledAccess)) {
+				if (this.firewall && context?.secure) {
 					context.phaseStart("firewall");
 					try {
 						try {
@@ -1056,22 +1162,34 @@ let HttpKernel = class HttpKernel extends Service {
 						context.phaseEnd("firewall");
 					}
 				}
-				if (context) {
-					context.phaseStart("action");
-					try {
-						return await context.handle();
-					} finally {
-						context.phaseEnd("action");
-					}
+				if (!context) return;
+				const guarded = context.resolver?.authorizeAction();
+				if (guarded !== void 0) await guarded;
+				const accepted = admission.accept();
+				const ws = accepted instanceof Promise ? await accepted : accepted;
+				if (ws === null) {
+					this.releaseOrphanWsScope(scope, context);
+					return;
+				}
+				trackPong(ws);
+				context.acceptConnection(ws);
+				await context.connect();
+				context.phaseStart("action");
+				try {
+					return await context.handle();
+				} finally {
+					context.phaseEnd("action");
 				}
 			});
 		} catch (e) {
 			try {
 				await this.onError(e, context);
 			} catch (errorHandlingError) {
+				admission.refuse(500);
 				this.releaseOrphanWsScope(scope, context);
 				throw errorHandlingError;
 			}
+			admission.refuse(500);
 			this.releaseOrphanWsScope(scope, context);
 			throw e;
 		}
@@ -1086,6 +1204,16 @@ let HttpKernel = class HttpKernel extends Service {
 		this.container?.leaveScope(scope);
 		context.clean();
 	}
+	/**
+	* Juge un handshake WebSocket AVANT son acceptation : hôte, origine,
+	* `beforeResolve`, contrôleur (protocole négocié), session. N'ouvre rien —
+	* l'acceptation n'a lieu qu'après le pare-feu et les gardes de l'action
+	* (cf {@link handleWebsocket}).
+	*
+	* @param context - contexte du handshake, encore sans socket
+	* @param error - erreur levée à la construction du contexte, relancée telle quelle
+	* @throws la première erreur du jugement — rendue en statut HTTP par `onError`
+	*/
 	async onConnect(context, error = null) {
 		if (error) throw error;
 		if (!context) throw new nodefonyError("Bad context", 500);
@@ -1099,7 +1227,6 @@ let HttpKernel = class HttpKernel extends Service {
 			throw e;
 		}
 		if (!context.sessionStarting) await this.startSession(context);
-		return context.connect();
 	}
 	checkValidDomain(context) {
 		if (context.validDomain) return 200;
@@ -1126,8 +1253,130 @@ let HttpKernel = class HttpKernel extends Service {
 	isTrustedHostname(hostname) {
 		return isDomainAllowed(this.regAlias, hostname);
 	}
+	/**
+	* Refus d'un upgrade WebSocket AVANT le `101`, par un statut HTTP
+	* (RFC 6455 §4.2.2) — appelé par le répartiteur d'upgrade, après le proxy
+	* inverse et avant le serveur `ws`.
+	*
+	* Pourquoi avant : accepter puis fermer fait croire au client que le serveur
+	* a répondu. Le client Vite sonde « le serveur est-il revenu ? » en ouvrant
+	* une socket ; une ouverture suivie d'une fermeture `4004` lui faisait
+	* recharger la page avant que Vite soit prêt — page blanche.
+	*
+	* Ne juge que l'existence d'une route WebSocket pour le chemin
+	* ({@link IRequestRouter.servesWebsocket}) : hôte, origine, sous-protocole,
+	* quotas et pare-feu restent jugés après l'ouverture, comme avant. Un refus
+	* compte au limiteur de débit comme une requête HTTP refusée — sans quoi un
+	* flot d'upgrades vers des chemins inexistants y échapperait.
+	*
+	* @param req - requête d'upgrade
+	* @returns le statut du refus — `404` chemin sans route WebSocket, `400` URL
+	*   inanalysable, `429` débit dépassé, `503` routeur pas encore posé (boot) —
+	*   ou `null` si l'upgrade est admis
+	*/
+	websocketUpgradeRefusal(req) {
+		const router = this.router;
+		if (router === null || router === void 0) return 503;
+		let pathname;
+		try {
+			pathname = parseWebsocketUrl("ws", req.headers.host, req.url).pathname;
+		} catch {
+			return this.#rateLimitedRefusal(req) ?? 400;
+		}
+		if (router.servesWebsocket(pathname)) return null;
+		return this.#rateLimitedRefusal(req) ?? 404;
+	}
+	/** Compte un upgrade refusé au limiteur de débit : `429` s'il le dépasse. */
+	#rateLimitedRefusal(req) {
+		if (this.rateLimiter === null) return null;
+		const ip = this.#clientIp(req);
+		return ip !== null && this.rateLimiter.hit(ip).limited ? 429 : null;
+	}
+	/**
+	* Bornes par IP d'un upgrade WebSocket : débit de handshakes (le MÊME
+	* compteur que les requêtes HTTP — un upgrade EST un GET) puis connexions
+	* simultanées (`wsMaxConnectionsPerIp`). Seule implémentation, appelée par
+	* le serveur WebSocket de Nodefony ET par le proxy inverse pour un upgrade
+	* qu'il relaie : un tunnel relayé n'échappe pas aux quotas d'une connexion
+	* servie.
+	*
+	* L'IP est résolue comme en HTTP (RFC 7239 + `trustProxy`), et seulement si
+	* un limiteur est armé — 0 coût quand tout est désactivé (défaut). Aucun log
+	* par refus : sous un flood, il serait lui-même un amplificateur.
+	*
+	* @param req - requête d'upgrade
+	* @param connection - ce dont la fermeture libère la place comptée (le `ws`
+	*   accepté, ou le socket du client pour un tunnel relayé)
+	* @returns `null` si l'upgrade est admis — sa place est alors rendue à la
+	*   fermeture de `connection` —, sinon la raison du refus
+	*/
+	websocketQuotaRefusal(req, connection) {
+		if (this.rateLimiter === null && this.#wsConnCounter === null) return null;
+		const ip = this.#clientIp(req);
+		if (ip === null) return null;
+		if (this.rateLimiter?.hit(ip).limited) return "rate limit";
+		return this.#acquireSlot(ip, connection) ? null : "too many connections";
+	}
+	/**
+	* Prend une place de connexion LONGUE pour l'IP de la requête — le plafond
+	* `wsMaxConnectionsPerIp`, partagé par les sockets WebSocket ET les flux SSE :
+	* un seul budget par IP, sinon N sockets plus N flux doubleraient le plafond.
+	* Le débit n'est pas recompté ici : la requête qui ouvre un flux l'a déjà été
+	* à l'entrée du pipeline.
+	*
+	* @param req - la requête qui ouvre le flux (en-têtes + socket du pair)
+	* @param connection - ce dont la fermeture rend la place (la réponse)
+	* @returns `true` si la place est prise — ou si aucun plafond n'est armé
+	*/
+	acquireConnectionSlot(req, connection) {
+		if (this.#wsConnCounter === null) return true;
+		const ip = this.#clientIp(req);
+		return ip === null || this.#acquireSlot(ip, connection);
+	}
+	/** IP cliente, résolue comme en HTTP (RFC 7239 + `trustProxy`). */
+	#clientIp(req) {
+		return resolveForwarded(req.headers, req.socket.remoteAddress, this.getTrustProxyChecker()).clientIp;
+	}
+	/**
+	* Compte une connexion de `ip` ; sa place est rendue à la fermeture de
+	* `connection`. Le compteur est capturé : la connexion décrémente TOUJOURS
+	* l'instance qui l'a comptée, même après reconfiguration — et `once("close")`
+	* part à toute fermeture (`terminate` du battement, rejet du pare-feu…).
+	*/
+	#acquireSlot(ip, connection) {
+		const counter = this.#wsConnCounter;
+		if (counter === null) return true;
+		if (!counter.tryAcquire(ip)) return false;
+		connection.once("close", () => counter.release(ip));
+		return true;
+	}
+	/**
+	* Inscrit un flux SSE à identité révocable : il sera fermé dans la fenêtre de
+	* re-validation qui suit la mort de son identité (déconnexion, session
+	* révoquée, jeton expiré ou annulé) — le même registre et la même règle que
+	* les sockets WebSocket.
+	*
+	* @internal — appelé par le flux lui-même.
+	*/
+	watchStream(stream) {
+		(this.#streams ??= new RevocationWatch({
+			isValid: (entry) => entry.revalidate(),
+			revoke: (entry) => void entry.close(),
+			identityOf: (entry) => entry.identifier ?? void 0
+		})).register(stream);
+	}
+	/** Retire un flux du registre de révocation (à sa fermeture). @internal */
+	unwatchStream(stream) {
+		this.#streams?.unregister(stream);
+	}
+	/**
+	* Re-valide tous les flux SSE et ferme ceux dont l'identité est morte.
+	* Publique pour qu'un banc la déclenche sans attendre le tick.
+	*/
+	revalidateStreams() {
+		return this.#streams?.revalidate() ?? Promise.resolve();
+	}
 };
-HttpKernel = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module])], HttpKernel);
+HttpKernel = __decorate([injectable()], HttpKernel);
 var http_kernel_default = HttpKernel;
-//#endregion
-export { http_kernel_default as default };
+export { http_kernel_default as default, responseEnded };