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

package/dist/nodefony/service/error-renderer.js

@@ -1,4 +1,4 @@
-import HttpError from "../src/errors/httpError.js";
+import HttpError, { serializeHttpError } from "../src/errors/httpError.js";
 import { toWsCloseCode } from "../src/context/websocket/WebsocketContext.js";
 import { Nodefony, nodefonyError } from "nodefony";
 // nodefony/service/error-renderer.ts
@@ -49,17 +49,23 @@ const UNIQUE_VIOLATION_MESSAGE = "Conflict — a resource with these unique valu
 */
 const OPAQUE_SERVER_ERROR = "Internal Server Error";
 /**
+* Le message rendu au client : celui de l'erreur, sauf une panne 5xx en
+* production, qui devient opaque. Un 4xx garde le sien — c'est un message
+* écrit POUR le client (validation, refus de politique), pas une fuite.
+*/
+const clientMessage = (status, message, production) => production && status >= 500 ? OPAQUE_SERVER_ERROR : message;
+/**
 * Clés d'un `HttpError` sérialisé qui décrivent les ENTRAILLES du serveur et ne
 * doivent jamais franchir la frontière en production.
 */
-const INTERNAL_ERROR_KEYS = [
+const INTERNAL_ERROR_KEYS = /* @__PURE__ */ new Set([
 	"stack",
 	"controller",
 	"action",
 	"bundle",
 	"url",
 	"pdu"
-];
+]);
 /**
 * Vrai si le runtime tourne en production — le détail des erreurs reste alors au
 * journal, seul le serveur le voit.
@@ -208,10 +214,11 @@ const PG_INVALID_INPUT = /^invalid input syntax for type (\w+): "(.*)"$/su;
 /**
 * Reconnaît un identifiant MAL FORMÉ refusé par la base, et rend la valeur fautive.
 *
-* Deux moteurs le disent : MongoDB par une `CastError` de Mongoose (la clé est
-* un ObjectId), PostgreSQL par `22P02` (la clé est un `uuid` ou un entier).
-* SQLite et MySQL rangent la clé en texte : ils ne lèvent rien, la lecture rend
-* simplement « rien », d'où leur 404 — c'est la cohérence avec eux qui est visée.
+* Trois sources le disent : MongoDB par une `CastError` de Mongoose (la clé est
+* un ObjectId), PostgreSQL par `22P02` (la clé est un `uuid` ou un entier), et
+* le kit de colonnes portable par une `ColumnValueError` de genre `uuid` ou
+* `integer` — il refuse sur les trois moteurs la clé que PostgreSQL refuserait. Une clé rangée en
+* texte NATIF ne lève rien, la lecture rend « rien » : le même 404.
 *
 * Même descente dans `cause` que {@link isUniqueViolation} (Drizzle enveloppe).
 *
@@ -223,6 +230,7 @@ function malformedIdentifierOf(error) {
 	for (let depth = 0; depth < 5 && current instanceof Error; depth += 1) {
 		const candidate = current;
 		if (candidate.name === "CastError" && (candidate.kind === "ObjectId" || candidate.kind === "UUID") && (typeof candidate.value === "string" || typeof candidate.value === "number")) return String(candidate.value);
+		if (candidate.name === "ColumnValueError" && (candidate.kind === "uuid" || candidate.kind === "integer") && typeof candidate.value === "string") return candidate.value;
 		if (String(candidate.code) === "22P02") {
 			const match = PG_INVALID_INPUT.exec(candidate.message);
 			if (match) {
@@ -374,12 +382,10 @@ var DefaultErrorRenderer = class {
 		const status = this.normalizeHttpStatus(httpError.code);
 		httpError.code = status;
 		const obj = context.metaData;
-		const serialized = httpError.toJSON();
-		const message = isProduction() && status >= 500 ? OPAQUE_SERVER_ERROR : httpError.message;
-		if (isProduction()) {
-			for (const key of INTERNAL_ERROR_KEYS) delete serialized[key];
-			serialized.message = message;
-		}
+		const production = isProduction();
+		const serialized = serializeHttpError(httpError, production ? INTERNAL_ERROR_KEYS : null);
+		const message = clientMessage(status, httpError.message, production);
+		if (production) serialized.message = message;
 		obj.error = serialized;
 		obj.code = status;
 		obj.message = message;
@@ -403,6 +409,34 @@ var DefaultErrorRenderer = class {
 			reason
 		};
 	}
+	/**
+	* Le statut HTTP et le message client qu'une route HTTP rendrait pour cette
+	* erreur — mêmes classements que {@link renderHttp} (validation 422, conflit
+	* 409, identifiant malformé, code numérique) et même opacité d'un 5xx en
+	* production —, sans RIEN écrire : ni statut sur la réponse, ni `metaData`,
+	* ni pile formatée. Sert les transports sans corps d'erreur : un appel gRPC
+	* traduit ce statut en code (ADR-0026 D7).
+	*
+	* Un identifiant malformé y vaut 400 : sans contexte, aucun chemin ne le
+	* désigne.
+	*
+	* @param error - l'erreur levée.
+	* @returns son statut émettable et le message destiné au client.
+	*
+	* @experimental Surface gRPC, ADR-0026 D11.
+	*/
+	describe(error) {
+		const httpError = this.toHttpError(error, void 0);
+		const status = this.normalizeHttpStatus(httpError.code);
+		return {
+			status,
+			message: clientMessage(status, httpError.message, isProduction())
+		};
+	}
+	/**
+	* Ramène une erreur à une `HttpError`. Sans contexte (`describe`), rien
+	* n'est écrit : `HttpError` ne pose le statut sur la réponse qu'avec lui.
+	*/
 	toHttpError(error, context) {
 		if (error instanceof HttpError) return error;
 		const fields = toValidationFields(error);

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

@@ -1,34 +1,44 @@
-import { isProfiledUrl } from "../src/profiler/aggregate.js";
 import HttpError from "../src/errors/httpError.js";
+import { isUnsupportedTransferCoding } from "../src/proxy/rules.js";
+import { hasConflictingAuthority } from "../src/context/transport.js";
+import { grpcWireOf, hasGrpcRoutes, prepareGrpcRefusal } from "../src/grpc/refusal.js";
 import { buildTrustProxy } from "../src/context/trustProxy.js";
 import { resolveForwarded } from "../src/context/forwarded.js";
 import { MemoryRateLimitStore } from "../src/rateLimit/MemoryRateLimitStore.js";
 import { WsConnectionCounter } from "../src/rateLimit/WsConnectionCounter.js";
 import { compileDomainPatterns, compileTrustedHosts, isDomainAllowed } from "../src/context/domainMatcher.js";
+import { isProfiledUrl } from "../src/profiler/aggregate.js";
 import { responseEnded } from "../src/context/responseEnded.js";
 import { unsentResponseWarning } from "../src/context/unsentResponse.js";
 import { closeRequestTrace, hasRequestTraceSubscribers, openRequestTrace, runTraced } from "../src/context/requestTrace.js";
-import { parseWebsocketUrl } from "../src/context/websocket/websocketUrl.js";
+import { SHUTDOWN_STREAMS_WAIT_MS, ShutdownRegistry, StallSweep } from "../src/context/http/StreamLifecycle.js";
 import WebsocketContext, { toHandshakeStatus } from "../src/context/websocket/WebsocketContext.js";
+import { ReceiveDeadline } from "../src/servers/receiveDeadline.js";
 import { trackPong } from "./servers/wsHeartbeat.js";
+import { parseWebsocketUrl } from "../src/context/websocket/websocketUrl.js";
 import HttpContext from "../src/context/http/HttpContext.js";
 import DefaultErrorRenderer from "./error-renderer.js";
-import JsonAuditLogger from "./audit-logger.js";
 import DefaultRequestLogger from "./request-logger.js";
 import PrettyRequestLogger from "./pretty-request-logger.js";
+import JsonAuditLogger from "./audit-logger.js";
 import { resolveTraceparent } from "./trace.js";
 import { asServersConfig, configuredServerPort } from "../src/servers/kernelServers.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.155.0/helpers/esm/decorate.js";
-import { GcScheduler, IDENTITY_CHANGED_EVENT, RequestContext, RevocationWatch, Service, finallyMaybe, injectable, isPromise, logColor, nodefonyError, servedUrl, thenMaybe, writeRuntimeState } from "nodefony";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
+import { BootConfigurationError, GcScheduler, IDENTITY_CHANGED_EVENT, RequestContext, RevocationWatch, Service, finallyMaybe, injectable, isPromise, logColor, nodefonyError, servedUrl, thenMaybe, writeRuntimeState } from "nodefony";
 import cluster from "node:cluster";
 import http from "node:http";
 // nodefony/service/http-kernel.ts
-const HEALTH_HEADERS = {
-	"content-type": "application/json",
-	"cache-control": "no-store"
-};
+const HEALTH_HEADERS = [
+	"content-type",
+	"application/json",
+	"cache-control",
+	"no-store"
+];
 const HEALTH_BODY_OK = "{\"status\":\"ok\"}";
 const HEALTH_BODY_UNREADY = "{\"status\":\"unready\"}";
+/** Corps du 429 du limiteur de débit — figé, rien à sérialiser par refus. */
+const TOO_MANY_REQUESTS_BODY = "{\"code\":429,\"message\":\"Too Many Requests\"}";
+const TOO_MANY_REQUESTS_LENGTH = Buffer.byteLength(TOO_MANY_REQUESTS_BODY);
 const perfProbe = process.env.NF_PERF_PROBE === "1" ? {
 	count: 0,
 	enterScopeNs: 0,
@@ -104,9 +114,33 @@ let HttpKernel = class HttpKernel extends Service {
 	}
 	responseTimeout;
 	closeTimeOutWs;
+	/**
+	* Échéance de réception du corps HTTP/2, par serveur (`requestTimeout` de sa
+	* section) : `node:http2` ne borne pas la réception, HTTP/1.1 l'est par Node.
+	* `undefined` tant qu'aucun corps HTTP/2 n'a été lu, `null` si le délai est
+	* désactivé (0). Cf {@link ReceiveDeadline}.
+	*/
+	#h2Receive = {
+		http: void 0,
+		https: void 0
+	};
 	secContentTypeOptions = null;
 	secFrameOptions = null;
 	secHsts = null;
+	/**
+	* En-têtes du transport, tableau plat `[nom, valeur, …]` aux noms en
+	* minuscules, par famille de serveur (HSTS sur TLS seulement). Figés et
+	* VALIDÉS au calcul : chaque réponse les recopie sans les revalider.
+	*/
+	#transportHeaders = {
+		http: [],
+		https: []
+	};
+	/** Réponse d'une sonde de santé : le transport, puis type et cache. */
+	#healthHeaders = {
+		http: [],
+		https: []
+	};
 	sessionService;
 	router;
 	firewall;
