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

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

@@ -6,21 +6,20 @@ import { WsConnectionCounter } from "../src/rateLimit/WsConnectionCounter.js";
 import { compileDomainPatterns, compileTrustedHosts, isDomainAllowed } from "../src/context/domainMatcher.js";
 import { responseEnded } from "../src/context/responseEnded.js";
 import { parseWebsocketUrl } from "../src/context/websocket/websocketUrl.js";
-import WebsocketContext from "../src/context/websocket/WebsocketContext.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.153.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.153.0/helpers/esm/decorate.js";
-import { GcScheduler, IDENTITY_CHANGED_EVENT, Module, RequestContext, RevocationWatch, 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"
@@ -126,9 +125,7 @@ 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,
@@ -356,7 +353,7 @@ let HttpKernel = class HttpKernel extends Service {
 		const policy = this.getWsOriginPolicy(secure ? "websocketSecure" : "websocket");
 		if (policy.disabled) return true;
 		if (!origin) return true;
-		let originHost = null;
+		let originHost;
 		try {
 			originHost = new URL(origin).hostname;
 		} catch {
@@ -382,7 +379,7 @@ let HttpKernel = class HttpKernel extends Service {
 	* @throws {HttpError} code WS 1008 (Policy Violation) si l'Origin est refusée.
 	*/
 	checkWebsocketOrigin(context) {
-		const secure = context.type === "websocket-secure";
+		const secure = context.serverType === "wss";
 		const raw = context.origin;
 		if (this.isWebsocketOriginAllowed(raw, context.domain, secure)) return;
 		const error = new HttpError(`WebSocket Origin "${raw}" not allowed (CSWSH protection)`, 1008, context);
@@ -481,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);
 	}
 	/**
@@ -580,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;
 	}
@@ -633,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) {
@@ -676,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);
@@ -686,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;
 	}
 	/**
@@ -720,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 = [];
@@ -736,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,
@@ -856,7 +878,7 @@ let HttpKernel = class HttpKernel extends Service {
 			response.on("close", () => {
 				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);
 			});
@@ -1019,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");
 		}
@@ -1057,21 +1085,48 @@ let HttpKernel = class HttpKernel extends Service {
 			this.log(e, "ERROR", "WS onFinish");
 		}
 	}
-	async onWebsocketRequest(ws, req, type) {
-		const refusal = this.websocketQuotaRefusal(req, ws);
-		if (refusal !== null) {
-			if (ws.readyState === Ws.OPEN) ws.close(1013, refusal);
+	/**
+	* 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;
 		}
@@ -1107,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;
 		}
@@ -1137,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);
@@ -1150,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;
@@ -1301,7 +1377,6 @@ let HttpKernel = class HttpKernel extends Service {
 		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, responseEnded };

package/dist/nodefony/service/pretty-request-logger.js

@@ -1,6 +1,7 @@
+import { handshakeRefusalStatus } from "../src/context/websocket/WebsocketContext.js";
 import { computeDurationMs, severityFromStatus } from "./audit-logger.js";
 import { logColor } from "nodefony";
-//#region nodefony/service/pretty-request-logger.ts
+// nodefony/service/pretty-request-logger.ts
 /**
 * Pretty single-line logger for dev (P3.2) — the biggest gain for humans.
 *
@@ -34,12 +35,13 @@ var PrettyRequestLogger = class {
 	}
 	renderWebsocket(context, error, acceptedProtocol) {
 		const ctx = context;
-		const status = ctx.response?.statusCode ?? (error ? 500 : null);
+		const refused = error ? handshakeRefusalStatus(context, error) : null;
+		const status = refused ?? ctx.response?.statusCode ?? (error ? 500 : null);
 		const duration = computeDurationMs(ctx.phases);
 		const proto = acceptedProtocol ? `[${acceptedProtocol}]` : "";
 		return {
 			text: `${logColor.cyan("WS  ")} ${colorizeStatus(status)} ${ctx.url} ${logColor.blackBright(proto)} ${logColor.blackBright(formatDuration(duration))} ${logColor.blackBright(ctx.remoteAddress ?? "-")} ` + logColor.magenta(`[${shortId(ctx.requestId)}]`) + (error ? ` ${logColor.red(error.message)}` : ""),
-			severity: error ? "ERROR" : "INFO",
+			severity: refused !== null ? severityFromStatus(refused) : error ? "ERROR" : "INFO",
 			msgid: "req"
 		};
 	}
@@ -61,5 +63,4 @@ function formatDuration(ms) {
 function shortId(id) {
 	return id.length > 8 ? id.slice(0, 8) : id;
 }
-//#endregion
 export { PrettyRequestLogger as default };

package/dist/nodefony/service/request-logger.js

@@ -1,5 +1,15 @@
+import { handshakeRefusalStatus } from "../src/context/websocket/WebsocketContext.js";
+import { severityFromStatus } from "./audit-logger.js";
 import { logColor } from "nodefony";
-//#region nodefony/service/request-logger.ts
+// nodefony/service/request-logger.ts
+/**
+* Statut de la réponse : le contrat ne type `response` qu'en `object` ; une
+* annotation (vérifiée, pas une assertion) le lit — le reste passe par le contrat, que le
+* compilateur surveille.
+*/
+const statusOf = (context) => {
+	return context.response?.statusCode;
+};
 /**
 * Default Nodefony per-request logger — preserves the legacy colored format.
 *
@@ -13,14 +23,13 @@ import { logColor } from "nodefony";
 */
 var DefaultRequestLogger = class {
 	renderHttp(context, error) {
-		const ctx = context;
-		const txt = `${logColor.cyan("URL")} : ${ctx.url} ${logColor.cyan("FROM")} : ${ctx.remoteAddress} ${logColor.cyan("ORIGIN")} : ${ctx.originUrl?.host} ${logColor.cyan("ID")} : ${ctx.requestId}`;
-		const err = error ?? ctx.error;
+		const txt = `${logColor.cyan("URL")} : ${context.url} ${logColor.cyan("FROM")} : ${context.remoteAddress} ${logColor.cyan("ORIGIN")} : ${context.originUrl?.host} ${logColor.cyan("ID")} : ${context.requestId}`;
+		const err = error ?? context.error;
 		if (err) {
-			const errCode = err.code ?? ctx.response?.statusCode ?? 500;
-			const msgid = `${ctx.type} ${logColor.magenta(errCode)} ${logColor.red(ctx.method ?? "")}`;
+			const errCode = err.code ?? statusOf(context) ?? 500;
+			const msgid = `${context.serverType} ${logColor.magenta(errCode)} ${logColor.red(context.method ?? "")}`;
 			return {
-				text: ctx.kernel?.environment === "production" ? `${txt} ${err}` : `${txt}\n          ${err}`,
+				text: context.kernel?.environment === "production" ? `${txt} ${err}` : `${txt}\n          ${err}`,
 				severity: "ERROR",
 				msgid
 			};
@@ -28,27 +37,26 @@ var DefaultRequestLogger = class {
 		return {
 			text: txt,
 			severity: "INFO",
-			msgid: `${ctx.type} ${logColor.magenta(ctx.response?.statusCode ?? "")} ${ctx.method}`
+			msgid: `${context.serverType} ${logColor.magenta(statusOf(context) ?? "")} ${context.method}`
 		};
 	}
 	renderWebsocket(context, error, acceptedProtocol) {
-		const ctx = context;
 		if (error) {
-			const errCode = error.code ?? ctx.response?.statusCode ?? 500;
-			const msgid = `${ctx.type} ${logColor.magenta(errCode)} ${logColor.red(ctx.method ?? "")}`;
+			const refused = handshakeRefusalStatus(context, error);
+			const errCode = refused ?? error.code ?? statusOf(context) ?? 500;
+			const msgid = `${context.serverType} ${logColor.magenta(errCode)} ${logColor.red(context.method ?? "")}`;
 			return {
-				text: `${logColor.cyan("URL")} : ${ctx.url}  ${logColor.cyan("FROM")} : ${ctx.remoteAddress} ${logColor.cyan("ORIGIN")} : ${ctx.originUrl?.host} ${logColor.cyan("ID")} : ${ctx.requestId}\n        ` + error.toString(),
-				severity: "ERROR",
+				text: `${logColor.cyan("URL")} : ${context.url}  ${logColor.cyan("FROM")} : ${context.remoteAddress} ${logColor.cyan("ORIGIN")} : ${context.originUrl?.host} ${logColor.cyan("ID")} : ${context.requestId}\n        ` + error.toString(),
+				severity: refused !== null ? severityFromStatus(refused) : "ERROR",
 				msgid
 			};
 		}
-		const msgid = `${ctx.type} ${logColor.magenta(ctx.response?.statusCode ?? "")} ${ctx.method}`;
+		const msgid = `${context.serverType} ${logColor.magenta(statusOf(context) ?? "")} ${context.method}`;
 		return {
-			text: `${logColor.cyan("URL")} : ${ctx.url} ${logColor.cyan("Accept-Protocol")} : ${acceptedProtocol || "*"} ${logColor.cyan("FROM")} : ${ctx.remoteAddress} ${logColor.cyan("ORIGIN")} : ${ctx.originUrl?.host} ${logColor.cyan("ID")} : ${ctx.requestId}`,
+			text: `${logColor.cyan("URL")} : ${context.url} ${logColor.cyan("Accept-Protocol")} : ${acceptedProtocol || "*"} ${logColor.cyan("FROM")} : ${context.remoteAddress} ${logColor.cyan("ORIGIN")} : ${context.originUrl?.host} ${logColor.cyan("ID")} : ${context.requestId}`,
 			severity: "INFO",
 			msgid
 		};
 	}
 };
-//#endregion
 export { DefaultRequestLogger as default };

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

@@ -1,11 +1,12 @@
 import { isAmbiguousPath, normalizePrefix, parseProxyOrigin, proxyMountProblems, websocketHandshakeProblem } from "../src/proxy/rules.js";
+import { requestAuthority } from "../src/context/transport.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
+// 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;
@@ -240,7 +241,7 @@ var ReverseProxy = class extends Service {
 		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"];
+		const host = requestAuthority(req.headers);
 		return forwardRequest(req, res, mount, target, this.fromOf(req, scheme, host), this.relayFor(mount, target));
 	}
 	/**
@@ -332,5 +333,4 @@ function hostnameOf(host) {
 		return null;
 	}
 }
-//#endregion
 export { ReverseProxy as default };

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

@@ -1,4 +1,5 @@
-//#region nodefony/service/servers/clientError.ts
+import { isPeerGoneError } from "../../src/context/websocket/Response.js";
+// nodefony/service/servers/clientError.ts
 /**
 * Gère l'event `clientError` d'un `http.Server` / `https.Server`.
 *
@@ -16,5 +17,23 @@ function handleClientError(error, socket) {
 	const statusLine = error.code === "HPE_HEADER_OVERFLOW" ? "431 Request Header Fields Too Large" : "400 Bad Request";
 	socket.end(`HTTP/1.1 ${statusLine}\r\nConnection: close\r\n\r\n`);
 }
-//#endregion
-export { handleClientError };
+/**
+* Gère l'event `sessionError` d'un serveur HTTP/2 (h2c ou TLS) : un pair PARTI
+* se tait, toute autre erreur est rapportée.
+*
+* Une session réinitialisée par le pair n'a rien à diagnostiquer. C'est la
+* signature d'une sonde de port — `nodefony status`, `doctor`, le superviseur
+* de développement, la sonde `tcpSocket` d'un orchestrateur — qui se connecte
+* puis ferme sans lire le `SETTINGS` que le serveur envoie dès l'ouverture : le
+* système ferme alors par un RST plutôt qu'un FIN, et Node lève `ECONNRESET`.
+* La rapporter imprimait une pile entière par sonde. La règle « client parti »
+* est celle des frames WebSocket ({@link isPeerGoneError}), pas une copie.
+*
+* @param error - erreur de session émise par `node:http2`
+* @param report - rapporte une erreur réelle, à la sévérité choisie par le serveur
+*/
+function handleSessionError(error, report) {
+	if (isPeerGoneError(error)) return;
+	report(error);
+}
+export { handleClientError, handleSessionError };

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

@@ -0,0 +1,126 @@
+import { asServersConfig, configuredServerPort, isH2cEnabled } from "../../src/servers/kernelServers.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
+import { handleSessionError } from "./clientError.js";
+import { createDrainTerminator } from "./serverShutdown.js";
+import { bindWithFallback, buildBindPlan, h2cPortConflict } from "../../src/servers/portBinder.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorateParam.js";
+import { http2ServerLimits, setHttp2SessionTimeout } from "../../src/servers/http2Limits.js";
+import { BootConfigurationError, Inject, Service, nodefonyError } from "nodefony";
+import http2 from "node:http2";
+// nodefony/service/servers/server-h2c.ts
+/**
+* Serveur HTTP/2 en clair (h2c, connaissance préalable — RFC 9113 §3.3), sur un
+* port DÉDIÉ (`servers.h2c`, 5153 par défaut), pour un proxy inverse qui parle
+* HTTP/2 à ses amonts.
+*
+* Il partage le chemin HTTP/2 du 5152 — même `onHttpRequest`, mêmes limites
+* anti-DoS (`http2ServerLimits`), même drain par GOAWAY — sans TLS : `serverType`
+* vaut `"http"`, le schéma vient du transport ou d'un proxy de confiance, jamais
+* du pseudo-en-tête `:scheme`. Le protocole du saut (`"h2c"`) se constate sur la
+* requête (`transport.ts#alpnProtocolOf`).
+*
+* Hors de son périmètre, délibérément : HTTP/1.1 (refusé par la préface HTTP/2 —
+* sondes et clients HTTP/1.1 restent sur le port HTTP), WebSocket (aucun CONNECT
+* étendu, RFC 8441 : un proxy route `Upgrade: websocket` vers le port HTTP) et la
+* bascule `Upgrade: h2c` (retirée par RFC 9113 §3.1).
+*/
+let ServerH2c = class ServerH2c extends Service {
+	httpKernel;
+	module;
+	server = null;
+	httpTerminator = null;
+	port;
+	protocol = "2.0";
+	ready = false;
+	type = "http";
+	domain;
+	scheme = "http";
+	address = null;
+	family = null;
+	active = false;
+	infos = null;
+	constructor(module, httpKernel) {
+		super("server-h2c", module.container ?? void 0, module.notificationsCenter, module.config.http);
+		this.httpKernel = httpKernel;
+		this.module = module;
+		this.active = isH2cEnabled(asServersConfig(module.kernel?.options.servers)?.h2c);
+		this.port = configuredServerPort(asServersConfig(module.kernel?.options.servers), "h2c") ?? 0;
+		this.domain = this.module.kernel?.domain ?? null;
+	}
+	/**
+	* Crée et met en écoute le serveur h2c.
+	*
+	* @returns le serveur à l'écoute
+	* @throws BootConfigurationError si `servers.h2c.port` est celui du serveur
+	*   HTTP ou HTTPS — un port partagé n'est pas un conflit à contourner
+	*/
+	createServer() {
+		return new Promise((resolve, reject) => {
+			try {
+				if (!this.active) return reject(/* @__PURE__ */ new Error(`Server h2c is not allowed in config file`));
+				const domain = this.domain;
+				if (domain === null) return reject(/* @__PURE__ */ new Error(`Server h2c : aucun domaine d'écoute (kernel absent)`));
+				const servers = asServersConfig(this.module.kernel?.options.servers);
+				const conflict = h2cPortConflict(servers);
+				if (conflict !== null) return reject(new BootConfigurationError(`servers.h2c.port (${this.port}) est aussi celui de servers.${conflict}.port : HTTP/1.1 et h2c ne partagent pas un port. Choisir un port distinct pour servers.h2c.port.`));
+				if (!servers?.http) this.log("servers.h2c actif sans servers.http : les sondes de santé et les WebSocket (HTTP/1.1) n'ont plus de port où arriver.", "WARNING");
+				const server = http2.createServer(http2ServerLimits(this.module.config.http2));
+				this.server = server;
+				this.httpTerminator = createDrainTerminator(server, this.options.shutdownTimeout);
+				setHttp2SessionTimeout(server, this.options.timeout, () => {
+					this.fire("onTimeout", this);
+				});
+				server.on("request", (request, response) => {
+					this.httpKernel.onHttpRequest(request, response, this.type);
+				});
+				server.on("sessionError", (error) => {
+					handleSessionError(error, (e) => this.log(e, "DEBUG", "H2C sessionError"));
+				});
+				server.on("streamError", (error) => {
+					this.log(error, "ERROR", "H2C streamError");
+				});
+				this.module.fire("onCreateServer", this.type, this);
+				bindWithFallback(server, domain, buildBindPlan("h2c", servers, this.module.kernel?.environment)).then(({ address, shiftedFrom }) => {
+					this.infos = address;
+					this.port = address.port;
+					this.address = address.address;
+					this.family = familyOf(address);
+					if (shiftedFrom !== null) this.log(`Port ${shiftedFrom} déjà occupé → h2c écoute sur ${this.port}. Figer le port : servers.h2c.port ; échouer au lieu de glisser : servers.portPolicy = "strict".`, "WARNING");
+					this.ready = true;
+					this.module.fire("onServersReady", this.type, this);
+					server.on("error", (error) => {
+						this.log(new nodefonyError(error), "CRITIC");
+					});
+					resolve(server);
+				}).catch((e) => {
+					const error = e instanceof Error ? e : new Error(String(e));
+					this.log(new nodefonyError(error), "CRITIC");
+					server.close();
+					reject(error);
+				});
+				this.kernel?.once("onTerminate", async () => {
+					if (!this.server) return;
+					try {
+						await this.httpTerminator?.terminate();
+						this.log(`h2c SHUTDOWN PORT : ${this.port}`, "INFO");
+					} catch (e) {
+						this.log(e, "ERROR", "TERMINATE");
+					}
+				});
+			} catch (e) {
+				this.log(e, "CRITIC");
+				return reject(e instanceof Error ? e : new Error(String(e)));
+			}
+		});
+	}
+	showBanner() {
+		if (this.infos) this.log(`Server Listen on h2c://${this.infos.address}:${this.infos.port} Family: ${this.infos.family} Protocol : ${this.protocol}`);
+	}
+};
+ServerH2c = __decorate([__decorateParam(1, Inject("HttpKernel"))], ServerH2c);
+/** Famille d'une adresse d'écoute, lue sans conversion (`AddressInfo.family` est une chaîne). */
+function familyOf(address) {
+	return address.family === "IPv6" ? "IPv6" : "IPv4";
+}
+var server_h2c_default = ServerH2c;
+export { server_h2c_default as default };

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

@@ -1,14 +1,12 @@
 import { asServersConfig, configuredServerPort } from "../../src/servers/kernelServers.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 __decorate from "../../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.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.153.0/helpers/esm/decorateParam.js";
-import { Module, Service, extend, inject, nodefonyError } from "nodefony";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorateParam.js";
+import { Inject, Service, extend, nodefonyError } from "nodefony";
 import http from "node:http";
-//#region nodefony/service/servers/server-http.ts
+// nodefony/service/servers/server-http.ts
 let ServerHttp = class ServerHttp extends Service {
 	httpKernel;
 	module;
@@ -129,7 +127,6 @@ let ServerHttp = class ServerHttp extends Service {
 		if (this.infos) this.log(`Server Listen on ${this.scheme}://${this.infos.address}:${this.infos.port} Family: ${this.infos.family} Protocol : ${this.protocol}`);
 	}
 };
-ServerHttp = __decorate([__decorateParam(1, inject("HttpKernel")), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module, typeof http_kernel_default === "undefined" ? Object : http_kernel_default])], ServerHttp);
+ServerHttp = __decorate([__decorateParam(1, Inject("HttpKernel"))], ServerHttp);
 var server_http_default = ServerHttp;
-//#endregion
 export { server_http_default as default };