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

package/dist/nodefony/src/proxy/forward.js

@@ -0,0 +1,500 @@
+import http from "node:http";
+import https from "node:https";
+// nodefony/src/proxy/forward.ts
+/**
+* En-têtes de CONNEXION (RFC 9110 §7.6.1) : ils décrivent un saut, jamais le
+* message — un intermédiaire ne les transmet pas. Les cinq premiers sont en
+* outre INTERDITS en HTTP/2 (RFC 9113 §8.2.2) : Node lève
+* `ERR_HTTP2_INVALID_CONNECTION_HEADERS` si une réponse les porte.
+*/
+const HOP_BY_HOP = /* @__PURE__ */ new Set([
+	"connection",
+	"keep-alive",
+	"proxy-connection",
+	"transfer-encoding",
+	"upgrade",
+	"te",
+	"trailer",
+	"proxy-authorization",
+	"proxy-authenticate"
+]);
+/**
+* En-têtes qui décrivent la chaîne de relais. Crus d'un relais de confiance,
+* écartés sinon : un client direct qui les pose ment sur son origine.
+*/
+const FORWARDING = /* @__PURE__ */ new Set([
+	"forwarded",
+	"x-forwarded-for",
+	"x-forwarded-proto",
+	"x-forwarded-host",
+	"x-forwarded-port",
+	"x-forwarded-prefix",
+	"x-forwarded-scheme",
+	"x-real-ip"
+]);
+/** Corps d'erreur du proxy — courts, sans détail interne. */
+const BAD_GATEWAY = "Bad Gateway";
+const GATEWAY_TIMEOUT = "Gateway Timeout";
+const LOOP_DETECTED = "Loop Detected";
+const NOT_IMPLEMENTED = "Not Implemented";
+/**
+* Sauts `Via` au-delà desquels un message est tenu pour une boucle. Notre
+* pseudonyme ne repère une boucle qu'au RETOUR dans ce processus : derrière un
+* répartiteur qui tourne sur N instances, cela peut prendre N+1 sauts, chacun
+* tenant une connexion. Une chaîne légitime (CDN, répartiteur, ingress) en
+* compte rarement plus de cinq.
+*/
+const MAX_VIA_HOPS = 10;
+/**
+* Noms listés par l'en-tête `Connection` d'un message : eux aussi ne valent
+* que pour ce saut (RFC 9110 §7.6.1).
+*
+* @param value - valeur brute de `Connection`
+* @returns noms en minuscules, ou `null` s'il n'y en a aucun
+*/
+function connectionTokens(value) {
+	if (value === void 0) return null;
+	const raw = Array.isArray(value) ? value.join(",") : value;
+	let tokens = null;
+	for (const t of raw.split(",")) {
+		const name = t.trim().toLowerCase();
+		if (name === "") continue;
+		(tokens ??= /* @__PURE__ */ new Set()).add(name);
+	}
+	return tokens;
+}
+/** Valeur d'en-tête aplatie (`a, b` pour un tableau). */
+function flat(value) {
+	return Array.isArray(value) ? value.join(", ") : value;
+}
+/**
+* Le message est-il déjà passé par CE processus ? Un `Via` qui porte notre
+* pseudonyme signe une boucle (RFC 9110 §7.6 : un proxy ne se renvoie pas un
+* message sans s'en protéger).
+*
+* @param via - en-tête `Via` reçu
+* @param pseudonym - pseudonyme de ce processus
+*/
+function viaLoops(via, pseudonym) {
+	const value = flat(via);
+	if (value === void 0) return false;
+	const hops = value.split(",");
+	if (hops.length >= 10) return true;
+	for (const hop of hops) if (hop.trim().split(/\s+/)[1] === pseudonym) return true;
+	return false;
+}
+/** Entrée `Via` de ce saut : `<version> <pseudonyme>` (RFC 9110 §7.6.3). */
+function viaEntry(httpVersion, pseudonym) {
+	return `${httpVersion.startsWith("2") ? "2" : httpVersion || "1.1"} ${pseudonym}`;
+}
+/**
+* Cadrage du corps reçu — décidé UNE fois, pour que l'amont lise exactement
+* les octets que le proxy lui envoie (RFC 9112 §6.3). Un `Transfer-Encoding`
+* l'emporte sur un `Content-Length` (que l'on retire alors) ; en HTTP/2, un
+* flux sans fin à la tête porte un corps même sans longueur annoncée.
+*
+* @param req - requête reçue
+* @returns le cadrage à appliquer vers l'amont
+*/
+function bodyFramingOf(req) {
+	const coding = req.headers["transfer-encoding"];
+	if (coding !== void 0) {
+		if (coding === "chunked") return "chunked";
+		return coding.trim().toLowerCase() === "chunked" ? "chunked" : "unsupported";
+	}
+	if (req.headers["content-length"] !== void 0) return "length";
+	const stream = req.stream;
+	if (stream !== void 0 && !stream.endAfterHeaders) return "chunked";
+	return "none";
+}
+/**
+* En-têtes de la requête à transmettre à l'amont.
+*
+* - écartés : pseudo-en-têtes HTTP/2, en-têtes de connexion et ceux que nomme
+*   `Connection`, `Expect` (le serveur a déjà répondu `100`), en-têtes retirés
+*   par le montage, chaîne de relais venue d'un pair NON fiable ;
+* - `Host` réécrit sur la cible (sauf `preserveHost`) ;
+* - `X-Forwarded-For` prolongé (pair fiable) ou recommencé ;
+*   `X-Forwarded-Proto`/`-Host` hérités d'un pair fiable, posés sinon ;
+*   `X-Forwarded-Prefix` quand le préfixe est retiré — à la suite de celui
+*   d'un pair fiable ; `Forwarded` d'un pair fiable prolongé de ce saut ;
+* - `Via` prolongé de ce saut ;
+* - cadrage du corps rendu cohérent ({@link bodyFramingOf}).
+*
+* @returns un objet neuf, prêt pour `http.request`
+*/
+function requestHeadersFor(headers, mount, target, from, pseudonym, framing) {
+	const listed = connectionTokens(headers.connection);
+	const stripped = mount.stripHeaders;
+	const out = {};
+	for (const name of Object.keys(headers)) {
+		const lower = name.toLowerCase();
+		if (lower.charCodeAt(0) === 58) continue;
+		if (HOP_BY_HOP.has(lower) || listed?.has(lower)) continue;
+		if (lower === "host" || lower === "expect" || lower === "via") continue;
+		if (lower === "content-length" && framing !== "length") continue;
+		if (FORWARDING.has(lower) && !from.trustedPeer) continue;
+		if (stripped?.includes(lower)) continue;
+		const value = headers[name];
+		if (value !== void 0) out[lower] = value;
+	}
+	out.host = mount.preserveHost === true && from.host ? from.host : target.host;
+	const prior = from.trustedPeer ? flat(headers["x-forwarded-for"]) : void 0;
+	if (from.remoteAddress) out["x-forwarded-for"] = prior ? `${prior}, ${from.remoteAddress}` : from.remoteAddress;
+	out["x-forwarded-proto"] ??= from.scheme;
+	if (from.host) out["x-forwarded-host"] ??= from.host;
+	if (mount.stripPrefix === true) {
+		let outer = from.trustedPeer ? flat(headers["x-forwarded-prefix"]) : void 0;
+		if (outer?.endsWith("/")) outer = outer.slice(0, -1);
+		out["x-forwarded-prefix"] = (outer ?? "") + mount.prefix.slice(0, -1);
+	}
+	const forwarded = from.trustedPeer ? flat(headers.forwarded) : void 0;
+	if (forwarded) out.forwarded = `${forwarded}, ${forwardedElement(from)}`;
+	const via = flat(headers.via);
+	const hop = viaEntry(from.httpVersion, pseudonym);
+	out.via = via ? `${via}, ${hop}` : hop;
+	if (framing === "chunked") out["transfer-encoding"] = "chunked";
+	return out;
+}
+/** Caractères d'un `token` (RFC 9110 §5.6.2) — compilé une fois. */
+const TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+/** Valeur d'un paramètre `Forwarded` : jeton nu, sinon chaîne entre guillemets (RFC 7239 §4). */
+function forwardedValue(value) {
+	return TOKEN.test(value) ? value : `"${value.replace(/["\\]/g, "\\$&")}"`;
+}
+/**
+* Élément `Forwarded` de ce saut : `for=` (une IPv6 entre crochets et
+* guillemets, RFC 7239 §6), `proto=`, `host=`.
+*/
+function forwardedElement(from) {
+	const address = from.remoteAddress;
+	let element = `for=${forwardedValue(address === void 0 ? "unknown" : address.includes(":") ? `[${address}]` : address)};proto=${forwardedValue(from.scheme)}`;
+	if (from.host) element += `;host=${forwardedValue(from.host)}`;
+	return element;
+}
+/**
+* Ramène sous le préfixe un `Location` émis par un amont qui ignore son
+* montage (`stripPrefix`) — l'équivalent de `proxy_redirect default` de
+* nginx. Un chemin absolu (`/login`) et une URL sur l'origine de l'amont sont
+* réécrits ; toute autre URL (un tiers) part intacte.
+*
+* @returns la valeur réécrite, ou celle reçue
+*/
+function rewriteLocation(location, mount, target) {
+	if (mount.stripPrefix !== true) return location;
+	if (location.startsWith("/") && !location.startsWith("//")) return mount.prefix + location.slice(1);
+	if (location.startsWith(target.origin + "/") || location === target.origin) return mount.prefix + location.slice(target.origin.length + 1);
+	return location;
+}
+/**
+* En-têtes de la réponse de l'amont à renvoyer au client : en-têtes de
+* connexion écartés — y compris ceux que nomme `Connection` —, `Via`
+* prolongé, `Location` ramené sous le préfixe (`stripPrefix`) ; le reste
+* intact (un `set-cookie` multiple reste un tableau).
+*
+* @returns un objet neuf, valable en HTTP/1.1 comme en HTTP/2
+*/
+function responseHeadersFor(headers, mount, target, hop) {
+	const listed = connectionTokens(headers.connection);
+	const out = {};
+	for (const name of Object.keys(headers)) {
+		if (HOP_BY_HOP.has(name) || listed?.has(name)) continue;
+		const value = headers[name];
+		if (value !== void 0) out[name] = value;
+	}
+	const via = flat(headers.via);
+	out.via = via ? `${via}, ${hop}` : hop;
+	if (typeof out.location === "string") out.location = rewriteLocation(out.location, mount, target);
+	return out;
+}
+/**
+* Chemin transmis à l'amont : tel quel, ou sans le préfixe (`stripPrefix`).
+*
+* @param url - cible de la requête (chemin + requête), qui commence par le préfixe
+* @param mount - montage qui relaie
+* @returns le chemin, toujours avec un `/` en tête
+*/
+function upstreamPath(url, mount) {
+	if (mount.stripPrefix !== true) return url;
+	return `/${url.slice(mount.prefix.length)}`;
+}
+/**
+* Options de `http.request` communes aux deux relais : cible, pool, TLS.
+* La vérification du certificat suit `secure` (refusé hors boucle locale
+* au montage).
+*/
+function requestOptions(target, mount, relay) {
+	const options = {
+		protocol: target.protocol,
+		hostname: target.hostname,
+		port: target.port
+	};
+	if (relay.agent !== void 0) options.agent = relay.agent;
+	if (target.protocol === "https:") options.rejectUnauthorized = mount.secure !== false;
+	return options;
+}
+/** Module client selon le scheme de la cible. */
+function requestFn(target) {
+	return target.protocol === "https:" ? https.request : http.request;
+}
+/**
+* Arme le délai d'ÉTABLISSEMENT de la connexion amont — distinct du délai
+* d'inactivité : un amont qui n'accepte pas la connexion ne doit pas tenir le
+* client pendant tout `timeoutMs`. Un socket réutilisé (pool) est déjà
+* connecté : rien à armer.
+*
+* @param upstream - requête vers l'amont
+* @param ms - délai
+* @param onTimeout - appelé si la connexion n'est pas établie à temps
+*/
+function armConnectTimeout(upstream, ms, onTimeout) {
+	upstream.once("socket", (socket) => {
+		if (!socket.connecting) return;
+		const timer = setTimeout(onTimeout, ms);
+		const clear = () => {
+			clearTimeout(timer);
+			socket.removeListener("connect", clear);
+			socket.removeListener("close", clear);
+		};
+		socket.once("connect", clear);
+		socket.once("close", clear);
+	});
+}
+/**
+* Relaie une requête HTTP vers l'amont et renvoie sa réponse au client.
+*
+* Le corps est transmis avec un cadrage cohérent ({@link bodyFramingOf}). Un
+* message qui porte déjà notre `Via` rend 508 sans contacter l'amont. Un
+* client parti coupe l'échange amont ; un amont injoignable rend 502 ; une
+* connexion non établie à temps ou un amont muet rendent 504 — à condition
+* que rien n'ait encore été envoyé, sinon la réponse est interrompue (un
+* statut ne se rattrape pas). Un amont coupé en plein corps interrompt la
+* réponse au client au lieu de la laisser pendre.
+*
+* @returns une promesse résolue à la fermeture de la réponse — jamais rejetée
+*/
+function forwardRequest(req, res, mount, target, from, relay) {
+	return new Promise((resolve) => {
+		const out = res;
+		let closed = false;
+		let failed = false;
+		const fail = (status, body) => {
+			if (failed || closed) return;
+			failed = true;
+			if (out.headersSent) {
+				out.destroy();
+				return;
+			}
+			out.writeHead(status, {
+				"content-type": "text/plain; charset=utf-8",
+				"content-length": Buffer.byteLength(body),
+				"cache-control": "no-store"
+			});
+			out.end(body);
+		};
+		let upstream = null;
+		out.once("close", () => {
+			closed = true;
+			if (!out.writableFinished) upstream?.destroy();
+			resolve();
+		});
+		if (viaLoops(req.headers.via, relay.pseudonym)) {
+			fail(508, LOOP_DETECTED);
+			return;
+		}
+		const framing = bodyFramingOf(req);
+		if (framing === "unsupported") {
+			fail(501, NOT_IMPLEMENTED);
+			return;
+		}
+		const options = requestOptions(target, mount, relay);
+		options.method = req.method ?? "GET";
+		options.path = upstreamPath(req.url ?? "/", mount);
+		options.headers = requestHeadersFor(req.headers, mount, target, from, relay.pseudonym, framing);
+		if (mount.timeoutMs !== void 0) options.timeout = mount.timeoutMs;
+		const request = requestFn(target)(options);
+		upstream = request;
+		let timedOut = false;
+		const giveUp = () => {
+			timedOut = true;
+			fail(504, GATEWAY_TIMEOUT);
+			request.destroy();
+		};
+		armConnectTimeout(request, relay.connectTimeoutMs, giveUp);
+		request.on("timeout", giveUp);
+		request.on("error", () => {
+			if (!timedOut) fail(502, BAD_GATEWAY);
+		});
+		const hop = viaEntry(from.httpVersion, relay.pseudonym);
+		request.on("response", (answer) => {
+			if (closed || failed) {
+				answer.resume();
+				return;
+			}
+			try {
+				out.writeHead(answer.statusCode ?? 502, responseHeadersFor(answer.headers, mount, target, hop));
+			} catch {
+				answer.resume();
+				fail(502, BAD_GATEWAY);
+				return;
+			}
+			answer.once("close", () => {
+				if (!answer.complete) out.destroy();
+			});
+			answer.pipe(out);
+		});
+		if (framing === "none") {
+			request.end();
+			return;
+		}
+		const body = req;
+		const onClientError = () => {
+			request.destroy();
+		};
+		body.once("error", onClientError);
+		request.once("close", () => {
+			body.removeListener("error", onClientError);
+			body.unpipe(request);
+			if (!body.readableEnded) body.resume();
+		});
+		body.pipe(request);
+	});
+}
+/**
+* Sérialise une tête de réponse HTTP/1.1 depuis des en-têtes BRUTS (paires
+* nom/valeur), sans réordonner ni fusionner, en écartant les noms donnés —
+* une réponse `101` doit rendre au client exactement ce que l'amont a négocié.
+*
+* @param status - ligne de statut, sans CRLF
+* @param rawHeaders - `IncomingMessage.rawHeaders`
+* @param skip - noms à écarter (minuscules)
+* @param extra - lignes ajoutées à la fin (`Nom: valeur`)
+* @returns la tête complète, CRLF final compris
+*/
+function rawHead(status, rawHeaders, skip = null, extra = []) {
+	let head = `${status}\r\n`;
+	for (let i = 0; i + 1 < rawHeaders.length; i += 2) {
+		const name = rawHeaders[i] ?? "";
+		if (skip?.has(name.toLowerCase())) continue;
+		head += `${name}: ${rawHeaders[i + 1]}\r\n`;
+	}
+	for (const line of extra) head += `${line}\r\n`;
+	return `${head}\r\n`;
+}
+/**
+* Réponse brute minimale sur un socket d'upgrade, puis fermeture.
+*
+* Les en-têtes passent par la validation de `node:http` : un nom ou une valeur
+* invalide — un saut de ligne surtout, qui forgerait un en-tête de plus — est
+* OMIS, jamais écrit. `Connection` et `Content-Length` sont posés ici et ne se
+* remplacent pas.
+*
+* @param socket - socket du client, encore en attente de sa réponse
+* @param status - statut HTTP du refus
+* @param reason - phrase de raison
+* @param headers - en-têtes du refus (`WWW-Authenticate`, `Retry-After`…)
+*/
+function refuseUpgrade(socket, status, reason, headers) {
+	if (!socket.writable) {
+		socket.destroy();
+		return;
+	}
+	let extra = "";
+	if (headers) for (const name of Object.keys(headers)) {
+		const lower = name.toLowerCase();
+		if (lower === "connection" || lower === "content-length") continue;
+		const value = String(headers[name]);
+		try {
+			http.validateHeaderName(name);
+			http.validateHeaderValue(name, value);
+		} catch {
+			continue;
+		}
+		extra += `${name}: ${value}\r\n`;
+	}
+	socket.end(`HTTP/1.1 ${status} ${reason}\r\n${extra}Connection: close\r\nContent-Length: 0\r\n\r\n`);
+}
+/** En-têtes d'une réponse d'amont REFUSANT l'upgrade, à ne pas recopier tels quels. */
+const REFUSAL_SKIP = /* @__PURE__ */ new Set([
+	"transfer-encoding",
+	"content-length",
+	"connection",
+	"keep-alive"
+]);
+/**
+* Relaie un upgrade WebSocket DÉJÀ validé (méthode, `Upgrade`, clé, version,
+* `Origin` — cf `ReverseProxy.handleUpgrade`) : rejoue le handshake vers
+* l'amont, renvoie sa réponse `101` au client puis raccorde les deux sockets
+* octet pour octet. Un refus de l'amont (`400`, `403`…) est rendu avec un
+* cadrage refait (fin de corps = fermeture) ; un amont injoignable rend `502`,
+* une connexion non établie à temps — ou un amont qui accepte puis se tait
+* au-delà de `timeoutMs` — `504`, une boucle `508`. Le délai d'inactivité
+* cesse au `101` : un tunnel établi peut rester muet. Une erreur d'un côté
+* détruit l'autre.
+*/
+function forwardUpgrade(req, socket, head, mount, target, from, relay) {
+	if (viaLoops(req.headers.via, relay.pseudonym)) {
+		refuseUpgrade(socket, 508, LOOP_DETECTED);
+		return;
+	}
+	const options = requestOptions(target, mount, relay);
+	options.agent = false;
+	options.method = "GET";
+	options.path = upstreamPath(req.url ?? "/", mount);
+	const headers = requestHeadersFor(req.headers, mount, target, from, relay.pseudonym, "none");
+	headers.connection = "Upgrade";
+	headers.upgrade = "websocket";
+	options.headers = headers;
+	if (mount.timeoutMs !== void 0) options.timeout = mount.timeoutMs;
+	if (head.length > 0) socket.unshift(head);
+	const upstream = requestFn(target)(options);
+	let state = "pending";
+	const onClientError = () => {
+		upstream.destroy();
+	};
+	socket.once("error", onClientError);
+	armConnectTimeout(upstream, relay.connectTimeoutMs, () => {
+		state = "refused";
+		refuseUpgrade(socket, 504, GATEWAY_TIMEOUT);
+		upstream.destroy();
+	});
+	upstream.on("timeout", () => {
+		if (state === "open") return;
+		if (state === "pending") refuseUpgrade(socket, 504, GATEWAY_TIMEOUT);
+		else socket.destroy();
+		state = "refused";
+		upstream.destroy();
+	});
+	upstream.on("upgrade", (answer, upSocket, upHead) => {
+		state = "open";
+		upSocket.setTimeout(0);
+		socket.removeListener("error", onClientError);
+		const destroyBoth = () => {
+			socket.destroy();
+			upSocket.destroy();
+		};
+		socket.on("error", destroyBoth);
+		upSocket.on("error", destroyBoth);
+		upSocket.setKeepAlive(true);
+		socket.setKeepAlive(true);
+		if (upHead.length > 0) upSocket.unshift(upHead);
+		socket.write(rawHead(`HTTP/1.1 101 ${answer.statusMessage ?? "Switching Protocols"}`, answer.rawHeaders));
+		upSocket.pipe(socket).pipe(upSocket);
+	});
+	upstream.on("response", (answer) => {
+		state = "refused";
+		socket.write(rawHead(`HTTP/1.1 ${answer.statusCode ?? 502} ${answer.statusMessage ?? ""}`, answer.rawHeaders, REFUSAL_SKIP, ["Connection: close"]));
+		answer.pipe(socket);
+	});
+	upstream.on("error", () => {
+		if (state === "refused") return;
+		if (state === "open") {
+			socket.destroy();
+			return;
+		}
+		state = "refused";
+		refuseUpgrade(socket, 502, BAD_GATEWAY);
+	});
+	upstream.end();
+}
+export { MAX_VIA_HOPS, bodyFramingOf, forwardRequest, forwardUpgrade, rawHead, refuseUpgrade, requestHeadersFor, responseHeadersFor, rewriteLocation, upstreamPath, viaLoops };

