@nodefony/http 10.0.0-alpha.1

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

@@ -0,0 +1,948 @@
+import HttpError from "../src/errors/httpError.js";
+import { buildTrustProxy } from "../src/context/trustProxy.js";
+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 Context from "../src/context/Context.js";
+import WebsocketContext from "../src/context/websocket/WebsocketContext.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 PrettyRequestLogger from "./pretty-request-logger.js";
+import { resolveTraceparent } from "./trace.js";
+import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import { GcScheduler, Module, RequestContext, Service, injectable, logColor, nodefonyError, writeRuntimeState } from "nodefony";
+import cluster from "node:cluster";
+import Ws from "ws";
+//#region nodefony/service/http-kernel.ts
+const HEALTH_HEADERS = {
+	"content-type": "application/json",
+	"cache-control": "no-store"
+};
+const HEALTH_BODY_OK = "{\"status\":\"ok\"}";
+const HEALTH_BODY_UNREADY = "{\"status\":\"unready\"}";
+const perfProbe = process.env.NF_PERF_PROBE === "1" ? {
+	count: 0,
+	enterScopeNs: 0,
+	ctxNs: 0,
+	leaveScopeNs: 0,
+	t0: 0n,
+	svcNs: 0,
+	ctxBaseNs: 0,
+	uploadNs: 0,
+	reqResNs: 0,
+	svcStartNs: 0,
+	svcOptsNs: 0,
+	svcLookupsNs: 0,
+	svcEventNs: 0,
+	reqStartNs: 0,
+	reqProxyNs: 0,
+	reqUrlNs: 0,
+	reqQueryNs: 0,
+	reqMetaNs: 0,
+	reqAcceptNs: 0
+} : null;
+if (perfProbe) globalThis.__nfPerfProbe = perfProbe;
+const serviceName = "HttpKernel";
+const WS_DEV_LOOPBACK = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1",
+	"[::1]"
+]);
+let HttpKernel = class HttpKernel extends Service {
+	#statelessIntentVues = null;
+	certificates;
+	serviceCerticats = null;
+	key = "";
+	cert = "";
+	ca = "";
+	serverStatic = null;
+	domain = "";
+	trustedHosts;
+	domainCheck = false;
+	regAlias = [];
+	module;
+	httpsPort;
+	httpPort;
+	responseTimeout;
+	closeTimeOutWs;
+	secContentTypeOptions = null;
+	secFrameOptions = null;
+	secHsts = null;
+	sessionService;
+	router;
+	firewall;
+	errorRenderer = new DefaultErrorRenderer();
+	requestLogger = new DefaultRequestLogger();
+	profiler = null;
+	_trustProxyChecker = null;
+	_wsOriginPolicy = Object.create(null);
+	rateLimiter = null;
+	rateLimitGc = null;
+	#wsConnCounter = null;
+	#healthPaths = null;
+	#healthShutdownDelay = 0;
+	#terminating = false;
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, module.options);
+		this.module = module;
+		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
+		};
+		this.closeTimeOutWs = {
+			ws: this.options.websocket.closeTimeout,
+			wss: this.options.websocketSecure.closeTimeout
+		};
+		this.computeSecurityHeaderCaches();
+	}
+	/**
+	* (Re)calcule les caches dérivés des en-têtes de sécurité depuis `this.options`
+	* — au boot ET à chaque édition live ({@link onConfigChanged}). Lus tels quels
+	* dans `onHttpRequest` (0 alloc/concat par requête).
+	*/
+	computeSecurityHeaderCaches() {
+		const sec = this.options.securityHeaders;
+		this.secContentTypeOptions = sec?.contentTypeOptions ?? null;
+		this.secFrameOptions = sec?.frameOptions ?? null;
+		if (sec?.strictTransportSecurity) {
+			const hsts = sec.strictTransportSecurity;
+			let v = `max-age=${hsts.maxAge}`;
+			if (hsts.includeSubDomains) v += "; includeSubDomains";
+			if (hsts.preload) v += "; preload";
+			this.secHsts = v;
+		} else this.secHsts = null;
+	}
+	/**
+	* Ce que ce kernel ÉMET réellement comme en-têtes de sécurité transport.
+	*
+	* Ces trois en-têtes (HSTS, X-Frame-Options, X-Content-Type-Options) sont posés
+	* ici, à l'entrée brute, pour couvrir aussi les statiques et les pages d'erreur
+	* — pas par `@nodefony/security`, dont les clés homonymes sont inertes. Toute
+	* console d'administration doit donc lire CE point, sinon elle affiche une
+	* intention de configuration au lieu de l'état appliqué.
+	*
+	* Lu depuis les caches recalculés au boot ET à chaque édition live
+	* ({@link onConfigChanged}) : la valeur rendue suit la config à chaud.
+	*
+	* @returns les valeurs d'en-tête, `null` quand l'en-tête n'est pas émis.
+	*/
+	describeTransportSecurityHeaders() {
+		return {
+			strictTransportSecurity: this.secHsts,
+			frameOptions: this.secFrameOptions,
+			contentTypeOptions: this.secContentTypeOptions
+		};
+	}
+	/**
+	* Hook appelé par le data plane admin APRÈS une édition LIVE de la config
+	* (`PATCH /nodefony/kernel/api/config/http`, dev only). Recompute les valeurs
+	* DÉRIVÉES mises en cache (en-têtes sécurité, checker trust-proxy, trustedHosts) :
+	* sans lui, l'édition d'un champ `runtimeMutable` porté par un cache serait
+	* ignorée. Les champs lus DIRECTEMENT depuis `options` (`headerServer`,
+	* `maxBodySize`) n'en ont pas besoin — l'appel reste idempotent et bon marché.
+	*/
+	onConfigChanged() {
+		this.computeSecurityHeaderCaches();
+		this._trustProxyChecker = null;
+		this._wsOriginPolicy = Object.create(null);
+		this.trustedHosts = this.options?.trustedHosts;
+		this.regAlias = this.compileAlias();
+		this.configureRateLimit();
+		this.configureWsConnectionLimit();
+		this.configureHealth();
+	}
+	/**
+	* (Re)configure le rate-limit général par IP depuis `options.rateLimit` — au
+	* boot (`onReady`) ET à chaque édition live ({@link onConfigChanged}). Désarme
+	* le GC précédent puis reconstruit compteur + scheduler UNIQUEMENT si
+	* `enabled` ; sinon `rateLimiter` reste `null` → 0 coût sur le hot path.
+	*/
+	/**
+	* Compteur de rate-limit actif, ou `null` s'il est désactivé — surface de
+	* LECTURE pour le data plane admin (introspection des IP suivies). `null` est
+	* l'information « fonction désarmée », pas une erreur : l'appelant l'affiche
+	* tel quel plutôt que d'inventer un état.
+	*/
+	get rateLimitStore() {
+		return this.rateLimiter;
+	}
+	configureRateLimit() {
+		this.rateLimitGc?.stop();
+		this.rateLimitGc = null;
+		const cfg = this.options.rateLimit;
+		if (!cfg?.enabled) {
+			this.rateLimiter = null;
+			return;
+		}
+		this.rateLimiter = new MemoryRateLimitStore({
+			windowMs: cfg.windowS * 1e3,
+			max: cfg.max,
+			maxTracked: cfg.maxTracked
+		});
+		this.rateLimitGc = new GcScheduler({
+			intervalS: cfg.gcIntervalS,
+			jitter: cfg.gcJitter !== false,
+			run: () => this.rateLimiter?.gc() ?? 0,
+			onError: (e) => this.log(e, "WARNING", "RATELIMIT-GC")
+		});
+		this.rateLimitGc.start();
+	}
+	/**
+	* (Re)configure le backstop OPT-IN de connexions WS concurrentes par IP (F6c)
+	* depuis `options.wsMaxConnectionsPerIp` — au boot ET à l'édition live. `null` (ou
+	* ≤ 0) = désactivé → `#wsConnCounter` reste `null` (0 alloc / 0 tracking, cas
+	* cloud-native par défaut : le cap concurrent est délégué à l'ingress). Reconstruit
+	* un compteur neuf : les sockets déjà ouvertes décrémentent l'ancienne instance
+	* (capturée dans leur closure de fermeture) → pas de dérive sur la nouvelle.
+	*/
+	configureWsConnectionLimit() {
+		const max = this.options.wsMaxConnectionsPerIp;
+		this.#wsConnCounter = typeof max === "number" && max > 0 ? new WsConnectionCounter(max) : null;
+	}
+	/**
+	* (Re)configure les probes de santé `/livez` + `/readyz` depuis
+	* `options.health` — au boot (`onReady`) ET à l'édition live. `enabled:false`
+	* → `#healthPaths` reste `null` (0 coût sur le hot path).
+	*/
+	configureHealth() {
+		const cfg = this.options.health;
+		this.#healthPaths = cfg?.enabled ? {
+			liveness: cfg.livenessPath,
+			readiness: cfg.readinessPath
+		} : null;
+		this.#healthShutdownDelay = cfg?.shutdownDelay ?? 0;
+	}
+	/**
+	* Répond une probe de santé — court-circuit TOTAL du pipeline : pas de
+	* contexte/scope DI/session/ALS, pas de rate-limit, pas de log par sonde
+	* (le kubelet sonde toutes les 2-10 s). Réponses pré-allouées.
+	*
+	* @param response - réponse serveur brute (HTTP/1 ou H2 compat)
+	* @param ok - `true` → 200, `false` → 503 (readiness pendant boot/shutdown)
+	*/
+	#respondHealth(response, ok) {
+		const res = response;
+		res.writeHead(ok ? 200 : 503, HEALTH_HEADERS);
+		res.end(ok ? HEALTH_BODY_OK : HEALTH_BODY_UNREADY);
+	}
+	async init() {
+		this.applyRequestLoggerFromConfig();
+		this.kernel?.prependOnceListener("onReady", () => {
+			this.serviceCerticats = this.get("certificates");
+			this.serverStatic = this.get("server-static");
+			this.domain = this.kernel?.domain;
+			this.trustedHosts = this.options?.trustedHosts;
+			this.regAlias = this.compileAlias();
+			this.sessionService = this.get("sessions");
+			this.profiler = this.get("profiler");
+			this.configureRateLimit();
+			this.configureWsConnectionLimit();
+			this.configureHealth();
+		});
+		this.once("onTerminate", () => {
+			this.rateLimitGc?.stop();
+		});
+		this.kernel?.once("onPostReady", () => {
+			this.kernel?.prependOnceListener("onTerminate", async () => {
+				this.#terminating = true;
+				if (this.#healthShutdownDelay > 0) await new Promise((r) => setTimeout(r, this.#healthShutdownDelay));
+			});
+		});
+		this.kernel?.prependOnceListener("onBoot", () => {
+			this.router = this.get("router");
+			this.firewall = this.get("firewall");
+		});
+		return this;
+	}
+	/**
+	* Checker de confiance reverse-proxy, compilé une seule fois depuis
+	* `options.trustProxy` (lazy — pas de `BlockList` allouée par requête).
+	* Consommé par `HttpRequest`/`HttpContext` pour décider de l'adoption des
+	* en-têtes `X-Forwarded-*`.
+	*
+	* @returns le {@link TrustProxyChecker} partagé.
+	*/
+	getTrustProxyChecker() {
+		if (this._trustProxyChecker === null) this._trustProxyChecker = buildTrustProxy(this.options?.trustProxy);
+		return this._trustProxyChecker;
+	}
+	/**
+	* Politique d'Origin WS (B4) compilée paresseusement pour un type de serveur
+	* (`websocket` / `websocketSecure`), depuis `options.<type>.allowedOrigins` :
+	*  - `true` → contrôle désactivé (`disabled`) ;
+	*  - `false` (défaut) → same-origin seul (`extra` vide) ;
+	*  - string/liste → Origins cross-origin additionnelles (compilées en RegExp).
+	*
+	* @param cfgKey - `"websocket"` ou `"websocketSecure"`.
+	* @returns la politique mémoïsée (0 alloc après le 1er handshake).
+	*/
+	getWsOriginPolicy(cfgKey) {
+		let policy = this._wsOriginPolicy[cfgKey];
+		if (!policy) {
+			const raw = this.options[cfgKey]?.allowedOrigins;
+			if (raw === true) policy = {
+				disabled: true,
+				extra: []
+			};
+			else policy = {
+				disabled: false,
+				extra: compileDomainPatterns(raw ? raw : [])
+			};
+			this._wsOriginPolicy[cfgKey] = policy;
+		}
+		return policy;
+	}
+	/**
+	* 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
+	* session de la victime** (reprise L1). On exige donc, par défaut, que
+	* l'`Origin` du handshake corresponde au `Host` servi (same-origin), avec
+	* tolérance loopback en development (Studio Vite cross-port) et allowlist
+	* explicite pour les SPA cross-origin (`allowedOrigins`).
+	*
+	* Une requête SANS `Origin` (client non-navigateur) est acceptée : un attaquant
+	* non-navigateur n'a pas besoin de CSWSH, il se connecte directement.
+	*
+	* @param context - contexte WebSocket au handshake (avant `connect()`).
+	* @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 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;
+		}
+		const error = new HttpError(`WebSocket Origin "${raw}" not allowed (CSWSH protection)`, 1008, context);
+		error.type = "origin";
+		throw error;
+	}
+	/**
+	* Reads the **kernel-level** syslog config (`kernel.options.log`) and swaps
+	* the request logger accordingly. The decision belongs to syslog (not to
+	* the http module) because EVERY request log flows through syslog, and
+	* the format choice is an operator concern shared across all transports.
+	*
+	* Config lue : `kernel.options.log.requestFormat`
+	*   "auto"    → dev=pretty, production=json, autre=default (DEFAULT)
+	*   "default" → DefaultRequestLogger (legacy verbeux)
+	*   "pretty"  → PrettyRequestLogger (1 ligne colorée, P3.2)
+	*   "json"    → JsonAuditLogger (PDU canonique, P3.1)
+	*
+	* Programmatic override via `setRequestLogger(custom)` reste possible et
+	* gagne toujours sur la config (idempotent — last setter wins).
+	*/
+	applyRequestLoggerFromConfig() {
+		const kernelLog = this.kernel?.options?.log ?? {};
+		let format = kernelLog.requestFormat ?? "auto";
+		if (format === "auto") {
+			const env = this.kernel?.environment;
+			format = env === "production" ? "json" : env === "development" ? "pretty" : "default";
+		}
+		if (format === "pretty") this.requestLogger = new PrettyRequestLogger();
+		else if (format === "json") {
+			const advanced = kernelLog.requestLogger ?? {};
+			const opts = {};
+			if (advanced.includeStack !== null && advanced.includeStack !== void 0) opts.includeStack = advanced.includeStack;
+			if (typeof advanced.maxCauseDepth === "number") opts.maxCauseDepth = advanced.maxCauseDepth;
+			if (typeof advanced.sampleRate === "number") opts.sampleRate = advanced.sampleRate;
+			const nominalMode = process.env.NF_BENCH_AUDIT_NOMINAL ?? advanced.nominal ?? "auto";
+			opts.nominal = nominalMode === "always" || nominalMode === "auto" && kernelLog.driver !== "null";
+			this.requestLogger = new JsonAuditLogger(opts);
+		}
+	}
+	async handle(request, response, type) {
+		let scope;
+		if (perfProbe) {
+			const t0 = process.hrtime.bigint();
+			scope = this.container?.enterScope("request");
+			perfProbe.enterScopeNs += Number(process.hrtime.bigint() - t0);
+			perfProbe.count++;
+		} else scope = this.container?.enterScope("request");
+		if (this.kernel?.debug) this.log(logColor.cyanBgBlue(`${request.url}`), "DEBUG", `${type}`);
+		return this.handleHttp(scope, request, response, type);
+	}
+	/**
+	* Arme le contexte pour l'exécution : zone firewall (`context.secure`) et
+	* résolveur de route — **sans instancier le controller**.
+	*
+	* Séparé de {@link handleFrontController} parce que les deux gestes n'ont pas
+	* le même moment légitime. Le MATCH doit être précoce : il pose
+	* `context.sessionIntent` (depuis `@UseSession`) et `resolver.bypassFirewall`,
+	* que le point session unique et le firewall lisent juste après. L'INSTANCE,
+	* elle, exécute du code utilisateur (`initialize()`) et résout des dépendances
+	* DI : elle n'a rien à faire avant que la requête soit autorisée.
+	*
+	* @param checkFirewall - calcule `context.secure` (zone protégée) ; laissé à
+	*   `false` par un appelant qui l'a déjà tranché.
+	* @throws HttpError 404 quand aucune route ne matche, ou l'exception portée
+	*   par le résolveur (405…) — inchangé, et toujours avant le firewall : une
+	*   route inexistante ne devient pas un 401.
+	*/
+	async prepareFrontController(context, checkFirewall = true) {
+		if (!this.router) throw new Error("kernel HTTP not ready");
+		if (this.firewall && checkFirewall) context.secure = this.firewall.isSecure(context);
+		let resolver;
+		if (context.resolver) resolver = context.resolver;
+		else {
+			context.phaseStart("resolve");
+			try {
+				resolver = this.router.resolve(context);
+			} finally {
+				context.phaseEnd("resolve");
+			}
+		}
+		if (resolver.resolve && !resolver.exception) {
+			context.resolver = resolver;
+			return resolver;
+		}
+		if (resolver.exception) throw resolver.exception;
+		throw new HttpError("Not Found", 404, context);
+	}
+	/**
+	* {@link prepareFrontController} + instanciation immédiate du controller
+	* (DI + hook `initialize()`).
+	*
+	* @remarks Réservé au **WebSocket** : le controller doit exister avant
+	*   `context.connect()`, puisqu'il porte le protocole négocié et peut encore
+	*   toucher la réponse du handshake (cookies, en-têtes) — après l'accept, il
+	*   est trop tard. Le HTTP, lui, arme la route ici et laisse
+	*   `Resolver.executeAction` créer l'instance une fois la requête autorisée.
+	*/
+	async handleFrontController(context, checkFirewall = true) {
+		return await (await this.prepareFrontController(context, checkFirewall)).newController(context);
+	}
+	/**
+	* Handles errors by setting appropriate response codes and messages.
+	*
+	* @param error - The error object, which can be of type Error, HttpError, or nodefonyError.
+	* @param context - Optional context parameter, which can be of type ContextType.
+	* @param extraHeaders - Optional additional headers to be included in the response.
+	* @returns A promise that resolves to either HttpContext or WebsocketContext.
+	*
+	* WebSocket error codes and their meanings:
+	*  - code >= 1000 && code <= 2999:
+	*    - 1000: Normal connection closure
+	*    - 1001: Remote peer is going away
+	*    - 1002: Protocol error
+	*    - 1003: Unprocessable input
+	*    - 1004: Reserved
+	*    - 1005: Reason not provided
+	*    - 1006: Abnormal closure, no further detail available
+	*    - 1007: Invalid data received
+	*    - 1008: Policy violation
+	*    - 1009: Message too big
+	*    - 1010: Extension requested by client is required
+	*    - 1011: Internal Server Error
+	*    - 1015: TLS Handshake Failed
+	*  - code >= 3000 && code <= 3999:
+	*    Reserved for use by libraries, frameworks, and applications.
+	*    Should be registered with IANA. Interpretation of these codes is
+	*    undefined by the WebSocket protocol.
+	*  - code >= 4000 && code <= 4999:
+	*    Reserved for private use. Interpretation of these codes is
+	*    undefined by the WebSocket protocol.
+	*/
+	/**
+	* Override the default error renderer — e.g. to hide stack traces in prod
+	* or emit RFC 7807 problem+json. Stateless singleton expected.
+	*/
+	setErrorRenderer(renderer) {
+		this.errorRenderer = renderer;
+	}
+	getErrorRenderer() {
+		return this.errorRenderer;
+	}
+	/**
+	* Override the default per-request logger — JSON access log, NCSA combined,
+	* pretty single-line formatter, etc. Stateless singleton expected.
+	*/
+	setRequestLogger(logger) {
+		this.requestLogger = logger;
+	}
+	getRequestLogger() {
+		return this.requestLogger;
+	}
+	async onError(error, context, _extraHeaders) {
+		if (context) context.error = error;
+		switch (true) {
+			case context instanceof HttpContext: {
+				const result = this.errorRenderer.renderHttp(error, context);
+				if (error instanceof HttpError || error instanceof nodefonyError) error.code = result.status;
+				context.response.setStatusCode(result.status, result.message);
+				if (result.headers) context.response.setHeaders(result.headers);
+				if (this.kernel?.debug) this.log(error.toString(), "ERROR");
+				if (context.finished || context.sended) {
+					this.log(error.toString(), "DEBUG", "onError on closed context");
+					return context;
+				}
+				if (!context.response.isHeaderSent()) {
+					try {
+						await context.render(result.body);
+					} catch (e) {
+						this.log(e, "CRITIC");
+						throw e;
+					}
+					return context;
+				}
+				await context.close();
+				return context;
+			}
+			case context instanceof WebsocketContext: try {
+				const wsResult = this.errorRenderer.renderWebsocket(error, context);
+				if (context.response && 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 (e) {
+				throw error;
+			}
+			default: throw error;
+		}
+	}
+	compileAlias() {
+		return compileTrustedHosts(this.domain, this.trustedHosts, this.kernel?.environment === "development");
+	}
+	async onHttpRequest(request, response, type) {
+		const headerServer = this.options.headerServer;
+		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.#healthPaths !== null) {
+			const url = request.url;
+			if (url === this.#healthPaths.liveness) return this.#respondHealth(response, true);
+			if (url === this.#healthPaths.readiness) return this.#respondHealth(response, !this.#terminating && this.kernel?.servable === true);
+		}
+		if (this.rateLimiter !== null) {
+			const ip = resolveForwarded(request.headers, request.socket?.remoteAddress, this.getTrustProxyChecker()).clientIp;
+			if (ip !== null) {
+				const verdict = this.rateLimiter.hit(ip);
+				response.setHeader("X-RateLimit-Limit", verdict.limit);
+				response.setHeader("X-RateLimit-Remaining", verdict.remaining);
+				response.setHeader("X-RateLimit-Reset", Math.ceil(verdict.resetAtMs / 1e3));
+				if (verdict.limited) {
+					response.setHeader("Retry-After", verdict.retryAfterS);
+					const res = response;
+					res.writeHead(429);
+					res.end();
+					return;
+				}
+			}
+		}
+		if (this.listenerCount("onServerRequest")) await this.fireAsync("onServerRequest", request, response, type).catch((e) => {
+			throw e;
+		});
+		return this.handle(request, response, type).catch((e) => {
+			throw e;
+		});
+	}
+	async initServers() {
+		const servers = [];
+		const serverHttp = this.get("server-http");
+		if (serverHttp?.active) {
+			await serverHttp.createServer();
+			servers.push(serverHttp);
+		}
+		const serverHttps = this.get("server-https");
+		if (serverHttps?.active) {
+			await serverHttps.createServer();
+			servers.push(serverHttps);
+		}
+		const serverWebsocket = this.get("server-websocket");
+		if (serverWebsocket && serverHttp?.active) {
+			await serverWebsocket.createServer(serverHttp);
+			servers.push(serverWebsocket);
+		}
+		const serverWebsocketSecure = this.get("server-websocket-secure");
+		if (serverWebsocketSecure && serverHttps?.active) {
+			await serverWebsocketSecure.createServer(serverHttps);
+			servers.push(serverWebsocketSecure);
+		}
+		this.publishRuntimePorts(serverHttp, serverHttps);
+		return servers;
+	}
+	/**
+	* Publie les ports EFFECTIFS du runtime (state file), une fois l'écoute établie.
+	*
+	* C'est le canal qui rend `servers.portPolicy: "auto"` utilisable : `nodefony
+	* status`, `nodefony stop` et la readiness `--detach` sondaient `[5151, 5152]`
+	* **en dur**. Dès qu'un port glisse, cette convention ment — ils sonderaient un
+	* port que personne n'écoute et conclueraient « serveur down » sur un serveur
+	* parfaitement vivant. Ici, la topologie réelle est écrite noir sur blanc.
+	*
+	* Le port DÉSIRÉ est publié à côté du port obtenu : un outil peut ainsi dire
+	* « tu voulais 5151, tu écoutes sur 5153 » sans deviner.
+	*
+	* **Publié dans TOUS les environnements, production comprise.** Le glissement de
+	* port (`auto`) n'est pas la seule façon de sortir de la convention : une app qui
+	* déclare son port (PaaS `PORT`, ingress, `servers.http.port`) écoute ailleurs
+	* que `[5151, 5152]` **en `strict` aussi**. Sans ce canal, `production --detach
+	* --wait` sonderait la convention, ne verrait rien, et group-killerait au bout de
+	* son plafond un serveur qui écoutait parfaitement (faux négatif — même famille
+	* que « une liste de ports sondés est une CONVENTION, pas la topologie »).
+	* L'écriture est best-effort : un `node_modules` en lecture seule (image
+	* conteneur) ne fait jamais tomber un serveur qui, lui, écoute très bien.
+	*
+	* En **cluster**, le pid publié est celui du MASTER, pas du worker qui écrit :
+	* les workers sont recyclés (respawn), et un pid mort fait purger le canal par
+	* {@link readRuntimeState} — `status`/`stop` redeviendraient aveugles alors que
+	* l'app écoute toujours. Le master, lui, est le propriétaire du runtime.
+	*/
+	publishRuntimePorts(serverHttp, serverHttps) {
+		const ports = [];
+		const desired = [];
+		if (serverHttp?.active && serverHttp.port > 0) {
+			ports.push(serverHttp.port);
+			const d = this.kernel?.options.servers?.http;
+			if (d && d.port) desired.push(d.port);
+		}
+		if (serverHttps?.active && serverHttps.port > 0) {
+			ports.push(serverHttps.port);
+			const d = this.kernel?.options.servers?.https;
+			if (d && d.port) desired.push(d.port);
+		}
+		if (ports.length === 0) return;
+		writeRuntimeState(process.cwd(), {
+			pid: cluster.isWorker ? process.ppid ?? process.pid : process.pid,
+			ports,
+			desiredPorts: desired.length > 0 ? desired : void 0
+		});
+	}
+	/**
+	* Point d'activation UNIQUE de session — symétrique HTTP **et** WS. Ouvre une
+	* session si, et seulement si, la route la déclare (`context.sessionIntent`,
+	* posé par le Resolver depuis `@UseSession` / un paramètre `@Session`) **ou**
+	* si un cookie de session entrant existe déjà (reprise — L1). Sinon : aucune
+	* session (lazy). Remplace l'ancien `sessionAutoStart` global « démarre sur
+	* toutes les routes » (le moteur du ×23).
+	*
+	* @param context - contexte HTTP/HTTP2/WS courant.
+	* @returns la session active, ou `null` si la requête n'en requiert aucune.
+	*/
+	async startSession(context) {
+		if (!this.sessionService) return null;
+		const intent = context.sessionIntent;
+		if (context.security?.stateless === true) {
+			if (intent) {
+				const name = context.security.name;
+				if (this.#statelessIntentVues === null) this.#statelessIntentVues = /* @__PURE__ */ new Set();
+				if (!this.#statelessIntentVues.has(name)) {
+					this.#statelessIntentVues.add(name);
+					this.log(`Zone "${name}" is stateless: the session requested by this route is IGNORED (no session opened, no cookie sent). Drop \`stateless: true\` on the area, or stop requiring a session on its routes.`, "WARNING", "SESSION");
+				}
+			}
+			return null;
+		}
+		if (!intent && !context.hasSession()) return null;
+		return await this.sessionService.start(context, intent?.readOnly);
+	}
+	/**
+	* Teardown post-réponse — fire-and-forget depuis le `once("close")` posé par
+	* `createHttpContext` (un seul fire possible : once auto-détaché). Loggue la
+	* requête, draine les hooks afterResponse/onFinish, libère le scope DI.
+	*/
+	async teardownHttp(context, scope) {
+		if (context.finished) return;
+		try {
+			if (context.waitAsync && !context.sended && this.kernel?.environment === "development") this.log(`Action "${context.resolver?.route?.name ?? context.url}" returned a non-renderable value (void/null/class instance) and never sent a response. Use 'return <object|string|number|boolean|Buffer>' (auto-JSON) or send/stream manually.`, "WARNING");
+			context.logRequest();
+			context.logPhasesVerbose();
+			this.profiler?.collect(context);
+			await context._runAfterResponse();
+			if (context.listenerCount("onFinish")) await context.fireAsync("onFinish", context);
+			context.finished = true;
+			if (perfProbe) {
+				const t0 = process.hrtime.bigint();
+				this.container?.leaveScope(scope);
+				perfProbe.leaveScopeNs += Number(process.hrtime.bigint() - t0);
+			} else this.container?.leaveScope(scope);
+			context.clean();
+		} catch (e) {
+			this.log(e, "ERROR", "TEARDOWN");
+			if (!context.finished) {
+				context.finished = true;
+				this.container?.leaveScope(scope);
+				context.clean();
+			}
+		}
+	}
+	createHttpContext(scope, request, response, type) {
+		try {
+			let context;
+			if (perfProbe) {
+				const t0 = process.hrtime.bigint();
+				perfProbe.t0 = t0;
+				context = new HttpContext(scope, request, response, type);
+				perfProbe.ctxNs += Number(process.hrtime.bigint() - t0);
+				perfProbe.t0 = 0n;
+			} else context = new HttpContext(scope, request, response, type);
+			response.once("close", () => {
+				if (!response.writableEnded) {
+					context._abortIfPending("Connection closed before response finished");
+					if (!context.sended) context.response.statusCode = 499;
+				}
+				this.teardownHttp(context, scope);
+			});
+			return context;
+		} catch (e) {
+			this.log(e, "ERROR");
+			throw e;
+		}
+	}
+	async handleHttp(scope, request, response, type) {
+		let context = null;
+		try {
+			context = this.createHttpContext(scope, request, response, type);
+			if (this.listenerCount("onCreateContext")) await this.fireAsync("onCreateContext", context);
+			context.traceparent = resolveTraceparent(request.headers?.traceparent);
+			const profilerQueries = this.profiler ? [] : null;
+			context.profilerQueries = profilerQueries;
+			context.profiling = profilerQueries !== null;
+			return await RequestContext.run({
+				requestId: context.requestId,
+				scheme: context.scheme,
+				traceparent: context.traceparent,
+				queries: profilerQueries ?? void 0,
+				context
+			}, async () => {
+				if (this.firewall?.handleCors(context) === 204) {
+					context.response.writeHead(204);
+					context.response.end();
+					return context;
+				}
+				context.phaseStart("resolve");
+				context.resolver = this.router ? this.router.resolve(context) : null;
+				context.phaseEnd("resolve");
+				this.firewall?.applySecurityHeaders(context);
+				if (this.serverStatic && context.resolver?.resolve !== true && !context.resolver?.exception && (this.kernel?.options.servers.statics || this.kernel?.options.statics || this.serverStatic.hasMounts())) {
+					response.removeHeader("Content-Type");
+					await this.serverStatic.handle(request, response).catch(() => void 0);
+				}
+				const streamBody = context.resolver?.resolve === true && context.resolver.route?.bodyStream === true;
+				context.phaseStart("parse");
+				try {
+					if (!streamBody) await context.request.initialize();
+				} finally {
+					context.phaseEnd("parse");
+				}
+				const ctx = await this.onRequestEnd(context);
+				if (ctx instanceof Context) {
+					ctx.phaseStart("action");
+					try {
+						return await ctx.handle();
+					} finally {
+						ctx.phaseEnd("action");
+					}
+				}
+				return context;
+			});
+		} catch (e) {
+			return await this.onError(e, context);
+		}
+	}
+	async onRequestEnd(context, error) {
+		if (!context) throw new nodefonyError("Bad context", 500);
+		if (error) throw error;
+		if (this.options[context.scheme].headers) context.response.setHeaders(this.options[context.scheme].headers);
+		if (this.kernel?.options.domainCheck) this.checkValidDomain(context);
+		if (this.listenerCount("beforeResolve")) await this.fireAsync("beforeResolve", context);
+		await this.prepareFrontController(context);
+		this.firewall?.enforceCsrf(context);
+		await this.startSession(context);
+		if (context.secure || context.isControlledAccess) {
+			context.phaseStart("firewall");
+			try {
+				try {
+					await this.firewall?.handleSecurity(context);
+					if (this.listenerCount("afterAuth")) await this.fireAsync("afterAuth", context);
+				} catch (authError) {
+					await this.fireAsync("onAuthFailure", context, authError).catch((e) => this.log(e, "ERROR", "onAuthFailure"));
+					throw authError;
+				}
+			} finally {
+				context.phaseEnd("firewall");
+			}
+			return context;
+		}
+		return context;
+	}
+	createWebsocketContext(scope, req, ws, type) {
+		const context = new WebsocketContext(scope, req, ws, type);
+		context.once("onFinish", async (wscontext) => {
+			if (!context) return;
+			if (context.finished) return;
+			context._abortIfPending("WebSocket closed");
+			await context._runAfterResponse();
+			if (context.session && !context.session.saved) try {
+				await context.saveSession();
+			} catch (e) {
+				this.log(e, "ERROR", "WS onFinish saveSession");
+			}
+			this.container?.leaveScope(wscontext.container);
+			context.clean();
+			context.finished = true;
+		});
+		return context;
+	}
+	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 !== null && 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));
+				}
+			}
+		}
+		await this.fireAsync("onServerRequest", req, null, type).catch((e) => {
+			throw e;
+		});
+		const scope = this.container?.enterScope("request");
+		return this.handleWebsocket(scope, ws, req, type).catch((e) => {
+			throw e;
+		});
+	}
+	async handleWebsocket(scope, ws, req, type) {
+		let context = null;
+		let error = null;
+		try {
+			context = this.createWebsocketContext(scope, req, ws, type);
+		} catch (e) {
+			error = e;
+		}
+		try {
+			if (context) {
+				context.traceparent = resolveTraceparent(req.headers?.traceparent);
+				context.profiling = this.profiler !== null;
+			}
+			const wsRunId = context?.requestId ?? "ws-no-ctx";
+			const wsScheme = context?.scheme ?? "ws";
+			const wsTrace = context?.traceparent ?? null;
+			return await RequestContext.run({
+				requestId: wsRunId,
+				scheme: wsScheme,
+				...wsTrace ? { traceparent: wsTrace } : {},
+				context
+			}, async () => {
+				await this.onConnect(context, error);
+				if (this.firewall && (context?.secure || context?.isControlledAccess)) {
+					context.phaseStart("firewall");
+					try {
+						try {
+							await this.firewall.handleSecurity(context);
+							await this.fireAsync("afterAuth", context);
+						} catch (authError) {
+							await this.fireAsync("onAuthFailure", context, authError).catch((e) => this.log(e, "ERROR", "onAuthFailure"));
+							throw authError;
+						}
+					} finally {
+						context.phaseEnd("firewall");
+					}
+				}
+				if (context) {
+					context.phaseStart("action");
+					try {
+						return await context.handle();
+					} finally {
+						context.phaseEnd("action");
+					}
+				}
+			});
+		} catch (e) {
+			try {
+				await this.onError(e, context);
+			} catch (errorHandlingError) {
+				this.releaseOrphanWsScope(scope, context);
+				throw errorHandlingError;
+			}
+			this.releaseOrphanWsScope(scope, context);
+			throw e;
+		}
+	}
+	releaseOrphanWsScope(scope, context) {
+		if (!context) {
+			this.container?.leaveScope(scope);
+			return;
+		}
+		if (context.teardownWired || context.finished) return;
+		context.finished = true;
+		this.container?.leaveScope(scope);
+		context.clean();
+	}
+	async onConnect(context, error = null) {
+		if (error) throw error;
+		if (!context) throw new nodefonyError("Bad context", 500);
+		if (this.domainCheck) this.checkValidDomain(context);
+		this.checkWebsocketOrigin(context);
+		await this.fireAsync("beforeResolve", context);
+		try {
+			await this.handleFrontController(context);
+		} catch (e) {
+			context.logRequest(e);
+			throw e;
+		}
+		if (!context.sessionStarting) await this.startSession(context);
+		return await context.connect();
+	}
+	checkValidDomain(context) {
+		if (context.validDomain) return 200;
+		const error = `DOMAIN Misdirected Request : ${context.domain}`;
+		throw new HttpError(error, 421);
+	}
+	isValidDomain(context) {
+		return this.isTrustedHostname(context.domain);
+	}
+	/**
+	* Ce nom d'hôte franchit-il la barrière `trustedHosts` ? Même liste compilée
+	* que `isValidDomain`, mais interrogeable **sans contexte** — un module qui
+	* doit décider si un `Host` reçu est légitime (ex. `@nodefony/frontend`, qui
+	* en dérive l'origine des assets Vite) appelle CETTE méthode plutôt que de
+	* recompiler les motifs de son côté : deux copies divergeraient en silence.
+	*
+	* Résolution par NOM (`container.get("HttpKernel")`) chez l'appelant — aucun
+	* import de `@nodefony/http`, donc aucun cycle.
+	*
+	* @param hostname - nom d'hôte SANS port (`Context.domain`).
+	* @returns `true` si un motif de `trustedHosts` (ou le domaine canonique)
+	*   couvre ce nom.
+	*/
+	isTrustedHostname(hostname) {
+		return isDomainAllowed(this.regAlias, hostname);
+	}
+};
+HttpKernel = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module])], HttpKernel);
+var http_kernel_default = HttpKernel;
+//#endregion
+export { http_kernel_default as default };