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

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

@@ -0,0 +1,582 @@
+import Http2Response from "../http2/Response.js";
+import HttpError from "../../errors/httpError.js";
+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
+/**
+* Cycle de vie d'une réponse en flux — la brique commune au flux d'événements
+* (`SseStream`) et au flux d'octets, NON exportée.
+*
+* Elle porte ce qu'un flux doit à la requête qui l'ouvre, quel que soit son
+* format :
+* - la PRISE de la réponse (`sended`), avant toute attente : le noyau ne peut
+*   plus répondre par-dessus, et l'avertissement « réponse non envoyée » se tait ;
+* - la session sauvée AVANT les en-têtes — ses cookies partent avec eux ;
+* - la fermeture lue sur la RÉPONSE, écouteur posé de façon SYNCHRONE à
+*   l'ouverture : un client parti pendant la sauvegarde de la session est vu ;
+* - le délai d'inactivité de la requête désarmé, remplacé par les gardes du
+*   flux : coupure d'un client qui ne lit plus (`stallTimeout`), durée de vie
+*   maximale (`maxDuration`) ;
+* - le plafond de connexions longues par IP (`wsMaxConnectionsPerIp`, le budget
+*   des sockets WebSocket) et la fermeture à la révocation de l'identité ;
+* - une fin unique, et des écouteurs de fin liés au contexte asynchrone.
+*
+* Le FORMAT (en-têtes, écriture, battement de cœur) appartient au flux qui la
+* porte.
+*/
+/**
+* Plus long délai qu'un minuteur sait tenir (2^31-1 ms). Au-delà, Node le
+* ramène à 1 ms : un délai qui le dépasse ferait battre ou couper le flux
+* mille fois par seconde.
+*/
+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`).
+* @param name - nom de l'option.
+* @param value - valeur reçue ; `undefined` et `false` passent.
+* @throws RangeError quand la valeur n'est ni `false` ni un entier entre 1 et 2^31-1.
+*
+* @internal
+*/
+function checkStreamTimer(label, name, value) {
+	if (value === void 0 || value === false) return;
+	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é
+* directement que par les tests.
+*
+* @internal
+*/
+var StreamLifecycle = class StreamLifecycle {
+	context;
+	/** Où l'on écrit : la réponse HTTP/1.1, ou le flux HTTP/2. */
+	target;
+	/** La réponse dont on écoute la fermeture — en HTTP/2, l'objet de compatibilité. */
+	#response;
+	#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;
+	/**
+	* Minuteur de la coupure d'un client qui ne lit plus — créé à la PREMIÈRE
+	* contre-pression, puis réarmé au reste du délai : jamais un minuteur par
+	* épisode (un flux d'octets en connaît un par morceau sur une socket rapide).
+	*/
+	#stall = null;
+	/** Début de l'attente de `drain` en cours (`Date.now()`) ; `0` : aucune. */
+	#stallSince = 0;
+	/** Fin de vie du flux — armée seulement si `maxDuration` est posé. */
+	#lifetime = null;
+	/** Nettoyage du flux qui porte la brique — posé une fois, appelé en premier. */
+	#release = null;
+	/** Écouteurs de fermeture — `null` tant que personne n'en pose (lazy). */
+	#onClose = null;
+	#onResponseClose = () => this.finish();
+	/**
+	* Tour du minuteur de blocage. Le client ne lit plus depuis `stallTimeout` :
+	* on coupe la connexion, comme s'il était parti — la fermeture de la réponse
+	* termine le flux. Une attente plus récente (le client a lu entre-temps) est
+	* réarmée au reste de son délai ; plus d'attente du tout : le minuteur s'éteint.
+	*/
+	#onStall = () => {
+		this.#stall = null;
+		const limit = this.#stallTimeout;
+		if (this.#stallSince === 0 || this.#closed || limit === false) return;
+		const waited = Date.now() - this.#stallSince;
+		if (waited < limit) {
+			this.#stall = setTimeout(this.#onStall, limit - waited);
+			this.#stall.unref();
+			return;
+		}
+		this.#cutStalled();
+	};
+	constructor(context, target, response, settings) {
+		this.context = context;
+		this.target = target;
+		this.#response = response;
+		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) 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() {
+		return this.#closed;
+	}
+	/**
+	* Qui a fermé le flux : le serveur, la coupure d'un client qui ne lit plus,
+	* ou `null` — client parti, ou flux encore ouvert. Lu par le flux qui porte
+	* la brique, dans son nettoyage, pour nommer la raison de la fin.
+	*/
+	get cause() {
+		return this.#cause;
+	}
+	/** L'identité qui a ouvert le flux est-elle toujours valable ? */
+	revalidate() {
+		return this.#revalidate === null ? Promise.resolve(true) : this.#revalidate();
+	}
+	/**
+	* Pose le nettoyage du flux qui porte la brique (minuteurs, attentes) : il
+	* passe AVANT les écouteurs de l'application. Un cycle déjà fermé l'appelle
+	* aussitôt.
+	*/
+	onRelease(release) {
+		if (this.#closed) {
+			release();
+			return;
+		}
+		this.#release = release;
+	}
+	/**
+	* Appelle `listener` à la fermeture du flux, quelle qu'en soit la cause.
+	*
+	* L'écouteur est lié au contexte asynchrone de la requête au moment de
+	* l'enregistrement : la fermeture par le client part de la SOCKET, hors de
+	* la bulle de la requête. Un flux déjà fermé appelle l'écouteur au tour
+	* suivant.
+	*/
+	onClose(listener) {
+		const bound = AsyncResource.bind(listener);
+		if (this.#closed) {
+			queueMicrotask(bound);
+			return;
+		}
+		this.#onClose ??= [];
+		this.#onClose.push(bound);
+	}
+	/**
+	* Arme la coupure d'un client qui ne lit plus — à appeler quand une écriture
+	* attend `drain`. Sans effet si elle est déjà armée ou désactivée.
+	*/
+	armStall() {
+		if (this.#stallTimeout === false || this.#stallSince !== 0 || this.#closed) return;
+		this.#stallSince = Date.now();
+		if (this.#stall !== null) return;
+		this.#stall = setTimeout(this.#onStall, this.#stallTimeout);
+		this.#stall.unref();
+	}
+	/**
+	* Désarme la coupure : le client a repris sa lecture. Le minuteur n'est pas
+	* détruit — il s'éteindra seul à son tour s'il n'y a plus d'attente, ou
+	* resservira à la suivante sans nouvelle allocation.
+	*/
+	clearStall() {
+		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() {
+		disarmResponseTimeout(this.target);
+	}
+	/**
+	* 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;
+		this.#closed = true;
+		this.#response.removeListener("close", this.#onResponseClose);
+		if (this.#lifetime !== null) {
+			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;
+		}
+		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?.();
+		const listeners = this.#onClose;
+		this.#onClose = null;
+		if (listeners !== null) for (const listener of listeners) listener();
+	}
+};
+/**
+* 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 —
+* sans rien écrire : les en-têtes appartiennent au flux. Un client parti
+* pendant la sauvegarde rend un cycle déjà fermé (`closed`) : le flux n'écrit
+* alors rien.
+*
+* @param context - le contexte de la requête, pas encore répondu.
+* @param options - gardes du flux et préfixe des messages.
+* @returns le cycle de vie, ou sa promesse quand une session est à sauver.
+* @throws HttpError 500 quand la réponse est déjà partie, ou que son
+*   transport n'est pas reconnu.
+* @throws HttpError 429 quand l'IP du client a déjà tous ses flux et sockets
+*   (`wsMaxConnectionsPerIp`) — refusé AVANT d'écrire quoi que ce soit.
+*
+* @internal
+*/
+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 nodeResponse = context.response.response;
+	if (nodeResponse === null) throw new HttpError(`${label} : réponse introuvable`, 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);
+	const revalidate = kernel?.firewall?.currentRevalidator?.() ?? null;
+	const identifier = revalidate === null ? null : RequestContext.getAuthenticatedUser()?.identifier ?? null;
+	context.sended = true;
+	const lifecycle = new StreamLifecycle(context, target, nodeResponse, {
+		stallTimeout: options.stallTimeout,
+		maxDuration: options.maxDuration,
+		revalidate,
+		identifier,
+		foreignWriter: options.foreignWriter ?? false,
+		endsAtShutdown: options.endsAtShutdown ?? true
+	});
+	if (gone) {
+		lifecycle.finish();
+		return lifecycle;
+	}
+	if (context.session == null) return lifecycle;
+	return context.saveSession().catch((e) => {
+		context.log(e, "ERROR", "SESSION-STORE");
+		return null;
+	}).then(() => {
+		if (target.destroyed) lifecycle.finish();
+		return lifecycle;
+	});
+}
+export { MAX_TIMER_MS, SHUTDOWN_STREAMS_WAIT_MS, STALL_SWEEP_PERIOD_MS, STREAM_STALL_TIMEOUT_MS, ShutdownRegistry, StallSweep, StreamLifecycle, checkStreamTimer, disarmResponseTimeout, openStreamLifecycle, resolveStreamTarget };

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

@@ -8,8 +8,8 @@ var Parser = class {
 	chunks;
 	received = 0;
 	aborted = false;
-	overflow = null;
-	onOverflow = null;
+	failure = null;
+	onFailure = null;
 	constructor(request) {
 		this.request = request;
 		this.chunks = [];
@@ -22,33 +22,51 @@ var Parser = class {
 		const max = this.request.maxBodySize;
 		this.received += buffer.length;
 		if (max > 0 && this.received > max) {
-			this.aborted = true;
-			this.chunks.length = 0;
-			this.overflow = new HttpError(`Request body exceeds maxBodySize (${max} bytes)`, 413, this.request.context);
-			this.request.request.pause?.();
-			if (this.onOverflow) this.onOverflow(this.overflow);
+			this.fail(new HttpError(`Request body exceeds maxBodySize (${max} bytes)`, 413, this.request.context));
 			return buffer;
 		}
 		this.chunks.push(buffer);
 		return buffer;
 	}
 	/**
+	* Interrompt la réception du corps : `parse()` rejette avec `error`, que
+	* l'interruption survienne avant ou pendant l'attente de la fin du flux.
+	*
+	* La RAM déjà bufferisée est libérée et la lecture du flux suspendue ; la
+	* réponse d'erreur peut encore partir. Sans effet si le corps est déjà
+	* entièrement reçu, ou déjà interrompu.
+	*
+	* @param error - la cause rendue au client (413 dépassement, 408 délai)
+	* @returns vrai si la réception a été interrompue
+	*/
+	fail(error) {
+		const req = this.request.request;
+		if (this.aborted || req.readableEnded === true || req.complete === true) return false;
+		this.aborted = true;
+		this.chunks.length = 0;
+		this.failure = error;
+		req.pause?.();
+		if (this.onFailure) this.onFailure(error);
+		return true;
+	}
+	/**
 	* Résout quand le flux requête est **entièrement reçu** (`end`). No-op si déjà
 	* terminé (corps vide / déjà drainé) → pas de hang d'un `once("end")` tardif.
 	* Indispensable avant de concaténer les chunks pour un corps à décoder
 	* (JSON…) : sinon on lit un buffer encore incomplet. (formidable drainait via
 	* son `await form.parse()` ; ses remplaçants doivent drainer explicitement.)
-	* Rejette en 413 si le corps dépasse `maxBodySize` (avant ou pendant l'attente).
+	* Rejette avec la cause de {@link Parser.fail} (413 dépassement de
+	* `maxBodySize`, 408 délai de réception), avant ou pendant l'attente.
 	*/
 	ended() {
-		if (this.overflow) return Promise.reject(this.overflow);
+		if (this.failure) return Promise.reject(this.failure);
 		const req = this.request.request;
 		return new Promise((resolve, reject) => {
 			if (req.readableEnded || req.complete) return resolve();
 			const cleanup = () => {
 				req.removeListener("end", onEnd);
 				req.removeListener("error", onError);
-				this.onOverflow = null;
+				this.onFailure = null;
 			};
 			const onEnd = () => {
 				cleanup();
@@ -58,7 +76,7 @@ var Parser = class {
 				cleanup();
 				reject(e instanceof Error ? e : new Error(String(e)));
 			};
-			this.onOverflow = (err) => {
+			this.onFailure = (err) => {
 				cleanup();
 				reject(err);
 			};