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

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

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