package/dist/nodefony/src/proxy/generateProxyConfig.js

@@ -1,16 +1,18 @@
-//#region nodefony/src/proxy/generateProxyConfig.ts
+// nodefony/src/proxy/generateProxyConfig.ts
 /** Valeurs par défaut d'un modèle d'introspection (complété par la commande). */
 const defaultIntrospection = {
 	domains: [],
 	backendHost: "127.0.0.1",
 	httpPort: 5151,
 	httpsPort: 5152,
+	h2cPort: null,
 	staticRoots: [],
 	mounts: [],
 	listen: 80,
 	reencrypt: false,
 	maxBodyBytes: 0,
 	keepaliveIntervalMs: 0,
+	readinessPath: "/readyz",
 	tls: null
 };
 /**
@@ -123,8 +125,16 @@ function nginxServerBlock(intro, scheme, idleSeconds, tls) {
 */
 function generateHaproxyConfig(intro) {
 	const backendPort = intro.reencrypt ? intro.httpsPort : intro.httpPort;
+	const h2cPort = intro.reencrypt ? null : intro.h2cPort ?? null;
 	const idleSeconds = idleTimeoutSeconds(intro);
 	const serverSsl = intro.reencrypt ? ` ssl ca-file /etc/haproxy/certs/ca.pem verify required verifyhost ${firstDomain(intro)} sni str(${firstDomain(intro)})` : "";
+	const readiness = intro.readinessPath ?? null;
+	const healthCheck = readiness === null ? "" : `  # Retire l'exemplaire dès que ${readiness} répond 503 (début de l'arrêt),
+  # pas seulement quand son port se ferme.
+  option httpchk GET ${readiness}
+  http-check expect status 200
+`;
+	const h2cCheck = readiness === null ? "check" : `check port ${intro.httpPort} check-proto h1`;
 	const staticNote = intro.staticRoots.length > 0 || intro.mounts.length > 0 ? "  # NB : haproxy ne sert pas de fichiers — les statiques sont proxifiés au\n  # backend. Pour les offloader, utiliser nginx (proxy:generate nginx) +\n  # `statics.enabled: false` côté Nodefony.\n" : "";
 	return `# Généré par \`nodefony proxy:generate haproxy\` — NE PAS éditer à la main.
 # Reverse-proxy dérivé de l'introspection Nodefony.
@@ -166,11 +176,10 @@ frontend fe_nodefony
   http-request set-header Forwarded "for=%[src];proto=https;host=%[req.hdr(host)]" if { ssl_fc }
   http-request set-header Forwarded "for=%[src];proto=http;host=%[req.hdr(host)]" unless { ssl_fc }
 
-  default_backend be_nodefony
-
+${h2cPort === null ? "  default_backend be_nodefony\n" : "  # h2c (servers.h2c) : HTTP/2 en clair vers le backend, plusieurs flux par\n  # connexion. WebSocket reste en HTTP/1.1 sur le port HTTP : le port h2c\n  # n'annonce pas le CONNECT étendu (RFC 8441).\n  use_backend be_nodefony if { hdr(upgrade) -i websocket }\n  default_backend be_nodefony_h2c\n"}
 backend be_nodefony
-${staticNote}  server nodefony ${intro.backendHost}:${backendPort} check${serverSsl}
-`;
+${healthCheck}${staticNote}  server nodefony ${intro.backendHost}:${backendPort} check${serverSsl}
+${h2cPort === null ? "" : `\nbackend be_nodefony_h2c\n${healthCheck}  server nodefony_h2c ${intro.backendHost}:${h2cPort} ${h2cCheck} proto h2\n`}`;
 }
 /** Premier domaine non-IP (pour verifyhost/sni), défaut `localhost`. */
 function firstDomain(intro) {
@@ -180,5 +189,4 @@ function firstDomain(intro) {
 function ensureTrailingSlash(dir) {
 	return dir.endsWith("/") ? dir : `${dir}/`;
 }
-//#endregion
 export { defaultIntrospection, generateHaproxyConfig, generateNginxConfig };