@nodefony/http 10.0.0-beta.6 → 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/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

@@ -597,4 +597,4 @@ function forwardUpgrade(req, socket, head, mount, target, from, relay) {
 	});
 	upstream.end();
 }
-export { MAX_VIA_HOPS, bodyFramingOf, forwardRequest, forwardUpgrade, rawHead, receivedMaxForwards, refuseMalformedHandshake, 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;
@@ -193,4 +269,4 @@ function firstDomain(intro) {
 function ensureTrailingSlash(dir) {
 	return dir.endsWith("/") ? dir : `${dir}/`;
 }
-export { defaultIntrospection, generateHaproxyConfig, generateNginxConfig };
+export { defaultIntrospection, generateHaproxyConfig, generateNginxConfig, upstreamH2cPort };

package/dist/nodefony/src/servers/http2Goaway.js

@@ -0,0 +1,76 @@
+import { constants } from "node:http2";
+// nodefony/src/servers/http2Goaway.ts
+/** Plus long délai d'annonce (ms) : un pair qui ne répond pas au PING ne retient pas la fermeture. */
+const ANNOUNCE_CAP_MS = 1e3;
+/** Dernier identifiant de flux possible (RFC 9113 §6.8) : « aucun flux n'est encore écarté ». */
+const LAST_POSSIBLE_STREAM = 2 ** 31 - 1;
+/**
+* Annonce à UNE session HTTP/2 qu'elle va fermer, SANS écarter un flux déjà en route.
+*
+* Un PING mesure l'aller-retour, puis GOAWAY à `2^31-1`, puis l'attente de cet
+* aller-retour : après elle, tout flux ouvert par le client avant l'annonce est
+* arrivé, et le GOAWAY définitif (`session.close()`, dernier flux traité) peut
+* suivre. RFC 9113 §6.8 : « SHOULD send an initial GOAWAY frame with the last
+* stream identifier set to 2^31-1 […] After allowing time for any in-flight
+* stream creation (at least one round-trip time) ». Sans annonce, un flux croisé
+* avec le GOAWAY est refusé alors qu'il aurait pu être servi.
+*
+* L'aller-retour se MESURE avant l'annonce : après un GOAWAY, un client Node ne
+* répond plus aux PING (constaté sur Node 26.13).
+*
+* @param session - la session à annoncer, ni fermée ni détruite
+* @param settle - appelé UNE fois : après l'attente, à la fermeture de la
+*   session, ou aussitôt si le PING ne part pas. Un pair muet ne l'appelle
+*   jamais — le délai maximal appartient à l'appelant.
+*/
+function announceSessionClose(session, settle) {
+	let settled = false;
+	let wait = null;
+	const done = () => {
+		if (settled) return;
+		settled = true;
+		if (wait !== null) clearTimeout(wait);
+		session.removeListener("close", done);
+		settle();
+	};
+	session.once("close", done);
+	if (!session.ping((error, rttMs) => {
+		if (error !== null || settled || session.closed) return done();
+		session.goaway(constants.NGHTTP2_NO_ERROR, LAST_POSSIBLE_STREAM);
+		wait = setTimeout(done, Math.max(1, Math.ceil(rttMs)));
+	})) {
+		session.goaway(constants.NGHTTP2_NO_ERROR, LAST_POSSIBLE_STREAM);
+		done();
+	}
+}
+/**
+* Ferme EN DOUCEUR une session HTTP/2 restée inactive au-delà du délai du serveur.
+*
+* RFC 9113 §9.1 : un serveur est « permitted to terminate idle connections »,
+* et « SHOULD first send a GOAWAY ». La fermeture suit l'annonce en deux temps
+* ({@link announceSessionClose}), puis `session.close()` : aucun nouveau flux,
+* mais les flux en cours vont à leur terme — un flux long et muet (abonnement
+* gRPC) n'est pas coupé, seuls les NOUVEAUX flux repartent sur une autre
+* connexion, ce que tout client HTTP/2 fait sur GOAWAY.
+*
+* Le délai de la session est désarmé d'abord : Node (26.13) marque une session
+* détruite AVANT de désarmer son minuteur, qui la retiendrait alors jusqu'à son
+* échéance (nodejs/node#66885).
+*
+* @param session - la session inactive
+* @param capMs - délai maximal d'attente de l'écho du PING (ms)
+*/
+function closeIdleSession(session, capMs = ANNOUNCE_CAP_MS) {
+	if (session.closed || session.destroyed) return;
+	session.setTimeout(0);
+	let finished = false;
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		clearTimeout(timer);
+		if (!session.closed && !session.destroyed) session.close();
+	};
+	const timer = setTimeout(finish, capMs);
+	announceSessionClose(session, finish);
+}
+export { ANNOUNCE_CAP_MS, announceSessionClose, closeIdleSession };

package/dist/nodefony/src/servers/http2Limits.js

@@ -1,3 +1,4 @@
+import { closeIdleSession } from "./http2Goaway.js";
 // nodefony/src/servers/http2Limits.ts
 /**
 * Limites anti-DoS d'un serveur HTTP/2, lues dans la section `http2` du module :
@@ -18,29 +19,54 @@ function http2ServerLimits(limits) {
 	return options;
 }
 /**
-* Borne l'inactivité des sessions d'un serveur HTTP/2 — TLS (5152) comme h2c —
-* et contourne un défaut de Node qui garde chaque session fermée en vie jusqu'à
-* l'échéance de ce délai.
+* Une session HTTP/2, et non une socket HTTP/1.1 : sur 5152 (`allowHTTP1`),
+* l'événement `timeout` du serveur reçoit les deux. `node:http2` n'exporte pas
+* la classe de session — elle se reconnaît à sa capacité (`goaway`).
+*/
+function isHttp2Session(target) {
+	return typeof target === "object" && target !== null && "goaway" in target;
+}
+/**
+* Ferme les sessions d'un serveur HTTP/2 — TLS (5152) comme h2c — restées
+* inactives au-delà de `timeoutMs`, et contourne un défaut de Node qui garde
+* chaque session fermée en vie jusqu'à l'échéance de ce délai.
 *
-* Le défaut (Node 24, 26) : `closeSession` (`internal/http2/core`) marque la
-* session détruite PUIS appelle `session.setTimeout(0)` ; or `setStreamTimeout`
-* sort aussitôt sur un objet détruit. Le minuteur n'est jamais désarmé et retient
-* la session (~2,4 Ko) pendant `timeoutMs` : sous un flux de connexions neuves,
-* connexions/s × délai × 2,4 Ko. Signalé à Node : https://github.com/nodejs/node/issues/66885
+* **La fermeture est À NOUS.** Node arme chaque session par
+* `session.setTimeout(server.timeout, sessionOnTimeout)` — un écouteur `once` —
+* et `sessionOnTimeout` ne détruit la session que si le serveur n'a AUCUN
+* écouteur `timeout` ; s'il en a un, il lui passe la main, UNE fois par session
+* (`internal/http2/core`, Node 26.13). Le serveur 5152 en a toujours un
+* (`routeSocketTimeout`, pour ses sockets HTTP/1.1), et ce délai doit prévenir
+* l'application (`onTimeout`) : sans fermeture ici, une session inactive vivait
+* jusqu'à ce que le CLIENT la ferme (#763). À l'échéance, la session est fermée
+* en douceur — GOAWAY annoncé puis définitif, les flux en cours vont à leur
+* terme ({@link closeIdleSession}, RFC 9113 §9.1 et §6.8).
 *
-* Le contournement : désarmer à la réception du GOAWAY, AVANT la destruction —
-* c'est ainsi que ferment un proxy et un client Node, même par `destroy()`. Rien
-* n'est retiré à la protection : Node n'agit déjà plus à l'échéance sur une
-* session fermée (`sessionOnTimeout` sort sur `closed`). Une coupure TCP sans
-* GOAWAY garde la rétention, bornée au délai.
+* **Le contournement** (Node 24, 26) : `closeSession` marque la session détruite
+* PUIS appelle `session.setTimeout(0)`, qui sort aussitôt sur un objet détruit ;
+* le minuteur retient alors la session (~2,4 Ko) pendant `timeoutMs`. Il est
+* désarmé à la réception du GOAWAY, AVANT la destruction — c'est ainsi que
+* ferment un proxy et un client Node, même par `destroy()` ; et
+* `closeIdleSession` le désarme avant de fermer. Signalé à Node :
+* https://github.com/nodejs/node/issues/66885 (corrigé par nodejs/node#66886,
+* absent de la 26.13). Une coupure TCP sans GOAWAY garde la rétention, bornée
+* au délai.
+*
+* Coût par requête : nul — un écouteur par serveur, et la fermeture n'agit qu'à
+* l'échéance.
 *
 * @param server - le serveur HTTP/2.
 * @param timeoutMs - délai d'inactivité ; 0 ou absent le laisse désactivé.
-* @param onTimeout - appelé à l'échéance (événement `timeout` du serveur).
+* @param onTimeout - appelé à l'échéance d'une session (événement `timeout` du
+*   serveur), après le début de sa fermeture.
 */
 function setHttp2SessionTimeout(server, timeoutMs, onTimeout) {
 	if (!timeoutMs) return;
-	server.setTimeout(timeoutMs, onTimeout);
+	server.setTimeout(timeoutMs, (target) => {
+		if (!isHttp2Session(target)) return;
+		closeIdleSession(target);
+		onTimeout();
+	});
 	server.on("session", (session) => {
 		session.once("goaway", () => {
 			session.setTimeout(0);