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

package/dist/nodefony/src/context/http/Response.js

@@ -3,6 +3,41 @@ import { thenMaybe, typeOf } from "nodefony";
 import http, { validateHeaderName, validateHeaderValue } from "node:http";
 import mime from "mime-types";
 // nodefony/src/context/http/Response.ts
+/**
+* Plafond, en octets, d'un corps de requête HTTP/1.1 non lu que le serveur
+* accepte de vider pour garder la connexion réutilisable — 256 Kio, le geste du
+* serveur HTTP de Go que Connect reprend (ADR-0026, D5). Au-delà, la réponse
+* ferme la connexion.
+*/
+const UNREAD_BODY_DRAIN_LIMIT = 262144;
+/**
+* Silence, en millisecondes, au bout duquel une connexion HTTP/1.1 fermée sur
+* un corps non lu est détruite — 5 s, le `lingering_timeout` par défaut de
+* nginx. La durée TOTALE reste bornée par le délai de réception de Node
+* (`requestTimeout`), qui court tant que le corps n'est pas fini.
+*/
+const UNREAD_BODY_LINGER_MS = 5e3;
+/**
+* Fermeture ATTARDÉE (RFC 9112 §9.6) d'une connexion qui part en
+* `connection: close` avec un corps encore en route : la réponse écrite, le
+* serveur ferme son côté écriture et continue de LIRE — Node jette les octets
+* du corps non consommé — jusqu'à ce que le client ferme, ou après
+* {@link UNREAD_BODY_LINGER_MS} de silence.
+*
+* Sans elle, Node détruit la socket aussitôt la réponse écrite
+* (`destroySoon`) : le client qui écrit encore son corps prend une
+* réinitialisation (`EPIPE`, `ECONNRESET`) et ne lit jamais la réponse — un
+* 413 sur un envoi de 5 Mo devenait une erreur réseau. Posée sur CETTE socket
+* seulement, qui ne sert plus d'autre requête.
+*
+* @param socket - la socket de la connexion qui se ferme.
+*/
+function lingerBeforeClose(socket) {
+	socket.destroySoon = () => {
+		socket.setTimeout(UNREAD_BODY_LINGER_MS, () => socket.destroy());
+		socket.end();
+	};
+}
 const ANSI_REGEX = new RegExp(["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"].join("|"), "g");
 const stripAnsi = function(val) {
 	return typeof val === "string" ? val.replace(ANSI_REGEX, "") : val;
@@ -100,7 +135,7 @@ var HttpResponse = class {
 	flushing = false;
 	encoding = "utf-8";
 	#text = null;
-	#textEncoding = "utf-8";
+	#textEncoding = "utf8";
 	#buffer = null;
 	contentType = "application/octet-stream";
 	headers = {};
@@ -127,6 +162,11 @@ var HttpResponse = class {
 	* le transport y est déjà, il ne s'amorce plus.
 	*/
 	#committed = false;
+	/**
+	* Méthode `setHeader` native retenue pendant que l'interception du repli
+	* statique est armée ; `null` sinon (et sur toute réponse routée).
+	*/
+	#nativeSetHeader = null;
 	constructor(response, context) {
 		this.context = context;
 		this.response = response;
@@ -387,19 +427,37 @@ var HttpResponse = class {
 		else list[at + 1] = value;
 	}
 	/**
+	* Range les en-têtes de corrélation du contexte — `X-Request-Id` et le
+	* `traceparent` W3C — que toute réponse renvoie, quel qu'en soit l'émetteur.
+	* Validés par Node à la remise, comme le reste de la réserve.
+	*/
+	putCorrelationHeaders() {
+		if (this.context.requestId) this.#put("x-request-id", this.context.requestId);
+		if (this.context.traceparent) this.#put("traceparent", this.context.traceparent);
+	}
+	/**
 	* Recopie la réserve sur la réponse Node, pour un émetteur qui écrit sans
-	* passer par {@link writeHead} — fichier statique, relais vers un amont. La
-	* réserve se vide ; ce qui se pose ensuite y retourne, et Node fusionne les
-	* deux au `writeHead`.
+	* passer par {@link writeHead} — fichier statique, relais vers un amont,
+	* adaptateur RPC. La réserve se vide ; ce qui se pose ensuite y retourne, et
+	* Node fusionne les deux au `writeHead` (l'émetteur l'emporte, nom par nom).
+	*
+	* @param contentType - type de la réponse que l'émetteur écrira, quand il
+	*   est connu d'avance (adaptateur RPC). Omis : il se lit à l'extension du
+	*   chemin, comme le serveur statique le fera.
 	*/
-	commitHeaders() {
+	commitHeaders(contentType) {
 		const res = this.response;
 		if (res === null || res.headersSent) return;
 		if (this.headerPolicy !== null) {
-			const pathname = this.context.request.pathname;
-			const type = pathname.endsWith("/") ? false : mime.lookup(pathname);
-			this.applyHeaderPolicy(type === false ? void 0 : type, true);
+			let type = contentType;
+			if (type === void 0) {
+				const pathname = this.context.request.pathname;
+				const found = pathname.endsWith("/") ? false : mime.lookup(pathname);
+				if (found !== false) type = found;
+			}
+			this.applyHeaderPolicy(type, true);
 		}
+		this.putCorrelationHeaders();
 		const list = this.#store();
 		for (let i = 0; i + 1 < list.length; i += 2) {
 			const name = list[i];
@@ -416,15 +474,22 @@ var HttpResponse = class {
 	* rien, sa réponse part ensuite en un seul `writeHead`. À désarmer par
 	* {@link disarmNativeWrite} quand le tiers rend la main sans avoir écrit.
 	*
-	* L'interception est une propriété PROPRE de la réponse, ajoutée puis
-	* retirée : V8 annule alors la dernière transition de forme de l'objet.
+	* L'interception est une propriété PROPRE de la réponse, posée une fois avec
+	* des attributs constants — toutes les réponses interceptées partagent donc
+	* la même forme — et désarmée en lui RÉAFFECTANT la méthode native, jamais
+	* en la supprimant : un `delete` fait basculer la réponse Node en mode
+	* dictionnaire (constaté par `%HasFastProperties` sur Node 26, 200 réponses
+	* sur 200), et chaque accès suivant de `node:http` le paie — mesuré in situ
+	* sur un 404 : `writeHead` +1,1 µs, `end` +4,3 µs.
 	*/
 	commitBeforeNativeWrite() {
 		const res = this.response;
-		if (res === null || res.headersSent || Object.hasOwn(res, "setHeader")) return;
+		if (res === null || res.headersSent || this.#nativeSetHeader !== null) return;
 		const native = res.setHeader;
+		this.#nativeSetHeader = native;
 		Object.defineProperty(res, "setHeader", {
 			configurable: true,
+			enumerable: false,
 			writable: true,
 			value: (name, value) => {
 				this.disarmNativeWrite();
@@ -433,10 +498,17 @@ var HttpResponse = class {
 			}
 		});
 	}
-	/** Retire l'interception posée par {@link commitBeforeNativeWrite}. */
+	/**
+	* Retire l'interception posée par {@link commitBeforeNativeWrite} : la
+	* propriété propre reçoit la méthode native — la forme de l'objet ne change
+	* pas, la réponse reste en mode rapide pour V8.
+	*/
 	disarmNativeWrite() {
+		const native = this.#nativeSetHeader;
+		if (native === null) return;
+		this.#nativeSetHeader = null;
 		const res = this.response;
-		if (res !== null && Object.hasOwn(res, "setHeader")) Reflect.deleteProperty(res, "setHeader");
+		if (res !== null) Object.defineProperty(res, "setHeader", { value: native });
 	}
 	/**
 	* Retire un en-tête, de la réserve comme de la réponse Node.
@@ -595,7 +667,7 @@ var HttpResponse = class {
 	#setText(text, encoding) {
 		this.#buffer = null;
 		this.#text = text;
-		this.#textEncoding = encoding;
+		this.#textEncoding = encoding === "utf-8" ? "utf8" : encoding;
 	}
 	setLength(body) {
 		if (this.response?.headersSent) throw new Error("Headers already sended");
@@ -625,8 +697,7 @@ var HttpResponse = class {
 			}
 			this.statusMessage = this.getStatusMessage();
 			if (headers) this.#apply(headers);
-			if (this.context.requestId) this.#put("x-request-id", this.context.requestId);
-			if (this.context.traceparent) this.#put("traceparent", this.context.traceparent);
+			this.putCorrelationHeaders();
 			this.setLength();
 			this.ensureContentTypeHeader();
 			this.applyHeaderPolicy(this.contentTypeForPolicy());
@@ -750,6 +821,38 @@ var HttpResponse = class {
 		return this.response.end(chunk, encoding || this.encoding);
 	}
 	/**
+	* Règle le sort d'un corps de requête resté NON LU au moment de répondre —
+	* route inconnue (404, 405), refus avant l'action, 408, 413. À appeler AVANT
+	* l'écriture des en-têtes ; sans effet si le corps est entièrement reçu.
+	*
+	* HTTP/1.1 : Node vide lui-même un corps non consommé une fois la réponse
+	* écrite, pour réutiliser la connexion — sans borne. On ne le laisse faire
+	* que pour un corps DÉCLARÉ d'au plus {@link UNREAD_BODY_DRAIN_LIMIT}
+	* octets ; au-delà, ou sans longueur déclarée (`transfer-encoding`), la
+	* réponse part avec `connection: close` (RFC 9112 §9.6) et la connexion
+	* n'est pas réutilisée — fermée par étapes ({@link lingerBeforeClose}),
+	* pour que le client qui écrit encore lise la réponse. La décision se prend
+	* sur la longueur ANNONCÉE, sans attendre un octet : la réponse n'est jamais
+	* retardée par le corps.
+	*
+	* HTTP/2 surcharge cette méthode (`Http2Response`) : fermeture du flux en
+	* `NO_ERROR` une fois la réponse écrite. Une seule entrée pour les deux
+	* protocoles, partagée par tout refus qui laisse un corps non lu (ADR-0026,
+	* D5).
+	*/
+	closeUnfinishedRequest() {
+		const response = this.response;
+		if (response === null || response.headersSent) return;
+		if (this.context.request.request.complete) return;
+		const headers = this.context.request.headers;
+		if (headers["transfer-encoding"] === void 0) {
+			if (Number(headers["content-length"] ?? 0) <= 262144) return;
+		}
+		this.setHeader("connection", "close");
+		const socket = response.socket;
+		if (socket !== null) lingerBeforeClose(socket);
+	}
+	/**
 	* Valeur d'un en-tête posé — dans la réserve, sinon sur la réponse Node (ce
 	* qu'un tiers y a écrit directement : `send`, quota).
 	*
@@ -800,4 +903,4 @@ var HttpResponse = class {
 		return this.context.log(pci, severity, msgid, msg);
 	}
 };
-export { HttpResponse as default, isContentlessStatus };
+export { UNREAD_BODY_DRAIN_LIMIT, UNREAD_BODY_LINGER_MS, HttpResponse as default, isContentlessStatus };

package/dist/nodefony/src/context/http/SseStream.js

@@ -1,10 +1,10 @@
-import { MAX_TIMER_MS, checkStreamTimer, openStreamLifecycle } from "./StreamLifecycle.js";
+import { MAX_TIMER_MS, STREAM_STALL_TIMEOUT_MS, checkStreamTimer, openStreamLifecycle } from "./StreamLifecycle.js";
 import http from "node:http";
 // nodefony/src/context/http/SseStream.ts
 /** Battement de cœur par défaut, en ms (§9.2.7 : « every 15 seconds or so »). */
 const SSE_HEARTBEAT_MS = 15e3;
-/** Délai de blocage d'écriture par défaut, en ms. */
-const SSE_STALL_TIMEOUT_MS = 3e4;
+/** Délai de blocage d'écriture par défaut, en ms — celui de tout flux. */
+const SSE_STALL_TIMEOUT_MS = STREAM_STALL_TIMEOUT_MS;
 /** Taille maximale d'un événement par défaut, en octets (1 Mio). */
 const SSE_MAX_EVENT_BYTES = 1048576;
 /** Commentaire de battement de cœur — ignoré par tout client conforme. */
@@ -255,7 +255,7 @@ function openSseStream(context, options = {}) {
 	};
 	const opened = openStreamLifecycle(context, {
 		label: "SSE",
-		stallTimeout: options.stallTimeout ?? 3e4,
+		stallTimeout: options.stallTimeout ?? SSE_STALL_TIMEOUT_MS,
 		maxDuration: options.maxDuration ?? false
 	});
 	return opened instanceof Promise ? opened.then((lifecycle) => startSseStream(lifecycle, options, settings)) : startSseStream(opened, options, settings);

package/dist/nodefony/src/context/http/StreamLifecycle.js

@@ -1,6 +1,7 @@
 import Http2Response from "../http2/Response.js";
 import HttpError from "../../errors/httpError.js";
-import { RequestContext } from "nodefony";
+import { ANNOUNCE_CAP_MS } from "../../servers/http2Goaway.js";
+import { REVOCATION_REVALIDATE_MS, RequestContext } from "nodefony";
 import http from "node:http";
 import { AsyncResource } from "node:async_hooks";
 // nodefony/src/context/http/StreamLifecycle.ts
@@ -32,6 +33,29 @@ import { AsyncResource } from "node:async_hooks";
 */
 const MAX_TIMER_MS = 2147483647;
 /**
+* Délai de blocage par défaut d'un flux, en ms : un client qui ne lit plus
+* depuis ce délai est coupé. Valeur commune aux flux d'événements, d'octets et
+* aux flux RPC.
+*/
+const STREAM_STALL_TIMEOUT_MS = 3e4;
+/**
+* Période du balayage de blocage ({@link StallSweep}) : la moitié du délai de
+* blocage. Un client bloqué est coupé entre `stallTimeout` et
+* `stallTimeout + période` après la première contre-pression vue — jamais
+* avant le délai réglé.
+*/
+const STALL_SWEEP_PERIOD_MS = STREAM_STALL_TIMEOUT_MS / 2;
+/**
+* Attente maximale, à l'arrêt du serveur, des flux longs qu'on vient de
+* terminer (`HttpKernel.shutdownStreams`), avant le drain des connexions.
+*
+* Un flux qui écoute son signal se ferme en quelques millisecondes : l'attente
+* finit avec lui. Elle ne dure jusqu'à son terme que pour un gestionnaire qui
+* n'écoute rien — et ce temps s'AJOUTE au drain (`shutdownTimeout`), d'où une
+* borne courte, celle de l'annonce du GOAWAY.
+*/
+const SHUTDOWN_STREAMS_WAIT_MS = ANNOUNCE_CAP_MS;
+/**
 * Refuse une option de délai hors de ce qu'un minuteur sait tenir.
 *
 * @param label - préfixe du message (`SSE`, `Flux`).
@@ -46,6 +70,42 @@ function checkStreamTimer(label, name, value) {
 	if (!Number.isInteger(value) || value < 1 || value > 2147483647) throw new RangeError(`${label} : ${name} entier entre 1 et ${MAX_TIMER_MS} ms, ou false, attendu`);
 }
 /**
+* Constate le transport de la réponse d'un contexte : le flux en HTTP/2, la
+* réponse en HTTP/1.1. Seule implémentation de ce constat — un flux SSE,
+* d'octets ou un appel gRPC le lisent ici.
+*
+* @param context - le contexte de la requête.
+* @returns la cible d'écriture, ou `null` quand la réponse est absente ou que
+*   son transport n'est pas reconnu.
+*
+* @internal
+*/
+function resolveStreamTarget(context) {
+	const response = context.response;
+	const stream = response instanceof Http2Response ? response.stream : null;
+	if (stream !== null) return stream;
+	const nodeResponse = response.response;
+	return nodeResponse instanceof http.ServerResponse ? nodeResponse : null;
+}
+/**
+* Désarme le délai de réponse que Nodefony arme sur toute requête
+* (`HttpContext.setTimeout`) : celui du flux en HTTP/2, celui de la socket en
+* HTTP/1.1. Seule implémentation de cette règle — un flux long l'appelle, et
+* une réponse possédée par un tiers aussi, pour qu'à l'expiration Nodefony
+* n'écrive pas un 503 par-dessus (un seul écrivain).
+*
+* En HTTP/1.1, la requête suivante de la même connexion réarme la socket
+* (`HttpContext.setTimeout` compare `socket.timeout` à son délai).
+*
+* @param target - la cible d'écriture constatée par {@link resolveStreamTarget}.
+*
+* @internal
+*/
+function disarmResponseTimeout(target) {
+	if (target instanceof http.ServerResponse) target.socket?.setTimeout(0);
+	else target.setTimeout(0);
+}
+/**
 * Le cycle de vie d'UN flux ouvert sur une réponse.
 *
 * S'obtient par {@link openStreamLifecycle} ; le constructeur n'est appelé
@@ -53,7 +113,7 @@ function checkStreamTimer(label, name, value) {
 *
 * @internal
 */
-var StreamLifecycle = class {
+var StreamLifecycle = class StreamLifecycle {
 	context;
 	/** Où l'on écrit : la réponse HTTP/1.1, ou le flux HTTP/2. */
 	target;
@@ -62,6 +122,27 @@ var StreamLifecycle = class {
 	#stallTimeout;
 	#revalidate;
 	identifier;
+	#foreignWriter;
+	/**
+	* Le noyau des registres où le flux s'inscrit, pris À L'OUVERTURE : le
+	* nettoyage du contexte (`Context.clean`) remet `context.httpKernel` à
+	* `null`, et il passe à la fermeture AVANT celui du flux — relu là, le
+	* retrait ne se ferait pas, et le flux fermé resterait dans les registres
+	* (révocation, balayage, arrêt) avec son contexte.
+	*/
+	#kernel;
+	/** Terminé par le noyau à l'arrêt du serveur — et donc inscrit à son registre. */
+	#endsAtShutdown;
+	/**
+	* Fin d'attente d'un flux balayé : posée sur `drain` quand le balayage voit
+	* une contre-pression — créée à la première, `null` avant (lazy).
+	*/
+	#onSweptDrain = null;
+	/**
+	* Fenêtre laissée à un appel RPC révoqué pour se terminer à son format avant
+	* la destruction du transport — armée seulement à la révocation.
+	*/
+	#revokeGrace = null;
 	#closed = false;
 	#cause = null;
 	/**
@@ -95,8 +176,7 @@ var StreamLifecycle = class {
 			this.#stall.unref();
 			return;
 		}
-		this.#cause = "stall";
-		this.target.destroy();
+		this.#cutStalled();
 	};
 	constructor(context, target, response, settings) {
 		this.context = context;
@@ -105,12 +185,18 @@ var StreamLifecycle = class {
 		this.#stallTimeout = settings.stallTimeout;
 		this.#revalidate = settings.revalidate;
 		this.identifier = settings.identifier;
+		this.#foreignWriter = settings.foreignWriter;
+		this.#endsAtShutdown = settings.endsAtShutdown;
+		const kernel = context.httpKernel;
+		this.#kernel = kernel;
 		response.on("close", this.#onResponseClose);
 		if (settings.maxDuration !== false) {
 			this.#lifetime = setTimeout(() => void this.close(), settings.maxDuration);
 			this.#lifetime.unref();
 		}
-		if (this.#revalidate !== null) context.httpKernel?.watchStream(this);
+		if (this.#revalidate !== null) kernel?.watchStream(this);
+		if (this.#endsAtShutdown) kernel?.trackStream(this);
+		if (this.#foreignWriter && this.#stallTimeout !== false) kernel?.sweepStall(this);
 	}
 	/** Le flux est-il fermé — par le serveur, ou par le client parti ? */
 	get closed() {
@@ -177,22 +263,104 @@ var StreamLifecycle = class {
 		this.#stallSince = 0;
 	}
 	/**
+	* Un tour du balayage de blocage, pour un flux dont un tiers tient les
+	* écritures ({@link StallSweep}).
+	*
+	* Une contre-pression vue (`writableNeedDrain`) ouvre l'attente et pose un
+	* `drain` : seul ce progrès RÉEL la ferme, jamais un tour qui verrait le
+	* tampon vide — un client lent qui lit voit son tampon se remplir à nouveau
+	* aussitôt, et serait sinon pris pour bloqué. Une attente qui dure
+	* `stallTimeout` coupe le client.
+	*
+	* @param now - l'heure du tour (`Date.now()`), lue une fois pour tous les flux.
+	*/
+	sweepStall(now) {
+		const limit = this.#stallTimeout;
+		if (this.#closed || limit === false) return;
+		if (this.#stallSince !== 0) {
+			if (now - this.#stallSince >= limit) this.#cutStalled();
+			return;
+		}
+		if (!this.target.writableNeedDrain) return;
+		this.#stallSince = now;
+		this.target.once("drain", this.#onSweptDrain ??= () => {
+			this.#stallSince = 0;
+		});
+	}
+	/** Coupe un client qui ne lit plus : la fermeture de la réponse termine le flux. */
+	#cutStalled() {
+		this.#cause = "stall";
+		this.target.destroy();
+	}
+	/**
 	* Désarme le délai d'inactivité de la requête : un flux n'a pas de fin
 	* attendue, ses propres gardes le remplacent.
 	*/
 	disarmIdleTimeout() {
-		const target = this.target;
-		if (target instanceof http.ServerResponse) target.socket?.setTimeout(0);
-		else target.setTimeout(0);
+		disarmResponseTimeout(this.target);
 	}
-	/** Ferme le flux et termine la requête. Idempotent. */
+	/**
+	* Ferme le flux et termine la requête. Idempotent. Quand un tiers tient les
+	* écritures, le transport est détruit : terminer la réponse en ferait un
+	* second écrivain.
+	*/
 	close() {
 		if (this.#closed) return void 0;
 		this.#cause = "server";
 		this.finish();
+		if (this.#foreignWriter) {
+			this.target.destroy();
+			return;
+		}
 		const done = this.context.close();
 		return done instanceof Promise ? done.then(() => void 0) : void 0;
 	}
+	/**
+	* L'identité qui a ouvert le flux est morte (révocation, droits changés) :
+	* le flux prend fin. Idempotent.
+	*
+	* Quand un adaptateur RPC tient les écritures, c'est LUI qui termine l'appel,
+	* au format de son protocole (`HttpContext.rpc.revoke`, gRPC : 16) : le
+	* client lit un statut, pas une coupure, et aucun second écrivain ne touche
+	* la réponse. Un gestionnaire qui n'entend rien — bloqué, sans message à
+	* produire — est détruit à la fenêtre de re-validation suivante. Sinon :
+	* {@link close}.
+	*/
+	revoke() {
+		if (this.#closed) return void 0;
+		const rpc = this.#foreignWriter ? this.context.rpc : null;
+		if (rpc === null) return this.close();
+		if (this.#revokeGrace !== null) return void 0;
+		this.#cause = "server";
+		rpc.revoke();
+		this.#revokeGrace = setTimeout(StreamLifecycle.#destroyRevoked, REVOCATION_REVALIDATE_MS, this);
+		this.#revokeGrace.unref();
+	}
+	/**
+	* Le serveur s'arrête : le flux prend fin AVANT le drain des connexions
+	* (ADR-0026 D8). Idempotent.
+	*
+	* Quand un adaptateur RPC tient les écritures, c'est LUI qui termine l'appel,
+	* au format de son protocole (`HttpContext.rpc.shutdown`, gRPC : 14
+	* `UNAVAILABLE`) : le client le rejoue ailleurs. Un gestionnaire qui n'entend
+	* rien tombe avec sa connexion, détruite par le drain à `shutdownTimeout` —
+	* aucun minuteur de plus. Sinon : {@link close} — `EventSource` se
+	* reconnecte, vers un autre exemplaire.
+	*/
+	shutdown() {
+		if (this.#closed) return void 0;
+		const rpc = this.#foreignWriter ? this.context.rpc : null;
+		if (rpc === null) return this.close();
+		this.#cause = "server";
+		rpc.shutdown();
+	}
+	/** Fenêtre écoulée : l'appel révoqué n'a pas fini, le transport est détruit. */
+	static #destroyRevoked(lifecycle) {
+		lifecycle.#revokeGrace = null;
+		if (lifecycle.#closed) return;
+		lifecycle.finish();
+		lifecycle.target.destroy();
+	}
 	/** Fin du flux : minuteurs, écouteurs et registre libérés, une seule fois. */
 	finish() {
 		if (this.#closed) return;
@@ -202,12 +370,22 @@ var StreamLifecycle = class {
 			clearTimeout(this.#lifetime);
 			this.#lifetime = null;
 		}
+		if (this.#revokeGrace !== null) {
+			clearTimeout(this.#revokeGrace);
+			this.#revokeGrace = null;
+		}
 		this.#stallSince = 0;
 		if (this.#stall !== null) {
 			clearTimeout(this.#stall);
 			this.#stall = null;
 		}
-		if (this.#revalidate !== null) this.context.httpKernel?.unwatchStream(this);
+		const kernel = this.#kernel;
+		if (this.#revalidate !== null) kernel?.unwatchStream(this);
+		if (this.#endsAtShutdown) kernel?.untrackStream(this);
+		if (this.#foreignWriter) {
+			kernel?.unsweepStall(this);
+			if (this.#onSweptDrain !== null) this.target.removeListener("drain", this.#onSweptDrain);
+		}
 		const release = this.#release;
 		this.#release = null;
 		release?.();
@@ -217,6 +395,139 @@ var StreamLifecycle = class {
 	}
 };
 /**
+* Le balayage de blocage des flux dont un tiers tient les écritures : UN
+* minuteur pour tous, armé au premier flux inscrit, arrêté au dernier retiré.
+*
+* Pourquoi un balayage : l'adaptateur écrit et attend `drain` lui-même, la
+* brique ne voit aucune écriture. Le délai d'inactivité que Node tient sur un
+* flux HTTP/2 ne suffit pas : il est repoussé tant que la SESSION avance
+* (`internal/http2/core#callTimeout`), si bien qu'un flux bloqué ne serait
+* jamais coupé tant qu'un voisin de la même connexion est lu.
+*
+* Le seuil reste dans {@link StreamLifecycle.sweepStall} : une règle, une
+* implémentation.
+*
+* Coût mesuré (300 flux HTTP/2 réels, médiane de 9 passes) : ~6 ns par flux et
+* par tour ; ~60 ns pour inscrire puis retirer un flux ; 0 par message.
+*
+* @internal
+*/
+var StallSweep = class {
+	#entries = null;
+	#timer = null;
+	#periodMs;
+	#tick = () => {
+		this.sweep(Date.now());
+	};
+	/** @param periodMs - période du balayage (défaut {@link STALL_SWEEP_PERIOD_MS}). */
+	constructor(periodMs = STALL_SWEEP_PERIOD_MS) {
+		this.#periodMs = periodMs;
+	}
+	/** Nombre de flux balayés. */
+	get size() {
+		return this.#entries?.size ?? 0;
+	}
+	/** Le minuteur est-il armé ? */
+	get running() {
+		return this.#timer !== null;
+	}
+	/** Inscrit un flux ; arme le minuteur au premier. */
+	add(lifecycle) {
+		(this.#entries ??= /* @__PURE__ */ new Set()).add(lifecycle);
+		if (this.#timer === null) {
+			this.#timer = setInterval(this.#tick, this.#periodMs);
+			this.#timer.unref();
+		}
+	}
+	/** Retire un flux (idempotent) ; arrête le minuteur quand il n'en reste aucun. */
+	delete(lifecycle) {
+		if (this.#entries === null) return;
+		this.#entries.delete(lifecycle);
+		if (this.#entries.size === 0 && this.#timer !== null) {
+			clearInterval(this.#timer);
+			this.#timer = null;
+		}
+	}
+	/**
+	* Un tour : chaque flux inscrit juge son propre blocage.
+	*
+	* @param now - l'heure du tour (`Date.now()`).
+	*/
+	sweep(now) {
+		if (this.#entries === null) return;
+		for (const lifecycle of this.#entries) lifecycle.sweepStall(now);
+	}
+};
+/**
+* Le registre de l'arrêt : TOUS les flux longs ouverts qui n'ont pas de fin à
+* eux — SSE, flux RPC, flux d'octets vivants (ADR-0026 D8). À l'arrêt du
+* serveur, le noyau les termine AVANT le drain des connexions, au lieu de les
+* laisser détruire sans un mot à `shutdownTimeout`.
+*
+* Distinct du registre de révocation (`RevocationWatch`), qui ne tient que les
+* flux à identité : y mettre les anonymes ferait travailler chaque fenêtre de
+* re-validation pour rien.
+*
+* Coût : un ajout et un retrait par flux long, constants (44 à 77 ns mesurés
+* de 0 à 10 000 flux ouverts, ADR-0026 D8) ; 0 par appel unaire, 0 par
+* message.
+*
+* @internal
+*/
+var ShutdownRegistry = class {
+	#entries = /* @__PURE__ */ new Set();
+	/** L'arrêt a commencé : un flux inscrit désormais est terminé au tour suivant. */
+	#closing = false;
+	/** Fin de l'attente de l'arrêt, appelée au retrait du dernier flux. */
+	#onEmpty = null;
+	/** Nombre de flux ouverts. */
+	get size() {
+		return this.#entries.size;
+	}
+	/**
+	* Inscrit un flux. Pendant l'arrêt, il est terminé au tour suivant — une
+	* fois son appel RPC relié, qui ne l'est qu'après l'ouverture.
+	*/
+	add(stream) {
+		this.#entries.add(stream);
+		if (this.#closing) setImmediate(shutdownLate, stream);
+	}
+	/** Retire un flux (idempotent) ; le dernier retiré met fin à l'attente. */
+	delete(stream) {
+		if (!this.#entries.delete(stream) || this.#entries.size !== 0) return;
+		const done = this.#onEmpty;
+		this.#onEmpty = null;
+		done?.();
+	}
+	/**
+	* L'arrêt : termine chaque flux, puis attend que tous se soient retirés, au
+	* plus `waitMs`.
+	*
+	* @param waitMs - attente maximale des fermetures.
+	* @returns le nombre de flux encore ouverts à la fin de l'attente — tout de
+	*   suite quand il n'y a rien à attendre, sinon sa promesse.
+	*/
+	shutdown(waitMs) {
+		this.#closing = true;
+		for (const stream of this.#entries) stream.shutdown();
+		if (this.#entries.size === 0) return 0;
+		return new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				this.#onEmpty = null;
+				resolve(this.#entries.size);
+			}, waitMs);
+			this.#onEmpty = () => {
+				clearTimeout(timer);
+				resolve(0);
+			};
+		});
+	}
+};
+/** Termine un flux inscrit pendant l'arrêt (rappel de `setImmediate`). */
+function shutdownLate(stream) {
+	stream.shutdown();
+}
+/**
 * Ouvre le cycle de vie d'un flux sur la réponse d'un contexte HTTP.
 *
 * Prend la réponse, pose l'écoute de sa fermeture, puis sauve la session —
@@ -237,14 +548,10 @@ var StreamLifecycle = class {
 function openStreamLifecycle(context, options) {
 	const { label } = options;
 	if (context.sended || context.finished || context.response.isHeaderSent()) throw new HttpError(`${label} : la réponse est déjà partie`, 500);
-	const response = context.response;
-	const nodeResponse = response.response;
+	const nodeResponse = context.response.response;
 	if (nodeResponse === null) throw new HttpError(`${label} : réponse introuvable`, 500, context);
-	const stream = response instanceof Http2Response ? response.stream : null;
-	let target;
-	if (stream !== null) target = stream;
-	else if (nodeResponse instanceof http.ServerResponse) target = nodeResponse;
-	else throw new HttpError(`${label} : transport de réponse inconnu`, 500, context);
+	const target = resolveStreamTarget(context);
+	if (target === null) throw new HttpError(`${label} : transport de réponse inconnu`, 500, context);
 	const gone = target.destroyed;
 	const kernel = context.httpKernel;
 	if (!gone && kernel !== null && !kernel.acquireConnectionSlot(context.request.request, nodeResponse)) throw new HttpError(`${label} : trop de connexions ouvertes depuis cette adresse`, 429, context);
@@ -255,7 +562,9 @@ function openStreamLifecycle(context, options) {
 		stallTimeout: options.stallTimeout,
 		maxDuration: options.maxDuration,
 		revalidate,
-		identifier
+		identifier,
+		foreignWriter: options.foreignWriter ?? false,
+		endsAtShutdown: options.endsAtShutdown ?? true
 	});
 	if (gone) {
 		lifecycle.finish();
@@ -270,4 +579,4 @@ function openStreamLifecycle(context, options) {
 		return lifecycle;
 	});
 }
-export { MAX_TIMER_MS, StreamLifecycle, checkStreamTimer, openStreamLifecycle };
+export { MAX_TIMER_MS, SHUTDOWN_STREAMS_WAIT_MS, STALL_SWEEP_PERIOD_MS, STREAM_STALL_TIMEOUT_MS, ShutdownRegistry, StallSweep, StreamLifecycle, checkStreamTimer, disarmResponseTimeout, openStreamLifecycle, resolveStreamTarget };