@nodefony/http 10.0.0-beta.5 → 10.0.0-beta.7

package/dist/nodefony/src/grpc/refusal.js

@@ -0,0 +1,271 @@
+// nodefony/src/grpc/refusal.ts
+/**
+* Refus d'un appel gRPC au format de son protocole (ADR-0026 D5 point 2, D13
+* point 2). Sans Connect : une application sans service gRPC charge ce module
+* avec le noyau, et n'y paie rien tant qu'aucune erreur n'est rendue.
+*
+* Le protocole se reconnaît aux en-têtes de la requête et se code en petit
+* entier (`GRPC_WIRE_*`, 0 = aucun) : une valeur toujours du même type, lue
+* sur le chemin d'erreur seulement.
+*/
+/** Requête qui ne parle aucun protocole gRPC. */
+const GRPC_WIRE_NONE = 0;
+/** gRPC natif (`application/grpc`, `application/grpc+proto`…). */
+const GRPC_WIRE_GRPC = 1;
+/** gRPC-Web (`application/grpc-web`, `application/grpc-web-text`…). */
+const GRPC_WIRE_WEB = 2;
+/** Connect unaire (`connect-protocol-version`, ou GET `?connect=v1`). */
+const GRPC_WIRE_CONNECT = 3;
+/** Connect en flux (`application/connect+proto`, `application/connect+json`). */
+const GRPC_WIRE_CONNECT_STREAM = 4;
+/** `"application/".length` : le sous-type commence là. */
+const SUBTYPE = 12;
+const PLUS = 43;
+const SEMICOLON = 59;
+const SPACE = 32;
+const HYPHEN = 45;
+/** Le sous-type s'arrête ici : fin, suffixe `+codec`, paramètre, espace. */
+function endsSubtype(code) {
+	return Number.isNaN(code) || code === PLUS || code === SEMICOLON || code === SPACE;
+}
+/**
+* Reconnaît le protocole gRPC d'une requête à ses en-têtes : `content-type`
+* d'abord, puis `connect-protocol-version`. Une API JSON ordinaire rend
+* `GRPC_WIRE_NONE`.
+*
+* @param headers - les en-têtes de la requête.
+* @param connectGet - `true` pour un GET qui porte `connect=v1` (Connect
+*   unaire en GET, sans en-tête propre).
+* @returns le protocole reconnu.
+*/
+function grpcWireOf(headers, connectGet = false) {
+	const type = headers["content-type"];
+	if (type?.startsWith("application/") === true) {
+		if (type.startsWith("grpc", SUBTYPE)) {
+			const next = type.charCodeAt(16);
+			if (endsSubtype(next)) return 1;
+			if (next === HYPHEN && type.startsWith("-web", 16)) {
+				const after = type.charCodeAt(20);
+				if (endsSubtype(after) || after === HYPHEN) return 2;
+			}
+			return 0;
+		}
+		if (type.startsWith("connect+", SUBTYPE)) return 4;
+	}
+	if (headers["connect-protocol-version"] !== void 0 || connectGet) return 3;
+	return 0;
+}
+/**
+* Noms des codes gRPC (`google-rpc-code.proto`), en minuscules comme Connect
+* les écrit, indexés par le code : un accès direct, aucune table de hachage.
+*/
+const CODE_NAMES = Object.freeze([
+	"ok",
+	"cancelled",
+	"unknown",
+	"invalid_argument",
+	"deadline_exceeded",
+	"not_found",
+	"already_exists",
+	"permission_denied",
+	"resource_exhausted",
+	"failed_precondition",
+	"aborted",
+	"out_of_range",
+	"unimplemented",
+	"internal",
+	"unavailable",
+	"data_loss",
+	"unauthenticated"
+]);
+/** Les codes en texte décimal, pour l'en-tête `grpc-status` : aucune conversion par refus. */
+const CODE_TEXTS = Object.freeze(CODE_NAMES.map((_name, code) => String(code)));
+/** 16 `UNAUTHENTICATED`. */
+const GRPC_UNAUTHENTICATED = 16;
+/** 7 `PERMISSION_DENIED`. */
+const GRPC_PERMISSION_DENIED = 7;
+/**
+* Le nom d'un code gRPC (`unimplemented`, `unauthenticated`…) — le libellé
+* générique d'un refus (ADR-0026 D5 point 4).
+*
+* @param code - le code gRPC, de 0 à 16.
+* @returns son nom ; `unknown` hors de la plage.
+*/
+function grpcCodeName(code) {
+	return CODE_NAMES[code] ?? "unknown";
+}
+/**
+* Les mêmes noms tels que les écrivent `google/rpc/code.proto` et les
+* conventions OpenTelemetry (`rpc.status_code`) : `OK`, `UNAVAILABLE`… Tirés
+* une fois, au chargement, de {@link CODE_NAMES} — une seule liste.
+*/
+const STATUS_NAMES = Object.freeze(CODE_NAMES.map((name) => name.toUpperCase()));
+/**
+* Le nom d'un code gRPC tel que le publient la ligne d'accès et le canal de
+* traçage (`UNAVAILABLE`) — ADR-0026 D10 point 1.
+*
+* @param code - le code gRPC, de 0 à 16.
+* @returns son nom ; `UNKNOWN` hors de la plage.
+*/
+function grpcStatusName(code) {
+	return STATUS_NAMES[code] ?? "UNKNOWN";
+}
+/**
+* Le code gRPC d'un refus de transport — rendu avant l'implémentation (chemin
+* inconnu, méthode refusée, limite de débit, pare-feu) — en gRPC natif et en
+* gRPC-Web (ADR-0026 D13 point 2). Distincte de la table des erreurs de
+* l'application (D7) ; seule la règle d'identité de 401/403 est commune (D5).
+*
+* @param status - le statut HTTP que le noyau aurait rendu.
+* @param identified - un appelant authentifié est connu.
+* @returns le code gRPC.
+*/
+function transportRefusalCode(status, identified) {
+	switch (status) {
+		case 400: return 13;
+		case 401:
+		case 403: return identified ? 7 : 16;
+		case 404:
+		case 405: return 12;
+		case 421:
+		case 429:
+		case 502:
+		case 503:
+		case 504: return 14;
+		default: return 2;
+	}
+}
+/**
+* Le code gRPC d'une erreur levée par l'APPLICATION pendant un appel — une
+* `HttpError` d'un service partagé avec des routes HTTP, une validation, un
+* conflit (ADR-0026 D7, table « HTTP Mapping » de `google/rpc/code.proto`).
+* Distincte de la table des refus de transport ({@link transportRefusalCode}) :
+* un 404 levé par un service dit « entité introuvable » (5), un chemin inconnu
+* dit « méthode absente » (12). Seule la règle d'identité de 401/403 est
+* commune (D5).
+*
+* `code.proto` associe 409 à `ABORTED` et à `ALREADY_EXISTS` : `ABORTED`, le
+* sens le plus large, est retenu ; `ALREADY_EXISTS` se lève en `ConnectError`.
+*
+* @param status - le statut HTTP que rendrait une route HTTP.
+* @param identified - un appelant authentifié est connu.
+* @returns le code gRPC.
+*/
+function applicationErrorCode(status, identified) {
+	switch (status) {
+		case 400:
+		case 422: return 3;
+		case 401:
+		case 403: return identified ? 7 : 16;
+		case 404: return 5;
+		case 409: return 10;
+		case 412: return 9;
+		case 413:
+		case 429: return 8;
+		case 499: return 1;
+		case 501: return 12;
+		case 502:
+		case 503: return 14;
+		case 408:
+		case 504: return 4;
+		default: return status >= 500 && status <= 599 ? 13 : 2;
+	}
+}
+/**
+* Le code d'un refus en protocole Connect : celui qu'un client DÉDUIT du
+* statut HTTP (`connect-protocol.md`, « HTTP to Error Code »), puisque le
+* statut voyage avec la réponse et doit s'accorder au code. 405 et 421 y
+* valent donc `unknown` (ADR-0026 D13, précision du lot 3) ; 401/403 suivent
+* la règle d'identité (D5).
+*
+* @param status - le statut HTTP du refus.
+* @param identified - un appelant authentifié est connu.
+* @returns le code gRPC.
+*/
+function connectRefusalCode(status, identified) {
+	switch (status) {
+		case 400: return 13;
+		case 401:
+		case 403: return identified ? 7 : 16;
+		case 404: return 12;
+		case 429:
+		case 502:
+		case 503:
+		case 504: return 14;
+		default: return 2;
+	}
+}
+/** Drapeau d'un message de fin de flux Connect (`connect-protocol.md`). */
+const CONNECT_END_STREAM = 2;
+/**
+* Pose le statut et les en-têtes d'un refus au format du protocole, et rend
+* le corps à envoyer — vide en gRPC et gRPC-Web, dont le statut voyage dans
+* les en-têtes (_Trailers-Only_ ; en HTTP/2, `Http2Response.writeHead` termine
+* alors le flux sur la trame d'en-têtes).
+*
+* | Protocole       | Statut HTTP                    | Corps                                  |
+* | --------------- | ------------------------------ | -------------------------------------- |
+* | gRPC, gRPC-Web  | 200                            | aucun                                  |
+* | Connect unaire  | celui du refus (401/403 : D5)  | `{"code":"<nom>"}`                     |
+* | Connect en flux | 200                            | message de fin `{"error":{…}}`         |
+*
+* Le message n'est jamais celui de l'erreur, qui nomme parfois la zone
+* refusée : seul le nom du code part (D5 point 4).
+*
+* @param response - la réponse du contexte, pas encore envoyée.
+* @param wire - le protocole de la requête, autre que `GRPC_WIRE_NONE`.
+* @param status - le statut HTTP que le noyau aurait rendu.
+* @param identified - un appelant authentifié est connu.
+* @param contentType - le `content-type` de la requête, recopié en gRPC,
+*   gRPC-Web et Connect en flux (déjà reconnu par {@link grpcWireOf}).
+* @returns le corps : texte vide, JSON, ou octets d'un message de fin.
+*/
+function prepareGrpcRefusal(response, wire, status, identified, contentType) {
+	if (wire === 3) {
+		const code = connectRefusalCode(status, identified);
+		const connectStatus = code === 16 ? 401 : code === 7 ? 403 : status;
+		response.setStatusCode(connectStatus);
+		response.setHeader("content-type", "application/json");
+		return `{"code":"${grpcCodeName(code)}"}`;
+	}
+	response.setStatusCode(200, "OK");
+	if (contentType !== void 0) response.setHeader("content-type", contentType);
+	if (wire === 4) return connectEndStream(`{"error":{"code":"${grpcCodeName(connectRefusalCode(status, identified))}"}}`);
+	const code = transportRefusalCode(status, identified);
+	response.setHeader("grpc-status", CODE_TEXTS[code] ?? "2");
+	response.setHeader("grpc-message", grpcCodeName(code));
+	return "";
+}
+/**
+* Un message de fin de flux Connect : drapeau, longueur (4 octets, gros
+* boutiste), puis le JSON. Le JSON n'est fait que de noms de codes ASCII :
+* un octet par caractère, aucun encodeur.
+*/
+function connectEndStream(json) {
+	const length = json.length;
+	const frame = new Uint8Array(5 + length);
+	frame[0] = CONNECT_END_STREAM;
+	new DataView(frame.buffer).setUint32(1, length);
+	for (let i = 0; i < length; i++) frame[5 + i] = json.charCodeAt(i);
+	return frame;
+}
+/** Au moins une route gRPC est déclarée dans le processus. */
+let grpcRoutesDeclared = false;
+/**
+* Marque une route comme servie par un point d'entrée gRPC — au démarrage,
+* par `@nodefony/framework/grpc`. Allume la garde qui refuse en 12 une requête
+* gRPC native aboutie à une route qui n'est pas gRPC (ADR-0026 D13 point 3) :
+* tant qu'aucune route n'est marquée, la garde coûte une lecture de booléen.
+*
+* @param route - la route montée pour une méthode du contrat.
+* @experimental Surface gRPC, ADR-0026 D11.
+*/
+function markGrpcRoute(route) {
+	route.grpc = true;
+	grpcRoutesDeclared = true;
+}
+/** `true` dès qu'une route gRPC est déclarée dans le processus. */
+function hasGrpcRoutes() {
+	return grpcRoutesDeclared;
+}
+export { GRPC_PERMISSION_DENIED, GRPC_UNAUTHENTICATED, GRPC_WIRE_CONNECT, GRPC_WIRE_CONNECT_STREAM, GRPC_WIRE_GRPC, GRPC_WIRE_NONE, GRPC_WIRE_WEB, applicationErrorCode, connectRefusalCode, grpcCodeName, grpcStatusName, grpcWireOf, hasGrpcRoutes, markGrpcRoute, prepareGrpcRefusal, transportRefusalCode };

