@nodefony/http 10.0.0-beta.6 → 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.
@@ -376,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;
@@ -405,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,6 +1,7 @@
 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";
@@ -10,7 +11,9 @@ 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 { 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";
@@ -20,7 +23,7 @@ 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.157.0/helpers/esm/decorate.js";
+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";
@@ -111,6 +114,16 @@ 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;
@@ -142,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;
@@ -292,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`.
 	*
@@ -379,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");
@@ -478,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;
 	}
@@ -582,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
@@ -669,8 +681,12 @@ let HttpKernel = class HttpKernel extends Service {
 					context.isRedirect = false;
 					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;
@@ -744,7 +760,7 @@ let HttpKernel = class HttpKernel extends Service {
 				return;
 			}
 			if (url === this.#healthPaths.readiness) {
-				this.#respondHealth(response, !this.#terminating && this.kernel?.servable === true, type);
+				this.#respondHealth(response, this.kernel?.isTerminating !== true && this.kernel?.servable === true, type);
 				return;
 			}
 		}
@@ -910,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();
@@ -1112,16 +1144,52 @@ let HttpKernel = class HttpKernel extends Service {
 		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 headers = httpContext.request.headers;
-		if (isUnsupportedTransferCoding(headers["transfer-encoding"])) return Promise.reject(new HttpError("Transfer-Encoding not implemented", 501, httpContext));
-		if (hasConflictingAuthority(headers)) return Promise.reject(new HttpError("Host differs from :authority", 400, httpContext));
-		const streamBody = httpContext.resolver?.resolve === true && httpContext.resolver.route?.bodyStream === true;
+		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"));
@@ -1512,7 +1580,7 @@ let HttpKernel = class HttpKernel extends Service {
 	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);
 	}
@@ -1521,6 +1589,117 @@ let HttpKernel = class HttpKernel extends Service {
 		this.#streams?.unregister(stream);
 	}
 	/**
+	* 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.
 	*/

package/dist/nodefony/service/pretty-request-logger.js

@@ -1,4 +1,5 @@
-import { severityFromStatus, statusOf } from "./audit-logger.js";
+import { severityFromStatus, severityOfHttp, statusOf } from "./audit-logger.js";
+import { rpcSegment } from "./request-logger.js";
 import { handshakeRefusalStatus } from "../src/context/websocket/WebsocketContext.js";
 import { accessStatusFamily, logColor } from "nodefony";
 // nodefony/service/pretty-request-logger.ts
@@ -27,9 +28,10 @@ var PrettyRequestLogger = class {
 		const status = statusOf(ctx) ?? (err ? 500 : null);
 		const method = ctx.method ?? "?";
 		const duration = ctx.stopClock();
+		const rpc = ctx.rpc ?? null;
 		return {
-			text: `${logColor.cyan(method.padEnd(4))} ${colorizeStatus(status)} ${ctx.url} ${logColor.blackBright(formatDuration(duration))} ${logColor.blackBright(ctx.remoteAddress ?? "-")} ` + logColor.magenta(`[${shortId(ctx.requestId)}]`) + (err ? ` ${logColor.red(err.message)}` : ""),
-			severity: severityFromStatus(status),
+			text: `${logColor.cyan(method.padEnd(4))} ${colorizeStatus(status)} ${ctx.url} ${logColor.blackBright(formatDuration(duration))} ${logColor.blackBright(ctx.remoteAddress ?? "-")} ` + logColor.magenta(`[${shortId(ctx.requestId)}]`) + (rpc === null ? "" : ` ${rpcSegment(rpc)}`) + (err ? ` ${logColor.red(err.message)}` : ""),
+			severity: severityOfHttp(ctx, status),
 			msgid: "req"
 		};
 	}

package/dist/nodefony/service/request-logger.js

@@ -1,4 +1,4 @@
-import { severityFromStatus } from "./audit-logger.js";
+import { severityFromRpcCode, severityFromStatus } from "./audit-logger.js";
 import { handshakeRefusalStatus } from "../src/context/websocket/WebsocketContext.js";
 import { logColor } from "nodefony";
 // nodefony/service/request-logger.ts
@@ -11,6 +11,18 @@ const statusOf = (context) => {
 	return context.response?.statusCode;
 };
 /**
+* Segment d'un appel RPC sur la ligne d'accès : `RPC : <méthode> <NOM>`
+* (ADR-0026 D10 point 4) — le statut HTTP reste à sa place. Sans code (appel
+* jamais commencé), la méthode seule.
+*
+* @param rpc - le résultat de l'appel.
+* @returns le segment, sans espace de tête.
+*/
+function rpcSegment(rpc) {
+	const name = rpc.codeName;
+	return name === null ? `${logColor.cyan("RPC")} : ${rpc.method}` : `${logColor.cyan("RPC")} : ${rpc.method} ${name}`;
+}
+/**
 * Default Nodefony per-request logger — preserves the legacy colored format.
 *
 * HTTP success: `URL : <url> FROM : <remote> ORIGIN : <host> ID : <uuid>`
@@ -23,21 +35,24 @@ const statusOf = (context) => {
 */
 var DefaultRequestLogger = class {
 	renderHttp(context, error) {
-		const txt = `${logColor.cyan("URL")} : ${context.url} ${logColor.cyan("FROM")} : ${context.remoteAddress} ${logColor.cyan("ORIGIN")} : ${context.originUrl?.host} ${logColor.cyan("ID")} : ${context.requestId}`;
+		const rpc = context.rpc ?? null;
+		const txt = `${logColor.cyan("URL")} : ${context.url} ${logColor.cyan("FROM")} : ${context.remoteAddress} ${logColor.cyan("ORIGIN")} : ${context.originUrl?.host} ${logColor.cyan("ID")} : ${context.requestId}` + (rpc === null ? "" : ` ${rpcSegment(rpc)}`);
+		const code = rpc === null ? null : rpc.code;
 		const err = error ?? context.error;
 		if (err) {
 			const errCode = err.code ?? statusOf(context) ?? 500;
 			const msgid = `${context.serverType} ${logColor.magenta(errCode)} ${logColor.red(context.method ?? "")}`;
 			return {
 				text: context.kernel?.environment === "production" ? `${txt} ${err}` : `${txt}\n          ${err}`,
-				severity: "ERROR",
+				severity: code === null ? "ERROR" : severityFromRpcCode(code),
 				msgid
 			};
 		}
+		const msgid = `${context.serverType} ${logColor.magenta(statusOf(context) ?? "")} ${context.method}`;
 		return {
 			text: txt,
-			severity: "INFO",
-			msgid: `${context.serverType} ${logColor.magenta(statusOf(context) ?? "")} ${context.method}`
+			severity: code === null ? "INFO" : severityFromRpcCode(code),
+			msgid
 		};
 	}
 	renderWebsocket(context, error, acceptedProtocol) {
@@ -59,4 +74,4 @@ var DefaultRequestLogger = class {
 		};
 	}
 };
-export { DefaultRequestLogger as default };
+export { DefaultRequestLogger as default, rpcSegment };

package/dist/nodefony/service/reverse-proxy.js

@@ -67,7 +67,7 @@ var ReverseProxy = class extends Service {
 		this.defaultTimeoutMs = section?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 		this.connectTimeoutMs = section?.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
 		this.maxSockets = section?.maxSockets ?? DEFAULT_MAX_SOCKETS;
-		this.kernel?.prependOnceListener("onTerminate", () => this.closeAll());
+		this.kernel?.once("onTerminate", () => this.closeAll());
 		for (const [prefix, mount] of Object.entries(section?.mounts ?? {})) this.#add(prefix, mount, "config");
 	}
 	/**

package/dist/nodefony/service/servers/clientError.js

@@ -1,6 +1,27 @@
 import { isPeerGoneError } from "../../src/context/websocket/Response.js";
+import { STATUS_CODES } from "node:http";
 // nodefony/service/servers/clientError.ts
 /**
+* Le statut que Node lui-même aurait répondu (`_http_server.js#socketOnError`),
+* hors débordement d'en-têtes ({@link overflowStatusLine}) ; 400 sinon.
+* Brancher un écouteur `clientError` retire cette réponse par défaut : sans
+* cette table, un délai de réception dépassé partait en `400 Bad Request` —
+* le client lisait sa requête malformée alors qu'elle était seulement lente.
+*/
+const CLIENT_ERROR_STATUS = /* @__PURE__ */ new Map([["ERR_HTTP_REQUEST_TIMEOUT", 408], ["HPE_CHUNK_EXTENSIONS_OVERFLOW", 413]]);
+function statusLineOf(status) {
+	return `${status} ${STATUS_CODES[status] ?? ""}`;
+}
+/**
+* La réponse en vol sur cette socket a-t-elle déjà écrit ses en-têtes ? La
+* garde même de Node (`socketOnError` : `_httpMessage._headerSent`), lue par
+* réflexion — deux champs internes, sans équivalent public sur la socket.
+*/
+function inFlightHeaderSent(socket) {
+	const message = Reflect.get(socket, "_httpMessage");
+	return message !== null && typeof message === "object" && Reflect.get(message, "_headerSent") === true;
+}
+/**
 * Gère l'event `clientError` d'un `http.Server` / `https.Server`, et des connexions
 * HTTP/1.1 d'un serveur HTTP/2 à `allowHTTP1`.
 *
@@ -16,7 +37,11 @@ import { isPeerGoneError } from "../../src/context/websocket/Response.js";
 function handleClientError(error, socket) {
 	const code = "code" in error ? error.code : void 0;
 	if (code === "ECONNRESET" || !socket.writable) return;
-	const statusLine = code === "HPE_HEADER_OVERFLOW" ? overflowStatusLine(error) : "400 Bad Request";
+	if (inFlightHeaderSent(socket)) {
+		socket.destroy();
+		return;
+	}
+	const statusLine = code === "HPE_HEADER_OVERFLOW" ? overflowStatusLine(error) : statusLineOf(CLIENT_ERROR_STATUS.get(code) ?? 400);
 	socket.end(`HTTP/1.1 ${statusLine}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`);
 }
 /**

package/dist/nodefony/service/servers/server-h2c.js

@@ -3,8 +3,8 @@ import { handleSessionError } from "./clientError.js";
 import { http2ServerLimits, setHttp2SessionTimeout } from "../../src/servers/http2Limits.js";
 import { bindWithFallback, buildBindPlan, h2cPortConflict } from "../../src/servers/portBinder.js";
 import { asServersConfig, configuredServerPort, isH2cEnabled } from "../../src/servers/kernelServers.js";
-import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorateParam.js";
-import __decorate from "../../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorateParam.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { BootConfigurationError, Inject, Service, nodefonyError } from "nodefony";
 import http2 from "node:http2";
 // nodefony/service/servers/server-h2c.ts
@@ -98,7 +98,7 @@ let ServerH2c = class ServerH2c extends Service {
 					server.close();
 					reject(error);
 				});
-				this.kernel?.once("onTerminate", async () => {
+				this.httpKernel.addShutdownStep("drain", async () => {
 					if (!this.server) return;
 					try {
 						await this.httpTerminator?.terminate();

package/dist/nodefony/service/servers/server-http.js

@@ -3,8 +3,8 @@ import { routeSocketTimeout } from "../../src/context/http/HttpContext.js";
 import { createDrainTerminator } from "./serverShutdown.js";
 import { bindWithFallback, buildBindPlan } from "../../src/servers/portBinder.js";
 import { asServersConfig, configuredServerPort } from "../../src/servers/kernelServers.js";
-import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorateParam.js";
-import __decorate from "../../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorateParam.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { Inject, Service, extend, nodefonyError } from "nodefony";
 import http from "node:http";
 // nodefony/service/servers/server-http.ts
@@ -69,7 +69,7 @@ let ServerHttp = class ServerHttp extends Service {
 					this.reportBindError(error);
 					reject(error);
 				});
-				this.kernel?.once("onTerminate", async () => {
+				this.httpKernel.addShutdownStep("drain", async () => {
 					if (!this.server) return;
 					try {
 						await this.httpTerminator?.terminate();

package/dist/nodefony/service/servers/server-https.js

@@ -4,8 +4,8 @@ import { handleClientError, handleSessionError } from "./clientError.js";
 import { routeSocketTimeout } from "../../src/context/http/HttpContext.js";
 import { bindWithFallback, buildBindPlan } from "../../src/servers/portBinder.js";
 import { asServersConfig, configuredServerPort } from "../../src/servers/kernelServers.js";
-import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorateParam.js";
-import __decorate from "../../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorateParam.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { Inject, Service, extend, nodefonyError } from "nodefony";
 import http2 from "node:http2";
 import https from "node:https";
@@ -76,7 +76,7 @@ let ServerHttps = class ServerHttps extends Service {
 				this.server.on("request", (request, response) => {
 					this.httpKernel.onHttpRequest(request, response, this.type);
 				});
-				this.kernel?.once("onTerminate", async () => {
+				this.httpKernel.addShutdownStep("drain", async () => {
 					if (!this.server) return;
 					try {
 						await this.httpTerminator?.terminate();
@@ -120,7 +120,7 @@ let ServerHttps = class ServerHttps extends Service {
 					this.reportBindError(error);
 					reject(error);
 				});
-				this.kernel?.once("onTerminate", async () => {
+				this.httpKernel.addShutdownStep("drain", async () => {
 					if (!this.server) return;
 					try {
 						await this.httpTerminator?.terminate();

package/dist/nodefony/service/servers/server-websocket-secure.js

@@ -1,8 +1,8 @@
 import { asServersConfig, configuredServerPort } from "../../src/servers/kernelServers.js";
 import { startHeartbeat } from "./wsHeartbeat.js";
 import { attachUpgradeDispatch, createNodefonyWebSocketServer } from "../../src/servers/upgradeDispatch.js";
-import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorateParam.js";
-import __decorate from "../../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorateParam.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { Inject, Service } from "nodefony";
 import Ws from "ws";
 // nodefony/service/servers/server-websocket-secure.ts
@@ -50,7 +50,7 @@ let WebsocketSecure = class WebsocketSecure extends Service {
 					this.httpKernel.onWebsocketUpgrade(req, admission, this.type).catch(() => {});
 				});
 				this.heartbeatTimer = startHeartbeat(this.server, this.options);
-				this.kernel?.prependOnceListener("onTerminate", this.terminate.bind(this));
+				this.httpKernel.addShutdownStep("dismiss", () => this.terminate());
 				this.ready = true;
 				this.module.fire("onServersReady", this.type, this);
 				return resolve(this.server);