@@ -121,9 +155,11 @@ let HttpKernel = class HttpKernel extends Service {
 	rateLimitGc = null;
 	#wsConnCounter = null;
 	#streams = null;
+	#stallSweep = null;
+	#openStreams = null;
 	#healthPaths = null;
 	#healthShutdownDelay = 0;
-	#terminating = false;
+	#shutdownSteps = null;
 	constructor(module) {
 		super(serviceName, module.container, module.notificationsCenter, module.options);
 		this.module = module;
@@ -157,12 +193,49 @@ let HttpKernel = class HttpKernel extends Service {
 			if (hsts.preload) v += "; preload";
 			this.secHsts = v;
 		} else this.secHsts = null;
+		const headerServer = this.options.headerServer;
+		const http1 = [];
+		if (headerServer != null && headerServer !== "") http1.push("server", headerServer);
+		if (this.secContentTypeOptions !== null) http1.push("x-content-type-options", this.secContentTypeOptions);
+		if (this.secFrameOptions !== null) http1.push("x-frame-options", this.secFrameOptions);
+		const tls = this.secHsts === null ? http1 : [
+			...http1,
+			"strict-transport-security",
+			this.secHsts
+		];
+		for (let i = 0; i + 1 < tls.length; i += 2) {
+			const name = tls[i] ?? "";
+			try {
+				http.validateHeaderValue(name, tls[i + 1] ?? "");
+			} catch (error) {
+				throw new BootConfigurationError(`[@nodefony/http] en-tête « ${name} » refusé : ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		this.#transportHeaders = {
+			http: http1,
+			https: tls
+		};
+		this.#healthHeaders = {
+			http: [...http1, ...HEALTH_HEADERS],
+			https: [...tls, ...HEALTH_HEADERS]
+		};
+	}
+	/**
+	* En-têtes du transport d'une réponse, figés au démarrage — ce que
+	* `HttpResponse` place en tête de sa réserve.
+	*
+	* @param type - famille du serveur qui a reçu la requête.
+	* @returns la liste plate `[nom, valeur, …]`, noms en minuscules.
+	*/
+	transportHeaders(type) {
+		return type === "https" ? this.#transportHeaders.https : this.#transportHeaders.http;
 	}
 	/**
 	* Ce que ce kernel ÉMET réellement comme en-têtes de sécurité transport.
 	*
 	* Ces trois en-têtes (HSTS, X-Frame-Options, X-Content-Type-Options) sont posés
-	* ici, à l'entrée brute, pour couvrir aussi les statiques et les pages d'erreur
+	* par `@nodefony/http` sur TOUTE réponse (en tête de la réserve de `HttpResponse`),
+	* statiques et pages d'erreur comprises
 	* — pas par `@nodefony/security`, dont les clés homonymes sont inertes. Toute
 	* console d'administration doit donc lire CE point, sinon elle affiche une
 	* intention de configuration au lieu de l'état appliqué.
@@ -189,6 +262,7 @@ let HttpKernel = class HttpKernel extends Service {
 	*/
 	onConfigChanged() {
 		this.computeSecurityHeaderCaches();
+		this.firewall?.onTransportHeadersChanged?.();
 		this._trustProxyChecker = null;
 		this._wsOriginPolicy = Object.create(null);
 		this.trustedHosts = this.options.trustedHosts;
@@ -233,7 +307,7 @@ let HttpKernel = class HttpKernel extends Service {
 	* Le message nomme l'action, ce qu'elle a rendu et le geste qui convient
 	* (`unsentResponseWarning`).
 	*
-	* Appelé au timeout, AVANT que le 504/408 parte — après, `sended` est vrai et
+	* Appelé au timeout, AVANT que le 503 parte — après, `sended` est vrai et
 	* plus rien ne se signalerait — et au démontage, pour un client parti avant.
 	* Gratuit en production : rien n'est lu au-delà de `waitAsync`.
 	*
@@ -296,9 +370,9 @@ let HttpKernel = class HttpKernel extends Service {
 	* @param response - réponse serveur brute (HTTP/1 ou H2 compat)
 	* @param ok - `true` → 200, `false` → 503 (readiness pendant boot/shutdown)
 	*/
-	#respondHealth(response, ok) {
+	#respondHealth(response, ok, type) {
 		const res = response;
-		res.writeHead(ok ? 200 : 503, HEALTH_HEADERS);
+		res.writeHead(ok ? 200 : 503, type === "https" ? this.#healthHeaders.https : this.#healthHeaders.http);
 		res.end(ok ? HEALTH_BODY_OK : HEALTH_BODY_UNREADY);
 	}
 	async init() {
@@ -320,13 +394,10 @@ let HttpKernel = class HttpKernel extends Service {
 		});
 		this.once("onTerminate", () => {
 			this.rateLimitGc?.stop();
+			this.#h2Receive.http?.close();
+			this.#h2Receive.https?.close();
 		});
-		this.kernel?.once("onPostReady", () => {
-			this.kernel?.prependOnceListener("onTerminate", async () => {
-				this.#terminating = true;
-				if (this.#healthShutdownDelay > 0) await new Promise((r) => setTimeout(r, this.#healthShutdownDelay));
-			});
-		});
+		this.kernel?.once("onDrain", () => this.drainTraffic());
 		this.kernel?.prependOnceListener("onBoot", () => {
 			this.router = this.get("router");
 			this.firewall = this.get("firewall");
@@ -419,7 +490,7 @@ let HttpKernel = class HttpKernel extends Service {
 		const secure = context.serverType === "wss";
 		const raw = context.origin;
 		if (this.isWebsocketOriginAllowed(raw, context.domain, secure)) return;
-		const error = new HttpError(`WebSocket Origin "${raw}" not allowed (CSWSH protection)`, 1008, context);
+		const error = HttpError.withoutStack(`WebSocket Origin "${raw}" not allowed (CSWSH protection)`, 1008, context);
 		error.type = "origin";
 		throw error;
 	}
@@ -523,7 +594,7 @@ let HttpKernel = class HttpKernel extends Service {
 			}
 			throw resolver.exception;
 		}
-		throw new HttpError("Not Found", 404, context);
+		throw HttpError.withoutStack("Not Found", 404, context);
 	}
 	/**
 	* {@link prepareFrontController} + instanciation immédiate du controller
@@ -608,10 +679,14 @@ let HttpKernel = class HttpKernel extends Service {
 			if (!context.response.isHeaderSent()) {
 				if (context.isRedirect) {
 					context.isRedirect = false;
-					context.response.response?.removeHeader("Location");
+					context.response.removeHeader("Location");
 				}
+				context.response.closeUnfinishedRequest();
+				const headers = context.request.headers;
+				const wire = grpcWireOf(headers, context.method === "GET" && context.request.url.searchParams.get("connect") === "v1");
 				try {
-					await context.render(result.body);
+					if (wire === 0) await context.render(result.body);
+					else await context.send(prepareGrpcRefusal(context.response, wire, result.status, context.authenticatedUser() !== null, headers["content-type"]));
 				} catch (e) {
 					this.log(e, "CRITIC");
 					throw e;
@@ -678,19 +753,14 @@ let HttpKernel = class HttpKernel extends Service {
 	*   pipeline.
 	*/
 	dispatchHttpRequest(request, response, type) {
-		const headerServer = this.options.headerServer;
-		if (headerServer != null && headerServer !== "") response.setHeader("Server", headerServer);
-		if (this.secContentTypeOptions !== null) response.setHeader("X-Content-Type-Options", this.secContentTypeOptions);
-		if (this.secFrameOptions !== null) response.setHeader("X-Frame-Options", this.secFrameOptions);
-		if (this.secHsts !== null && type === "https") response.setHeader("Strict-Transport-Security", this.secHsts);
 		if (this.#healthPaths !== null) {
 			const url = request.url;
 			if (url === this.#healthPaths.liveness) {
-				this.#respondHealth(response, true);
+				this.#respondHealth(response, true, type);
 				return;
 			}
 			if (url === this.#healthPaths.readiness) {
-				this.#respondHealth(response, !this.#terminating && this.kernel?.servable === true);
+				this.#respondHealth(response, this.kernel?.isTerminating !== true && this.kernel?.servable === true, type);
 				return;
 			}
 		}
@@ -704,13 +774,19 @@ let HttpKernel = class HttpKernel extends Service {
 				if (verdict.limited) {
 					response.setHeader("Retry-After", verdict.retryAfterS);
 					const res = response;
-					res.writeHead(429);
-					res.end();
+					response.setHeader("Content-Type", "application/json; charset=utf-8");
+					response.setHeader("Content-Length", TOO_MANY_REQUESTS_LENGTH);
+					res.writeHead(429, type === "https" ? this.#transportHeaders.https : this.#transportHeaders.http);
+					res.end(TOO_MANY_REQUESTS_BODY);
 					return;
 				}
 			}
 		}
-		if (this.listenerCount("onServerRequest")) return this.fireAsync("onServerRequest", request, response, type).then(() => this.handle(request, response, type));
+		if (this.listenerCount("onServerRequest")) {
+			const transport = type === "https" ? this.#transportHeaders.https : this.#transportHeaders.http;
+			for (let i = 0; i + 1 < transport.length; i += 2) response.setHeader(transport[i] ?? "", transport[i + 1] ?? "");
+			return this.fireAsync("onServerRequest", request, response, type).then(() => this.handle(request, response, type));
+		}
 		return this.handle(request, response, type);
 	}
 	async initServers() {
@@ -850,13 +926,29 @@ let HttpKernel = class HttpKernel extends Service {
 	* @returns `undefined` quand le démontage est terminé ; sinon la promesse de
 	*   sa fin, qui ne rejette pas.
 	*/
+	/**
+	* Fixe le code d'un appel RPC au `close` : « réponse finie » est la règle
+	* unique du noyau ({@link responseEnded}, celle du 499), jamais
+	* `writableFinished`, qui dit « finie » sur une annulation HTTP/2. Une cause
+	* rendue par l'appel devient l'erreur de la requête : la ligne d'accès la
+	* porte, le canal la publie — une ligne par appel en erreur (D10 point 3).
+	*
+	* @param context - le contexte de la requête.
+	* @param rpc - son appel RPC.
+	*/
+	settleRpc(context, rpc) {
+		const raw = context.response.response;
+		const cause = rpc.settle(raw !== null && responseEnded(raw));
+		if (cause !== null && !context.error) context.error = cause;
+	}
 	teardownHttp(context, scope) {
 		if (context.finished) return void 0;
 		try {
 			context.stopClock();
 			if (context.waitAsync) this.warnUnsentResponse(context);
+			if (context.rpc !== null) this.settleRpc(context, context.rpc);
 			context.logRequest();
-			if (context.requestTrace !== null) closeRequestTrace(context, context.response.statusCode, context.error);
+			if (context.requestTrace !== null) closeRequestTrace(context, context.response.statusCode, context.error, context.rpc);
 			context.logPhasesVerbose();
 			if (this.shouldProfile(context.url)) this.profiler?.collect(context);
 			const afterResponse = context._runAfterResponse();
@@ -946,7 +1038,7 @@ let HttpKernel = class HttpKernel extends Service {
 			if (!isPromise(served)) return served;
 			return served.catch((e) => this.failHttp(e, created, scope));
 		} catch (e) {
-			return this.failHttp(e, context, scope);
+			return this.failHttp(e, context, scope, response);
 		}
 	}
 	/**
@@ -986,9 +1078,19 @@ let HttpKernel = class HttpKernel extends Service {
 	/**
 	* Chemin d'erreur de {@link handleHttp} : libère le scope d'un contexte qui
 	* n'a pas pu se construire, puis rend l'erreur au client (`onError`).
+	*
+	* Sans contexte, `onError` n'a rien sur quoi écrire : la réponse BRUTE
+	* reçoit alors un 500 nu. Sinon HTTP/1.1 coupait la connexion sans un octet
+	* et HTTP/2 laissait le flux pendu.
 	*/
-	failHttp(e, context, scope) {
-		if (context === null) this.container?.leaveScope(scope);
+	failHttp(e, context, scope, response) {
+		if (context === null) {
+			this.container?.leaveScope(scope);
+			if (response && !response.headersSent) {
+				response.statusCode = 500;
+				response.end();
+			}
+		}
 		return this.onError(e, context);
 	}
 	/**
@@ -1020,6 +1122,7 @@ let HttpKernel = class HttpKernel extends Service {
 	*/
 	routeHttpRequest(httpContext, request, response) {
 		if (this.reverseProxy !== null && this.reverseProxy.mounts !== null && (httpContext.validDomain || !this.domainCheck)) {
+			if (this.reverseProxy.match(request.url) !== void 0) httpContext.response.commitHeaders();
 			const relayed = this.reverseProxy.forward(request, response, httpContext.scheme);
 			if (relayed !== void 0) {
 				httpContext.relayAccessLog = this.reverseProxy.match(request.url)?.accessLog ?? "all";
@@ -1029,21 +1132,64 @@ let HttpKernel = class HttpKernel extends Service {
 		httpContext.phaseStart("resolve");
 		httpContext.resolver = this.router ? this.router.resolve(httpContext) : null;
 		httpContext.phaseEnd("resolve");
-		this.firewall?.applySecurityHeaders(httpContext);
+		if (this.firewall) httpContext.response.headerPolicy = this.firewall;
 		if (this.serverStatic && httpContext.resolver?.resolve !== true && !httpContext.resolver?.exception && (asServersConfig(this.kernel?.options.servers)?.statics || this.kernel?.options.statics || this.serverStatic.hasMounts())) {
-			response.removeHeader("Content-Type");
-			return this.serverStatic.handle(request, response).catch(() => void 0).then(() => this.serveHttpRequest(httpContext));
+			httpContext.response.removeHeader("Content-Type");
+			httpContext.response.commitBeforeNativeWrite();
+			return this.serverStatic.handle(request, response).catch(() => void 0).then(() => {
+				httpContext.response.disarmNativeWrite();
+				return this.serveHttpRequest(httpContext);
+			});
 		}
 		return this.serveHttpRequest(httpContext);
 	}
 	/**
+	* L'échéance de réception HTTP/2 du serveur qui sert (`requestTimeout` de sa
+	* section), créée au premier corps HTTP/2 lu ; `null` si le délai vaut 0.
+	*
+	* À l'échéance, la réception en cours est interrompue (`abortBody`) et la
+	* requête rendue en 408 par le chemin d'erreur habituel — comme un corps qui
+	* dépasse sa limite (413).
+	*/
+	http2ReceiveDeadline(serverType) {
+		const key = serverType === "https" ? "https" : "http";
+		let deadline = this.#h2Receive[key];
+		if (deadline === void 0) {
+			const timeoutMs = this.options[key].requestTimeout;
+			deadline = timeoutMs > 0 ? new ReceiveDeadline(timeoutMs, (context) => {
+				if (context.finished) return;
+				context.request.abortBody(HttpError.withoutStack("Request Timeout", 408, context));
+			}) : null;
+			this.#h2Receive[key] = deadline;
+		}
+		return deadline;
+	}
+	/**
 	* Le corps — lu seulement s'il y en a un à lire —, puis les gardes
 	* ({@link onRequestEnd}) et l'action. Chacun n'est attendu que s'il attend.
 	*/
 	serveHttpRequest(httpContext) {
-		const streamBody = httpContext.resolver?.resolve === true && httpContext.resolver.route?.bodyStream === true;
+		const headers = httpContext.request.headers;
+		if (isUnsupportedTransferCoding(headers["transfer-encoding"])) return Promise.reject(HttpError.withoutStack("Transfer-Encoding not implemented", 501, httpContext));
+		if (hasConflictingAuthority(headers)) return Promise.reject(HttpError.withoutStack("Host differs from :authority", 400, httpContext));
+		const resolver = httpContext.resolver;
+		if (hasGrpcRoutes() && resolver?.resolve === true && httpContext.method === "POST" && resolver.route?.grpc !== true && grpcWireOf(headers) === 1) resolver.resolve = false;
+		const skipBody = !(resolver?.resolve === true) || resolver.route?.bodyStream === true;
 		httpContext.phaseStart("parse");
-		const parsed = finallyMaybe(() => streamBody ? void 0 : httpContext.request.initialize(), () => httpContext.phaseEnd("parse"));
+		let receiving = null;
+		let receivingSeq = 0;
+		const parsed = finallyMaybe(() => {
+			if (skipBody) return void 0;
+			const pending = httpContext.request.initialize();
+			if (pending !== void 0 && (httpContext.alpnProtocol === "h2" || httpContext.alpnProtocol === "h2c")) {
+				receiving = this.http2ReceiveDeadline(httpContext.serverType);
+				if (receiving !== null) receivingSeq = receiving.track(httpContext);
+			}
+			return pending;
+		}, () => {
+			httpContext.phaseEnd("parse");
+			if (receiving !== null) receiving.release(receivingSeq, httpContext);
+		});
 		return thenMaybe(parsed, () => thenMaybe(this.onRequestEnd(httpContext), (guarded) => {
 			guarded.phaseStart("action");
 			return finallyMaybe(() => guarded.handle(), () => guarded.phaseEnd("action"));
@@ -1098,8 +1244,8 @@ let HttpKernel = class HttpKernel extends Service {
 				if (this.listenerCount("afterAuth")) await this.fireAsync("afterAuth", context);
 			} catch (authError) {
 				if (context.resolver?.exception) {
-					context.response.response?.removeHeader("Upgrade");
-					context.response.response?.removeHeader("Connection");
+					context.response.removeHeader("Upgrade");
+					context.response.removeHeader("Connection");
 				}
 				await this.fireAsync("onAuthFailure", context, authError).catch((e) => this.log(e, "ERROR", "onAuthFailure"));
 				throw authError;
@@ -1424,17 +1570,17 @@ let HttpKernel = class HttpKernel extends Service {
 		return true;
 	}
 	/**
-	* Inscrit un flux SSE à identité révocable : il sera fermé dans la fenêtre de
+	* Inscrit un flux (événements ou octets) à identité révocable : il sera fermé dans la fenêtre de
 	* re-validation qui suit la mort de son identité (déconnexion, session
 	* révoquée, jeton expiré ou annulé) — le même registre et la même règle que
 	* les sockets WebSocket.
 	*
-	* @internal — appelé par le flux lui-même.
+	* @internal — appelé par le cycle de vie du flux (`StreamLifecycle`).
 	*/
 	watchStream(stream) {
 		(this.#streams ??= new RevocationWatch({
 			isValid: (entry) => entry.revalidate(),
-			revoke: (entry) => void entry.close(),
+			revoke: (entry) => void entry.revoke(),
 			identityOf: (entry) => entry.identifier ?? void 0
 		})).register(stream);
 	}
@@ -1443,7 +1589,118 @@ let HttpKernel = class HttpKernel extends Service {
 		this.#streams?.unregister(stream);
 	}
 	/**
-	* Re-valide tous les flux SSE et ferme ceux dont l'identité est morte.
+	* Inscrit au balayage de blocage un flux dont un tiers tient les écritures :
+	* un client qui ne lit plus y est coupé (`StreamLifecycle.sweepStall`).
+	*
+	* @internal — appelé par le cycle de vie du flux (`StreamLifecycle`).
+	*/
+	sweepStall(stream) {
+		(this.#stallSweep ??= new StallSweep()).add(stream);
+	}
+	/** Retire un flux du balayage de blocage (à sa fermeture). @internal */
+	unsweepStall(stream) {
+		this.#stallSweep?.delete(stream);
+	}
+	/**
+	* Inscrit un flux sans fin à lui (SSE, flux RPC, octets vivants) au registre
+	* de l'arrêt : il sera terminé AVANT le drain ({@link shutdownStreams}).
+	* Ouvert pendant l'arrêt, il l'est au tour suivant — une fois son appel RPC
+	* relié, qui ne l'est qu'après l'ouverture.
+	*
+	* @internal — appelé par le cycle de vie du flux (`StreamLifecycle`).
+	*/
+	trackStream(stream) {
+		(this.#openStreams ??= new ShutdownRegistry()).add(stream);
+	}
+	/** Retire un flux du registre de l'arrêt (à sa fermeture). @internal */
+	untrackStream(stream) {
+		this.#openStreams?.delete(stream);
+	}
+	/**
+	* Inscrit une étape de l'arrêt du trafic, appelée par {@link drainTraffic}.
+	*
+	* Un serveur s'inscrit à sa création au lieu d'écouter le noyau : l'ordre
+	* (congé des connexions longues AVANT le drain, ADR-0026 D8) vit alors dans
+	* une seule fonction, plus dans des moments d'inscription.
+	*
+	* @param step - `dismiss` : congédier les connexions longues (WebSocket
+	*   1001) ; `drain` : cesser d'accepter et laisser finir les requêtes.
+	* @param action - l'étape ; une promesse rendue est attendue.
+	*
+	* @internal
+	*/
+	addShutdownStep(step, action) {
+		this.#shutdownSteps ??= {
+			dismiss: [],
+			drain: []
+		};
+		this.#shutdownSteps[step].push(action);
+	}
+	/**
+	* L'arrêt du trafic (ADR-0027 D2), écouteur unique d'`onDrain` :
+	*
+	* 1. si le pod a été annoncé disponible, attendre `health.shutdownDelay` —
+	*    la sonde répond déjà 503 (`kernel.isTerminating`), la répartition
+	*    retire le pod ;
+	* 2. congédier ensemble les connexions longues : WebSocket (1001) et flux
+	*    longs (fin au format de leur protocole, {@link shutdownStreams}) ;
+	* 3. drainer ensemble les serveurs HTTP, HTTPS et h2c (ports distincts).
+	*
+	* Une étape qui échoue est journalisée sans arrêter les autres.
+	*
+	* @internal
+	*/
+	async drainTraffic() {
+		if (this.kernel?.postReady === true && this.#healthShutdownDelay > 0) await new Promise((r) => setTimeout(r, this.#healthShutdownDelay));
+		const steps = this.#shutdownSteps;
+		await this.#runShutdownSteps([...steps?.dismiss ?? [], () => this.shutdownStreams()]);
+		if (steps !== null) await this.#runShutdownSteps(steps.drain);
+	}
+	/** Lance des étapes d'arrêt ensemble, attend la dernière, journalise les échecs. */
+	async #runShutdownSteps(actions) {
+		const settled = await Promise.allSettled(actions.map(async (action) => action()));
+		for (const outcome of settled) if (outcome.status === "rejected") this.log(outcome.reason, "ERROR", "TERMINATE");
+	}
+	/**
+	* L'arrêt du serveur : termine chaque flux long ouvert, puis attend leur
+	* fermeture, au plus `waitMs` (ADR-0026 D8).
+	*
+	* Un appel RPC se termine au format de son protocole (gRPC : 14
+	* `UNAVAILABLE`, le client le rejoue ailleurs), un flux SSE ou d'octets
+	* vivant par une fin simple (`EventSource` se reconnecte). Un gestionnaire
+	* qui n'entend rien laisse l'attente aller à son terme : sa connexion tombe
+	* ensuite au drain, à `shutdownTimeout`.
+	*
+	* Appelé par {@link drainTraffic}, avec les fermetures 1001, avant le
+	* drain : le client lit la fin du flux AVANT le GOAWAY définitif. Un appel unaire en vol n'est pas touché — il finit
+	* pendant le drain.
+	*
+	* @param waitMs - attente maximale des fermetures.
+	* @returns la promesse de l'attente, ou rien quand aucun flux n'est ouvert.
+	*
+	* @internal
+	*/
+	shutdownStreams(waitMs = SHUTDOWN_STREAMS_WAIT_MS) {
+		const registry = this.#openStreams ??= new ShutdownRegistry();
+		const count = registry.size;
+		const left = registry.shutdown(waitMs);
+		if (count === 0) return void 0;
+		if (typeof left === "number") {
+			this.#logStreamsShutdown(count, left, waitMs);
+			return;
+		}
+		return left.then((still) => this.#logStreamsShutdown(count, still, waitMs));
+	}
+	/** Une ligne pour l'arrêt des flux longs ; un avertissement s'il en reste. */
+	#logStreamsShutdown(count, still, waitMs) {
+		if (still === 0) {
+			this.log(`Arrêt : ${count} flux long(s) terminé(s)`, "INFO");
+			return;
+		}
+		this.log(`Arrêt : ${still} flux long(s) sur ${count} toujours ouvert(s) après ${waitMs} ms — gestionnaire qui n'écoute pas son signal ; coupé(s) par le drain à shutdownTimeout`, "WARNING");
+	}
+	/**
+	* Re-valide tous les flux en cours et ferme ceux dont l'identité est morte.
 	* Publique pour qu'un banc la déclenche sans attendre le tick.
 	*/
 	revalidateStreams() {