package/dist/nodefony/src/profiler/Profiler.js

@@ -31,6 +31,14 @@ var Profiler = class {
 	/** Dernier numéro d'ordre attribué (0 = aucun profil collecté). */
 	_seq = 0;
 	/**
+	* Démarrage du profileur, donc du processus (ms epoch, horloge du serveur) :
+	* aucune requête servie avant n'est connue. Rendu avec un profil absent, pour
+	* que le lecteur dise « le serveur a redémarré » plutôt que « évincé ».
+	*/
+	startedAt = Date.now();
+	/** Dernier vidage des anneaux (ms epoch), `null` s'il n'y en a jamais eu. */
+	_clearedAt = null;
+	/**
 	* @param cap - capacité de l'anneau de l'application.
 	* @param sideCap - capacité de chacun des anneaux de l'outillage et des
 	*          assets relayés.
@@ -151,12 +159,17 @@ var Profiler = class {
 		const { app, tooling, asset } = this._lanes;
 		return app.size + tooling.size + asset.size;
 	}
-	/** Vide les anneaux. */
+	/** Vide les anneaux, et retient l'instant du vidage ({@link clearedAt}). */
 	clear() {
 		const { app, tooling, asset } = this._lanes;
 		app.clear();
 		tooling.clear();
 		asset.clear();
+		this._clearedAt = Date.now();
+	}
+	/** Dernier vidage des anneaux (ms epoch, horloge du serveur), `null` si aucun. */
+	get clearedAt() {
+		return this._clearedAt;
 	}
 	/**
 	* Profils de numéro supérieur à `from`, tous anneaux confondus, du plus

package/dist/nodefony/src/profiler/aggregate.js

@@ -121,8 +121,8 @@ function actionSelfMs(entry) {
 	}
 	inner.sort((a, b) => a[0] - b[0]);
 	let covered = 0;
-	let curStart = -Infinity;
-	let curEnd = -Infinity;
+	let curStart = -1e400;
+	let curEnd = -1e400;
 	for (const [s, e] of inner) if (s > curEnd) {
 		if (curEnd > curStart) covered += curEnd - curStart;
 		curStart = s;

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

@@ -1,3 +1,4 @@
+import { isUnsupportedTransferCoding } from "./rules.js";
 import http from "node:http";
 import https from "node:https";
 // nodefony/src/proxy/forward.ts
@@ -83,6 +84,71 @@ function viaLoops(via, pseudonym) {
 	for (const hop of hops) if (hop.trim().split(/\s+/)[1] === pseudonym) return true;
 	return false;
 }
+/** `1*DIGIT` (RFC 9110 §7.6.2) — compilé une fois. */
+const DIGITS = /^[0-9]+$/;
+/**
+* `Max-Forwards` reçu, tel qu'un intermédiaire doit le lire (RFC 9110 §7.6.2) :
+* sur `OPTIONS` et `TRACE` seulement — la même section permet de l'ignorer
+* pour toute autre méthode, et il part alors tel quel.
+*
+* @param method - méthode de la requête
+* @param value - en-tête `Max-Forwards` reçu
+* @returns `null` s'il n'y a rien à faire (autre méthode, en-tête absent) ;
+*   `-1` si la valeur n'est pas `1*DIGIT` — elle ne se décrémente pas, l'en-tête
+*   n'est donc pas transmis ; sinon la valeur reçue (`0` : le proxy répond
+*   lui-même, sans joindre l'amont).
+*/
+function receivedMaxForwards(method, value) {
+	if (value === void 0 || method !== "OPTIONS" && method !== "TRACE") return null;
+	const raw = (Array.isArray(value) ? value[0] : value)?.trim() ?? "";
+	return DIGITS.test(raw) ? Number(raw) : -1;
+}
+/**
+* En-têtes qu'une réponse à `TRACE` ne renvoie pas : ils portent des secrets
+* (RFC 9110 §9.3.8 : le destinataire final DEVRAIT exclure les champs
+* susceptibles de contenir des données sensibles).
+*/
+const TRACE_SENSITIVE = /^(?:authorization|proxy-authorization|cookie)$|token|secret|session|api-?key|csrf/i;
+/**
+* Corps `message/http` d'une réponse à `TRACE` : la requête reçue, en-têtes
+* sensibles et pseudo-en-têtes HTTP/2 retirés (RFC 9110 §9.3.8).
+*/
+function traceEcho(req) {
+	let echo = `TRACE ${req.url ?? "/"} HTTP/${req.httpVersion}\r\n`;
+	const authority = req.headers[":authority"];
+	if (req.headers.host === void 0 && typeof authority === "string") echo += `host: ${authority}\r\n`;
+	for (const name of Object.keys(req.headers)) {
+		if (name.charCodeAt(0) === 58 || TRACE_SENSITIVE.test(name)) continue;
+		echo += `${name}: ${flat(req.headers[name])}\r\n`;
+	}
+	return `${echo}\r\n`;
+}
+/**
+* Réponse du proxy en DESTINATAIRE FINAL, quand `Max-Forwards` est épuisé
+* (RFC 9110 §7.6.2) : `TRACE` renvoie la requête reçue (§9.3.8), `OPTIONS`
+* rend 200 avec `Allow` si le montage restreint ses méthodes, et
+* `Content-Length: 0` (§9.3.7). L'amont n'est jamais joint.
+*/
+function answerAsFinalRecipient(req, out, mount) {
+	req.resume();
+	if (req.method === "TRACE") {
+		const body = traceEcho(req);
+		out.writeHead(200, {
+			"content-type": "message/http",
+			"content-length": Buffer.byteLength(body),
+			"cache-control": "no-store"
+		});
+		out.end(body);
+		return;
+	}
+	const headers = {
+		"content-length": 0,
+		"cache-control": "no-store"
+	};
+	if (mount.methods !== void 0) headers.allow = mount.methods.join(", ");
+	out.writeHead(200, headers);
+	out.end();
+}
 /** 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}`;
@@ -98,10 +164,7 @@ function viaEntry(httpVersion, pseudonym) {
 */
 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 (coding !== void 0) return isUnsupportedTransferCoding(coding) ? "unsupported" : "chunked";
 	if (req.headers["content-length"] !== void 0) return "length";
 	const stream = req.stream;
 	if (stream !== void 0 && !stream.endAfterHeaders) return "chunked";
@@ -264,8 +327,9 @@ function armConnectTimeout(upstream, ms, onTimeout) {
 * 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
+* message qui porte déjà notre `Via` rend 508 sans contacter l'amont. Sur
+* `OPTIONS` et `TRACE`, `Max-Forwards` est décrémenté ; à `0`, le proxy répond
+* lui-même en destinataire final (RFC 9110 §7.6.2). 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
@@ -307,10 +371,21 @@ function forwardRequest(req, res, mount, target, from, relay) {
 			fail(501, NOT_IMPLEMENTED);
 			return;
 		}
+		const method = req.method ?? "GET";
+		const hops = receivedMaxForwards(method, req.headers["max-forwards"]);
+		if (hops === 0) {
+			answerAsFinalRecipient(req, out, mount);
+			return;
+		}
 		const options = requestOptions(target, mount, relay);
-		options.method = req.method ?? "GET";
+		options.method = method;
 		options.path = upstreamPath(req.url ?? "/", mount);
-		options.headers = requestHeadersFor(req.headers, mount, target, from, relay.pseudonym, framing);
+		const headers = requestHeadersFor(req.headers, mount, target, from, relay.pseudonym, framing);
+		if (hops !== null) {
+			if (hops > 0) headers["max-forwards"] = String(Math.min(hops - 1, 10));
+			else delete headers["max-forwards"];
+		}
+		options.headers = headers;
 		if (mount.timeoutMs !== void 0) options.timeout = mount.timeoutMs;
 		const request = requestFn(target)(options);
 		upstream = request;
@@ -414,6 +489,31 @@ function refuseUpgrade(socket, status, reason, headers) {
 	}
 	socket.end(`HTTP/1.1 ${status} ${reason}\r\n${extra}Connection: close\r\nContent-Length: 0\r\n\r\n`);
 }
+/** En-têtes du refus d'une version WebSocket inconnue — figés, partagés. */
+const WS_VERSION_REFUSAL_HEADERS = Object.freeze({
+	Upgrade: "websocket",
+	"Sec-WebSocket-Version": "13"
+});
+/**
+* Refuse un handshake WebSocket non conforme — la réponse qui convient à la
+* raison rendue par `websocketHandshakeProblem`, seule implémentation pour le
+* serveur WebSocket ET le proxy inverse.
+*
+* Une version inconnue reçoit `426` avec `Sec-WebSocket-Version: 13` : le
+* client apprend vers quelle version se rabattre (RFC 6455 §4.2.2 point 6,
+* §4.4), et le 426 porte l'`Upgrade` qu'exige RFC 9110 §15.5.22. Tout autre
+* défaut de forme reçoit `400`.
+*
+* @param socket - socket du client, encore en attente de sa réponse
+* @param problem - la raison rendue par `websocketHandshakeProblem`
+*/
+function refuseMalformedHandshake(socket, problem) {
+	if (problem === "Sec-WebSocket-Version ≠ 13") {
+		refuseUpgrade(socket, 426, "Upgrade Required", WS_VERSION_REFUSAL_HEADERS);
+		return;
+	}
+	refuseUpgrade(socket, 400, "Bad Request");
+}
 /** 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",
@@ -497,4 +597,4 @@ function forwardUpgrade(req, socket, head, mount, target, from, relay) {
 	});
 	upstream.end();
 }
-export { MAX_VIA_HOPS, bodyFramingOf, forwardRequest, forwardUpgrade, rawHead, refuseUpgrade, requestHeadersFor, responseHeadersFor, rewriteLocation, upstreamPath, viaLoops };
+export { HOP_BY_HOP, MAX_VIA_HOPS, bodyFramingOf, forwardRequest, forwardUpgrade, rawHead, receivedMaxForwards, refuseMalformedHandshake, refuseUpgrade, requestHeadersFor, responseHeadersFor, rewriteLocation, upstreamPath, viaLoops };

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

@@ -30,6 +30,30 @@ function idleTimeoutSeconds(intro) {
 	if (intro.keepaliveIntervalMs <= 0) return 3600;
 	return Math.max(300, Math.ceil(intro.keepaliveIntervalMs * 4 / 1e3));
 }
+/**
+* Port h2c que le proxy doit joindre, ou `null` — règle UNIQUE des deux
+* générateurs.
+*
+* Seulement vers un backend en clair : le re-chiffrement vise le port TLS, qui
+* négocie déjà HTTP/2 par ALPN, et mélanger les deux liens ferait voyager une
+* partie du trafic en clair alors que l'utilisateur a demandé le chiffrement.
+*
+* @param intro - modèle d'introspection Nodefony.
+* @returns le port h2c à joindre, ou `null` s'il n'y a pas de lien h2c.
+*/
+function upstreamH2cPort(intro) {
+	return intro.reencrypt ? null : intro.h2cPort ?? null;
+}
+/**
+* Le `content-type` d'un appel gRPC natif, en expression régulière nginx :
+* `application/grpc`, suivi de rien, d'un sous-type (`+proto`, `+json`) ou de
+* paramètres (`;`).
+*
+* gRPC-Web (`application/grpc-web…`) n'y entre PAS, et c'est voulu : il est
+* conçu pour HTTP/1.1, le chemin ordinaire le sert déjà, et l'envoyer sur le
+* lien h2c retirerait la traduction que le serveur fait pour le navigateur.
+*/
+const NGINX_GRPC_CONTENT_TYPE = "^application/grpc($|[+;])";
 /** `server_name` nginx / hôte de comparaison — IP et `0.0.0.0` exclus. */
 function serverNames(domains) {
 	const names = domains.filter((d) => d && d !== "0.0.0.0" && !isIpLiteral(d));
@@ -39,15 +63,23 @@ function serverNames(domains) {
 function isIpLiteral(host) {
 	return /^\d{1,3}(\.\d{1,3}){3}$/.test(host) || host.includes(":");
 }
-/** En-têtes forwarded nginx (pattern EDGE : on ÉCRASE X-Forwarded-For). */
-const NGINX_FORWARD_HEADERS_TPL = `      # EDGE (face client) : on ÉCRASE X-Forwarded-For avec la SEULE IP vue par
+/**
+* En-têtes d'identité du client (pattern EDGE : on ÉCRASE X-Forwarded-For),
+* communs au relais HTTP (`proxy_set_header`) et au relais gRPC
+* (`grpc_set_header`) — `__SET__` reçoit la directive. Un seul texte : les deux
+* chemins annoncent au serveur le même client, sinon `trustProxy` lirait deux
+* vérités selon le protocole.
+*/
+const NGINX_CLIENT_HEADERS_TPL = `      # EDGE (face client) : on ÉCRASE X-Forwarded-For avec la SEULE IP vue par
       # nginx → toute valeur forgée par le client est jetée (RFC 7239 §8.1).
-      proxy_set_header Host              $host;
-      proxy_set_header X-Real-IP         $remote_addr;
-      proxy_set_header X-Forwarded-For   $remote_addr;
-      proxy_set_header X-Forwarded-Proto $scheme;
-      proxy_set_header X-Forwarded-Host  $host;
-      proxy_set_header X-Forwarded-Port  $server_port;
+      __SET__ Host              $host;
+      __SET__ X-Real-IP         $remote_addr;
+      __SET__ X-Forwarded-For   $remote_addr;
+      __SET__ X-Forwarded-Proto $scheme;
+      __SET__ X-Forwarded-Host  $host;
+      __SET__ X-Forwarded-Port  $server_port;`;
+/** En-têtes forwarded nginx (pattern EDGE : on ÉCRASE X-Forwarded-For). */
+const NGINX_FORWARD_HEADERS_TPL = `${NGINX_CLIENT_HEADERS_TPL.replaceAll("__SET__ ", "proxy_set_header ")}
       # WebSocket (Nodefony co-héberge HTTP + WS sur le même port).
       proxy_set_header Upgrade           $http_upgrade;
       proxy_set_header Connection        $connection_upgrade;
@@ -61,6 +93,39 @@ function nginxForwardHeaders(idleSeconds) {
 	return NGINX_FORWARD_HEADERS_TPL.replaceAll("__IDLE__", String(idleSeconds));
 }
 /**
+* Le relais gRPC d'un bloc `server` : aiguillage par `content-type`, puis la
+* location nommée qui parle HTTP/2 au port h2c.
+*
+* nginx ne parle HTTP/2 à un amont que par `grpc_pass` (`proxy_pass` s'arrête à
+* HTTP/1.1) ; or gRPC n'existe qu'en HTTP/2, avec son statut dans les trailers.
+* Une `location` ne choisit que sur l'URI, et l'URI d'un appel gRPC
+* (`/paquet.Service/Méthode`) ne se distingue d'aucune autre : c'est donc le
+* `content-type` qui aiguille, au niveau du `server`, par un `if` qui ne fait
+* que `return` — la seule forme qui ne se mêle pas aux `try_files` des
+* locations. Le `418` est un code INTERNE (jamais rendu au client) que
+* `error_page` convertit en saut vers `@grpc`.
+*
+* @param idleSeconds - inactivité tolérée, dérivée du heartbeat WebSocket.
+* @returns les lignes à poser dans le bloc `server`.
+*/
+function nginxGrpcRelay(idleSeconds) {
+	return [
+		"",
+		"    # gRPC (servers.h2c) : HTTP/2 jusqu'au backend, seul chemin où ses trailers",
+		"    # (grpc-status) survivent. gRPC-Web reste sur le chemin HTTP/1.1 ordinaire.",
+		`    if ($content_type ~* "${NGINX_GRPC_CONTENT_TYPE}") { return 418; }`,
+		"    error_page 418 = @grpc;",
+		"",
+		"    location @grpc {",
+		"      grpc_pass grpc://nodefony_h2c;",
+		NGINX_CLIENT_HEADERS_TPL.replaceAll("__SET__ ", "grpc_set_header  "),
+		`      grpc_read_timeout ${idleSeconds}s;`,
+		`      grpc_send_timeout ${idleSeconds}s;`,
+		"      client_max_body_size 0;",
+		"    }"
+	];
+}
+/**
 * Génère une configuration nginx complète (reverse-proxy + offload statiques).
 *
 * @param intro - modèle d'introspection Nodefony.
@@ -71,10 +136,15 @@ function generateNginxConfig(intro) {
 	const backendPort = intro.reencrypt ? intro.httpsPort : intro.httpPort;
 	const idleSeconds = idleTimeoutSeconds(intro);
 	const lines = [];
-	lines.push("# Généré par `nodefony proxy:generate nginx` — NE PAS éditer à la main.", "# Reverse-proxy dérivé de l'introspection Nodefony (domaines, statiques, ports).", "worker_processes auto;", "events { worker_connections 1024; }", "", "http {", "  include /etc/nginx/mime.types;", "  default_type application/octet-stream;", "", "  server_tokens off;", "", "  sendfile on;", "  tcp_nopush on;", "  tcp_nodelay on;", "", "  gzip on;", "  gzip_vary on;", "  gzip_min_length 1024;", "  gzip_proxied any;", "  gzip_types text/plain text/css text/xml application/javascript application/json application/xml image/svg+xml application/manifest+json;", "", "  # Upgrade WebSocket — HTTP et WS co-habitent sur le même port Nodefony.", "  map $http_upgrade $connection_upgrade { default upgrade; '' close; }", "", `  upstream nodefony { server ${intro.backendHost}:${backendPort}; keepalive 32; }`, "");
+	lines.push("# Généré par `nodefony proxy:generate nginx` — NE PAS éditer à la main.", "# Reverse-proxy dérivé de l'introspection Nodefony (domaines, statiques, ports).", "worker_processes auto;", "events { worker_connections 1024; }", "", "http {", "  include /etc/nginx/mime.types;", "  default_type application/octet-stream;", "", "  server_tokens off;", "", "  sendfile on;", "  tcp_nopush on;", "  tcp_nodelay on;", "", "  gzip on;", "  gzip_vary on;", "  gzip_min_length 1024;", "  gzip_proxied any;", "  gzip_types text/plain text/css text/xml application/javascript application/json application/xml image/svg+xml application/manifest+json;", "", "  # Upgrade WebSocket — HTTP et WS co-habitent sur le même port Nodefony.", "  map $http_upgrade $connection_upgrade { default upgrade; '' close; }", "", `  upstream nodefony { server ${intro.backendHost}:${backendPort}; keepalive 32; }`);
+	const h2cPort = upstreamH2cPort(intro);
+	if (h2cPort === null) lines.push(intro.reencrypt && intro.h2cPort ? "  # gRPC : non relayé — le re-chiffrement vise le port TLS ; h2c reste un lien en clair." : "  # gRPC : non relayé — activer `servers.h2c` côté Nodefony puis régénérer.");
+	else lines.push(`  upstream nodefony_h2c { server ${intro.backendHost}:${h2cPort}; keepalive 32; }`);
+	lines.push("");
 	if (intro.maxBodyBytes > 0) lines.push(`  # Aligné sur \`http.maxBodySize\` (${intro.maxBodyBytes} octets) — sans quoi`, "  # nginx rendrait 413 à 1 Mo, son défaut, sans que le serveur le sache.", `  client_max_body_size ${intro.maxBodyBytes};`, "");
-	lines.push(...nginxServerBlock(intro, scheme, idleSeconds, null));
-	if (intro.tls) lines.push("", ...nginxServerBlock(intro, scheme, idleSeconds, intro.tls));
+	const grpc = h2cPort !== null;
+	lines.push(...nginxServerBlock(intro, scheme, idleSeconds, null, grpc));
+	if (intro.tls) lines.push("", ...nginxServerBlock(intro, scheme, idleSeconds, intro.tls, grpc));
 	lines.push("}", "");
 	return lines.join("\n");
 }
@@ -90,12 +160,18 @@ function generateNginxConfig(intro) {
 * @param scheme - `http` ou `https` vers le BACKEND (re-chiffrement).
 * @param idleSeconds - inactivité tolérée, dérivée du heartbeat WebSocket.
 * @param tls - terminaison TLS de CE bloc, ou `null` pour une écoute en clair.
+* @param grpc - relayer gRPC vers l'amont `nodefony_h2c` (h2c actif).
 * @returns les lignes du bloc `server`.
 */
-function nginxServerBlock(intro, scheme, idleSeconds, tls) {
+function nginxServerBlock(intro, scheme, idleSeconds, tls, grpc) {
 	const lines = ["  server {"];
 	if (tls) lines.push(`    listen ${tls.listen} ssl;`, "    http2 on;", `    server_name ${serverNames(intro.domains)};`, "", "    # Terminaison TLS au frontal. Ces chemins sont ceux d'un MONTAGE, à", "    # pourvoir au déploiement (volume compose, secret k8s) : une clé privée", "    # n'entre pas dans une image, où la couche reste lisible même effacée.", `    ssl_certificate     ${tls.certPath};`, `    ssl_certificate_key ${tls.keyPath};`, "    ssl_protocols TLSv1.2 TLSv1.3;", "    ssl_session_cache shared:SSL:10m;", "    ssl_session_timeout 1h;", "", "    error_page 497 =301 https://$http_host$request_uri;");
-	else lines.push(`    listen ${intro.listen};`, `    server_name ${serverNames(intro.domains)};`);
+	else {
+		lines.push(`    listen ${intro.listen};`);
+		if (grpc) lines.push("    http2 on;");
+		lines.push(`    server_name ${serverNames(intro.domains)};`);
+	}
+	if (grpc) lines.push(...nginxGrpcRelay(idleSeconds));
 	if (intro.reencrypt) lines.push("    # Re-encrypt : valider le cert backend (cf docker/certs).", "    # proxy_ssl_trusted_certificate /etc/nginx/certs/ca.pem;", "    # proxy_ssl_verify on; proxy_ssl_name nodefony.com;");
 	for (const m of intro.mounts) {
 		const prefix = ensureTrailingSlash(m.prefix);
@@ -125,7 +201,7 @@ 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 h2cPort = upstreamH2cPort(intro);
 	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;
@@ -152,6 +228,12 @@ defaults
   # \`timeout server\` ne s'applique plus au tunnel. Sans cette ligne, la valeur
   # implicite coupe des sockets que le heartbeat gardait pourtant vivantes.
   timeout tunnel  ${idleSeconds}s
+  # Forwarded (RFC 7239) posé par haproxy lui-même (>= 2.8) : il met entre
+  # guillemets ce qui n'est pas un jeton — une IPv6 (\`for="[2001:db8::1]"\`),
+  # un \`host\` qui porte un port. Un \`set-header\` écrit à la main laissait
+  # \`for=2001:db8::1\`, valeur invalide (§6). \`proto\` suit \`ssl_fc\` : le
+  # scheme vu par le CLIENT. Vaut pour tous les backends.
+  option forwarded proto host for
 
 frontend fe_nodefony
   bind *:${intro.listen}
@@ -173,8 +255,6 @@ frontend fe_nodefony
   http-request set-header X-Forwarded-Proto http  unless { ssl_fc }
   http-request set-header X-Forwarded-Host  %[req.hdr(host)]
   http-request set-header X-Real-IP         %[src]
-  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 }
 
 ${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
@@ -189,4 +269,4 @@ function firstDomain(intro) {
 function ensureTrailingSlash(dir) {
 	return dir.endsWith("/") ? dir : `${dir}/`;
 }
-export { defaultIntrospection, generateHaproxyConfig, generateNginxConfig };
+export { defaultIntrospection, generateHaproxyConfig, generateNginxConfig, upstreamH2cPort };