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

package/dist/nodefony/service/servers/server-websocket.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.ts
@@ -50,7 +50,7 @@ let Websocket = class Websocket 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);

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

@@ -1,5 +1,5 @@
+import { ANNOUNCE_CAP_MS, announceSessionClose } from "../../src/servers/http2Goaway.js";
 import http from "node:http";
-import { constants } from "node:http2";
 import https from "node:https";
 import tls from "node:tls";
 // nodefony/service/servers/serverShutdown.ts
@@ -21,8 +21,8 @@ import tls from "node:tls";
 *
 * ⚠️ Les sockets WebSocket upgradées (sans réponse HTTP en cours) sont détruites
 * SANS frame Close → les serveurs WS doivent fermer leurs clients (close 1001)
-* AVANT ce drain. Garanti par l'ordre des listeners `onTerminate` : WS/WSS
-* s'attachent en `prependOnceListener`, les serveurs HTTP en `once`.
+* AVANT ce drain. Garanti par `HttpKernel.drainTraffic` (ADR-0027 D2) : l'étape
+* `dismiss` (1001) est attendue avant l'étape `drain`.
 *
 * @param server - serveur Node à drainer, créé AVANT son `listen` (le suivi des
 *   connexions commence ici)
@@ -84,27 +84,19 @@ function createDrainTerminator(server, shutdownTimeout) {
 		return terminating;
 	} };
 }
-/** Plus long délai d'annonce (ms) : un pair qui ne répond pas au PING ne retient pas l'arrêt. */
-const ANNOUNCE_CAP_MS = 1e3;
-/** Plus grand identifiant de flux (RFC 9113 §6.8) : « aucun flux n'est encore écarté ». */
-const LAST_POSSIBLE_STREAM = 2 ** 31 - 1;
 /**
-* Annonce l'arrêt à chaque session HTTP/2 SANS écarter un flux déjà en route :
-* un PING mesure l'aller-retour, puis GOAWAY à `2^31-1`, puis l'attente de cet
-* aller-retour — après elle, tout flux ouvert par le client avant l'annonce est
-* arrivé. Le GOAWAY définitif (`session.close()`, dernier flux traité) suit
-* dans `done`. Un pair qui ne répond pas au PING est réglé au délai `cap`.
-* RFC 9113 §6.8 : « SHOULD send an initial GOAWAY frame with the last stream
-* identifier set to 2^31-1 […] After allowing time for any in-flight stream
-* creation (at least one round-trip time) ». Sans annonce, un flux croisé avec
-* le GOAWAY est refusé alors qu'il aurait pu être servi.
+* Annonce l'arrêt à chaque session HTTP/2 SANS écarter un flux déjà en route —
+* l'annonce en deux temps de RFC 9113 §6.8, session par session
+* ({@link announceSessionClose}, la même règle que la fermeture d'une session
+* inactive). Le GOAWAY définitif (`session.close()`) suit dans `done`. Un pair
+* qui ne répond pas au PING est réglé au délai `cap`.
 *
 * @param sessions - sessions HTTP/2 ouvertes, `null` pour un serveur HTTP/1.1
 * @param cap - délai maximal d'attente des échos (ms)
 * @param done - appelé UNE fois, quand tous les échos sont revenus ou au délai
 */
 function announceShutdown(sessions, cap, done) {
-	let pending = 0;
+	let pending = 1;
 	let finished = false;
 	const finish = () => {
 		if (finished) return;
@@ -112,30 +104,16 @@ function announceShutdown(sessions, cap, done) {
 		clearTimeout(timer);
 		done();
 	};
+	const settle = () => {
+		if (--pending === 0) finish();
+	};
 	const timer = setTimeout(finish, cap);
 	if (sessions !== null) for (const session of sessions) {
 		if (session.closed || session.destroyed) continue;
-		let settled = false;
-		let wait = null;
-		const settle = () => {
-			if (settled) return;
-			settled = true;
-			if (wait !== null) clearTimeout(wait);
-			session.removeListener("close", settle);
-			if (--pending === 0) finish();
-		};
 		pending++;
-		session.once("close", settle);
-		if (!session.ping((error, rttMs) => {
-			if (error !== null || settled || session.closed) return settle();
-			session.goaway(constants.NGHTTP2_NO_ERROR, LAST_POSSIBLE_STREAM);
-			wait = setTimeout(settle, Math.max(1, Math.ceil(rttMs)));
-		})) {
-			session.goaway(constants.NGHTTP2_NO_ERROR, LAST_POSSIBLE_STREAM);
-			settle();
-		}
+		announceSessionClose(session, settle);
 	}
-	if (pending === 0) finish();
+	settle();
 }
 function track(set, socket) {
 	set.add(socket);

package/dist/nodefony/service/sessions/sessions-service.js

@@ -2,8 +2,8 @@ import Session from "../../src/session/session.js";
 import MemorySessionStorage from "../../src/session/storage/MemorySessionStorage.js";
 import RevocationGuardStorage from "../../src/session/storage/RevocationGuardStorage.js";
 import { SESSION_FACETS } from "../../src/session/storage/sessionFilters.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 { AUTO_STORE, EMPTY_INFRA, GcScheduler, Inject, Nodefony, RequestContext, Service, countFacets, extend, injectable, readStoreConnector, readStoreLocation, resolveAutoStore, storeConnectivity } from "nodefony";
 import { createHash, createHmac } from "node:crypto";
 // nodefony/service/sessions/sessions-service.ts
@@ -125,10 +125,6 @@ let SessionsService = class SessionsService extends Service {
 		this.module = module;
 		this.certificates = this.get("certificates");
 		this.defaultSessionName = this.options.name;
-		this.once("onTerminate", () => {
-			this.gcScheduler?.stop();
-			if (this.storage) this.storage.close();
-		});
 	}
 	async init() {
 		this.secret = this.createSecret();
@@ -184,6 +180,10 @@ let SessionsService = class SessionsService extends Service {
 				onError: (e) => this.log(e, "WARNING", "SESSION-GC")
 			});
 			this.gcScheduler.start();
+			this.kernel?.once("onTerminate", () => {
+				this.gcScheduler?.stop();
+				this.storage?.close();
+			});
 		});
 		return this.storage;
 	}

package/dist/nodefony/service/upload/upload-service.js

@@ -1,5 +1,5 @@
-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 { Cli, FileClass, Inject, Service } from "nodefony";
 import fs from "node:fs";
 import fsp from "node:fs/promises";

package/dist/nodefony/src/context/Context.js

@@ -3,9 +3,9 @@ import { protocolNameOf } from "./transport.js";
 import { resolveTimingMode } from "./timingMode.js";
 import Cookie, { cookiesParser } from "../cookies/cookie.js";
 import { RequestContext, Service, logColor } from "nodefony";
+import { AsyncResource } from "node:async_hooks";
 import { randomFillSync, randomUUID } from "node:crypto";
 import { performance } from "node:perf_hooks";
-import { AsyncResource } from "node:async_hooks";
 // nodefony/src/context/Context.ts
 const colorLogEvent = () => logColor.cyanBgBlack("EVENT CONTEXT");
 const PERF_PROBE_SUB = process.env.NF_PERF_PROBE === "1";
@@ -356,6 +356,17 @@ var Context = class extends Service {
 	holdRequestStore(store) {
 		this.requestStore = store;
 	}
+	/**
+	* L'utilisateur authentifié de l'unité de travail, lu sur son magasin et
+	* non sur l'ALS : valable là où la bulle n'est plus active (rendu d'une
+	* erreur, démontage). Même règle que `RequestContext.getAuthenticatedUser`.
+	*
+	* @returns l'utilisateur connecté, ou `null` (anonyme, hors zone, nettoyé).
+	*/
+	authenticatedUser() {
+		const store = this.requestStore;
+		return store === null ? null : RequestContext.authenticatedUserOf(store);
+	}
 	clean() {
 		this.cleaned = true;
 		this.httpKernel = null;

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

@@ -1,5 +1,5 @@
 import HttpError from "../../errors/httpError.js";
-import "./SseStream.js";
+import { SSE_STALL_TIMEOUT_MS } from "./SseStream.js";
 import { MAX_TIMER_MS, checkStreamTimer, openStreamLifecycle } from "./StreamLifecycle.js";
 import http from "node:http";
 import { AsyncResource } from "node:async_hooks";
@@ -330,8 +330,9 @@ function openByteStream(context, source, options = {}) {
 		settings = settingsOf(context, options);
 		opened = openStreamLifecycle(context, {
 			label: "Flux",
-			stallTimeout: options.stallTimeout ?? 3e4,
-			maxDuration: options.maxDuration ?? false
+			stallTimeout: options.stallTimeout ?? SSE_STALL_TIMEOUT_MS,
+			maxDuration: options.maxDuration ?? false,
+			endsAtShutdown: settings.live
 		});
 	} catch (error) {
 		readable.on("error", IGNORE_LATE_ERROR);
@@ -343,7 +344,11 @@ function openByteStream(context, source, options = {}) {
 		stream.start();
 		return stream.done;
 	};
-	return opened instanceof Promise ? opened.then(start) : start(opened);
+	if (opened instanceof Promise) {
+		readable.on("error", IGNORE_LATE_ERROR);
+		return opened.then(start);
+	}
+	return start(opened);
 }
 /** Les réglages du flux, défauts résolus sur le contexte. */
 function settingsOf(context, options) {

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

@@ -11,6 +11,7 @@ import { responseEnded } from "../responseEnded.js";
 import { alpnProtocolOf } from "../transport.js";
 import { openSseStream } from "./SseStream.js";
 import { openByteStream } from "./ByteStream.js";
+import { webResponseParts } from "./webResponse.js";
 import { finallyMaybe, isPromise, thenMaybe, typeOf } from "nodefony";
 import net from "node:net";
 import url, { URL } from "node:url";
@@ -33,7 +34,7 @@ function switchUrlScheme(from, scheme, port) {
 const socketActiveContext = /* @__PURE__ */ new WeakMap();
 /**
 * Route le délai d'inactivité d'une socket HTTP/1.1 vers la requête qu'elle
-* porte : 408/504 si une requête est en cours, fermeture si la connexion
+* porte : 503 si une requête est en cours, fermeture si la connexion
 * persistante est inactive. Écouteur `timeout` du SERVEUR — un seul pour
 * toutes ses connexions —, que Node appelle avec la socket en argument
 * (`socketOnTimeout` → `server.emit("timeout", socket)`).
@@ -49,7 +50,8 @@ const socketActiveContext = /* @__PURE__ */ new WeakMap();
 * serveur supprime aussi une fermeture et une entrée de registre par connexion.
 *
 * @param socket - la socket dont le délai a expiré ; une session HTTP/2 (même
-*   événement sur un serveur `allowHTTP1`) est laissée à son propre délai
+*   événement sur un serveur `allowHTTP1`) est fermée par l'écouteur que pose
+*   `setHttp2SessionTimeout` (`src/servers/http2Limits.ts`)
 */
 function routeSocketTimeout(socket) {
 	if (!(socket instanceof net.Socket)) return;
@@ -72,6 +74,15 @@ var HttpContext = class extends Context {
 	* son montage. `null` = servie par l'application (cas de toute requête).
 	*/
 	relayAccessLog = null;
+	/**
+	* L'appel RPC servi sur cette requête (gRPC, gRPC-Web, Connect), `null`
+	* hors appel RPC (ADR-0026 D10) : un champ, aucune allocation. Posé par le
+	* point d'entrée gRPC ; à l'échéance du délai de réponse, {@link _onTimeout}
+	* le termine au lieu d'écrire un 503.
+	*
+	* @experimental Surface gRPC, ADR-0026 D11.
+	*/
+	rpc = null;
 	request;
 	response;
 	uploadService;
@@ -142,11 +153,34 @@ var HttpContext = class extends Context {
 	_onTimeout() {
 		if (this.listenerCount("onTimeout")) this.fire("onTimeout", this);
 		this._abortIfPending("Request timeout");
+		if (this.rpc !== null) {
+			this.rpc.expire();
+			return;
+		}
 		this.httpKernel?.warnUnsentResponse(this);
-		let error;
-		if (this.response.stream) error = new HttpError("Gateway Timeout", 504, this);
-		else error = new HttpError("Request Timeout", 408, this);
-		this.httpKernel?.onError(error, this);
+		this.httpKernel?.onError(new HttpError("Service Unavailable", 503, this), this);
+	}
+	/**
+	* Ré-arme le délai de réponse de la requête à la valeur propre de sa route
+	* (`responseTimeout` d'une option de route), une fois celle-ci résolue.
+	*
+	* Même mécanisme que {@link setTimeout} — délai d'inactivité de la socket
+	* (HTTP/1.1) ou du flux (HTTP/2) —, sans second écouteur : sous HTTP/2,
+	* `setTimeout(ms)` sans rappel remplace le minuteur et garde celui posé par
+	* {@link setTimeout}. `0` désactive le délai pour la requête.
+	*
+	* @param ms - délai de la route, en millisecondes.
+	*/
+	rearmTimeout(ms) {
+		this.response.setTimeout(ms);
+		const res = this.response.response;
+		if (!res) return;
+		if (this.response.stream) {
+			res.setTimeout(ms);
+			return;
+		}
+		const socket = this.activeSocket;
+		if (socket && socket.timeout !== ms) socket.setTimeout(ms);
 	}
 	setScheme() {
 		const req = this.request;
@@ -173,6 +207,8 @@ var HttpContext = class extends Context {
 		if (kernel && (kernel.debug || kernel.listenerCount("onRequest") > 0)) kernel.fire("onRequest", this);
 		if (!this.resolver && this.router) this.resolver = this.router.resolve(this);
 		if (this.resolver?.resolve) {
+			const routeTimeout = this.resolver.route?.responseTimeout;
+			if (routeTimeout !== void 0 && routeTimeout !== null) this.rearmTimeout(routeTimeout);
 			this.setMetaData();
 			return this.resolver.callController();
 		}
@@ -199,17 +235,32 @@ var HttpContext = class extends Context {
 	* réellement rendu (le relais écrit la réponse brute, pas celle du
 	* contexte) ; un montage `accessLog: "errors"` ne l'écrit qu'en échec.
 	*
+	* Le statut natif n'est recopié que si la réponse a été TERMINÉE
+	* ({@link responseEnded}) : sinon il n'a jamais atteint le client (200 par
+	* défaut de Node), et le statut du contexte — 499 d'un client parti — dit
+	* vrai. Règle unique pour toute réponse écrite par un tiers (#695, critère
+	* 38).
+	*
 	* @param httpError - l'erreur de la requête, s'il y en a une
 	*/
 	logRequest(httpError) {
+		if (this.rpc !== null) this.adoptNativeStatus();
 		if (this.relayAccessLog !== null) {
-			const raw = this.response.response;
-			if (raw !== null) this.response.statusCode = raw.statusCode;
+			this.adoptNativeStatus();
 			if (this.relayAccessLog === "errors" && this.response.statusCode < 400 && !httpError && !this.error) return;
 		}
 		return super.logRequest(httpError);
 	}
 	/**
+	* Reprend le statut de la réponse native, écrite par un tiers (relais,
+	* adaptateur RPC) — si la réponse est TERMINÉE seulement : sinon ce statut
+	* n'a jamais atteint le client, et celui du contexte (499) dit vrai.
+	*/
+	adoptNativeStatus() {
+		const raw = this.response.response;
+		if (raw !== null && responseEnded(raw)) this.response.statusCode = raw.statusCode;
+	}
+	/**
 	* Nettoie le contexte, et le DÉTACHE de sa socket h1 : la connexion
 	* persistante survit à la requête, et l'entrée de `socketActiveContext`
 	* retiendrait sinon tout le contexte jusqu'à sa fermeture. Seule l'entrée qui
@@ -382,6 +433,33 @@ var HttpContext = class extends Context {
 	openStream(source, options) {
 		return openByteStream(this, source, options);
 	}
+	/**
+	* Répond par une `Response` Web standard — celle que rend `fetch()`, ou une
+	* réponse construite (`new Response(…)`, `Response.json(…)`) : son statut,
+	* ses en-têtes, et son corps EN FLUX, jamais lu d'avance.
+	*
+	* C'est ce que fait le framework quand une action renvoie une `Response`.
+	* Une réponse relayée (issue de `fetch`) perd `content-encoding`,
+	* `content-length` et `set-cookie` de l'amont ; une réponse construite garde
+	* les siens. Les en-têtes de connexion ne partent jamais. Le reste — arrêt au
+	* départ du client, contre-pression, délais, HEAD sans lire le corps — est
+	* celui de {@link HttpContext.openStream}.
+	*
+	* @param response - une `Response` dont le corps n'a pas été consommé.
+	* @param options - délais et écouteur de fin ; statut et en-têtes viennent de la réponse.
+	* @returns la raison de la fin et le nombre d'octets ; ne rejette jamais.
+	* @throws HttpError 502 pour `Response.error()` (statut 0, aucune réponse) ;
+	*   les cas de {@link HttpContext.openStream} sinon.
+	*/
+	openWebResponse(response, options) {
+		if (response.type === "error") throw new HttpError("Réponse Web en erreur : Response.error() ne porte aucune réponse", 502, this);
+		const parts = webResponseParts(response);
+		return openByteStream(this, parts.source, {
+			...options,
+			status: parts.status,
+			headers: parts.headers
+		});
+	}
 	flush(chunk, encoding) {
 		return this.response.flush(chunk, encoding);
 	}

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

@@ -23,6 +23,18 @@ const reg = /(.*)[[][\]]$/u;
 const unlinkQuiet = (p) => fsp.unlink(p).catch(() => void 0);
 var BodyHandled = class {};
 const BODY_DONE = new BodyHandled();
+/**
+* Une réception multipart EN COURS, interruptible de l'extérieur : `fail` rompt
+* la lecture comme le ferait un dépassement de limite (temporaires nettoyés).
+* Posée dans `request.parser` le temps de la lecture seulement — l'allocation
+* est réservée au multipart, déjà lourd.
+*/
+var MultipartReception = class {
+	fail;
+	constructor(fail) {
+		this.fail = fail;
+	}
+};
 const CHARSET_ALIASES = {
 	"utf-8": "utf8",
 	utf8: "utf8",
@@ -128,6 +140,9 @@ var HttpRequest = class {
 	* temporaire — lus par `@UploadedFile()` / `@UploadedFiles()`. Les champs
 	* texte du même corps sont dans {@link body}.
 	*
+	* Ces temporaires sont EFFACÉS à la fin de la requête : pour garder un
+	* fichier, l'action le déplace (`moveAsync`) avant de répondre.
+	*
 	* Lecture seule : une requête sans upload rend un vide partagé et gelé,
 	* aucune allocation.
 	*/
@@ -271,6 +286,25 @@ var HttpRequest = class {
 		}
 	}
 	/**
+	* Lit le plafond du corps et les limites d'envoi tels que les voit CETTE
+	* requête : la configuration http, surchargée par le calque que la requête a
+	* pu poser avant la lecture du corps (`overlayConfig`, #494), puis par les
+	* bornes que la route déclare pour elle-même (option de route `upload`). La
+	* route est déjà résolue à ce moment : une route sans bornes propres
+	* n'alloue rien. Hors pipeline (aucun scope ouvert), la configuration du
+	* module telle quelle.
+	*/
+	readBodyLimits() {
+		const options = RequestContext.getScope() !== void 0 ? useConfig("@nodefony/http") : this.context.httpKernel?.module.options;
+		const base = options?.upload ?? {};
+		const route = this.context.resolver?.route?.upload;
+		this.uploadOption = route ? {
+			...base,
+			...route
+		} : base;
+		this.maxBodySize = options?.maxBodySize ?? 0;
+	}
+	/**
 	* B1 — Pré-contrôle de taille du corps via l'en-tête `Content-Length` :
 	* rejette en 413 (RFC 9110 §15.5.14 « Content Too Large ») AVANT toute lecture
 	* quand le client annonce une taille supérieure à `maxBodySize`. Rideau de
@@ -279,17 +313,6 @@ var HttpRequest = class {
 	*
 	* @throws {HttpError} 413 si `Content-Length` dépasse `maxBodySize`.
 	*/
-	/**
-	* Lit le plafond du corps et les limites d'envoi tels que les voit CETTE
-	* requête : la configuration http, surchargée par le calque que la requête a
-	* pu poser avant la lecture du corps (`overlayConfig`, #494). Hors pipeline
-	* (aucun scope ouvert), la configuration du module telle quelle.
-	*/
-	readBodyLimits() {
-		const options = RequestContext.getScope() !== void 0 ? useConfig("@nodefony/http") : this.context.httpKernel?.module.options;
-		this.uploadOption = options?.upload ?? {};
-		this.maxBodySize = options?.maxBodySize ?? 0;
-	}
 	enforceBodyLimit() {
 		const max = this.maxBodySize;
 		if (max <= 0) return;
@@ -366,6 +389,7 @@ var HttpRequest = class {
 			return this.parser;
 		}
 		const { fields, files } = await this.streamMultipart(bb);
+		this.parser = null;
 		this.body = fields;
 		for (const pf of files) await this.createFileUpload(pf.field, pf.file);
 		this.context.requestEnded = true;
@@ -385,18 +409,33 @@ var HttpRequest = class {
 		return new Promise((resolve, reject) => {
 			const fields = {};
 			const files = [];
+			let order = 0;
 			const pending = [];
 			const tempPaths = [];
 			const openStreams = /* @__PURE__ */ new Set();
 			let totalBytes = 0;
 			let aborted = false;
+			let received = false;
 			const abort = (err) => {
 				if (aborted) return;
 				aborted = true;
 				this.request.unpipe(bb);
 				this.request.resume();
-				for (const ws of openStreams) ws.destroy();
-				Promise.all(tempPaths.map(unlinkQuiet)).finally(() => reject(err));
+				const purge = () => {
+					Promise.all(tempPaths.map(unlinkQuiet)).finally(() => reject(err));
+				};
+				let closing = openStreams.size;
+				if (closing === 0) {
+					purge();
+					return;
+				}
+				for (const ws of openStreams) {
+					ws.once("close", () => {
+						closing -= 1;
+						if (closing === 0) purge();
+					});
+					ws.destroy();
+				}
 			};
 			bb.on("field", (name, value) => {
 				if (aborted) return;
@@ -407,6 +446,8 @@ var HttpRequest = class {
 					stream.resume();
 					return;
 				}
+				const slot = order;
+				order += 1;
 				const field = reg.exec(fieldname)?.[1] ?? fieldname;
 				const ext = filename ? path.extname(filename) : "";
 				const newFilename = `${randomUUID()}${ext}`;
@@ -431,7 +472,7 @@ var HttpRequest = class {
 					ws.on("close", () => {
 						openStreams.delete(ws);
 						if (aborted) return res();
-						files.push({
+						files[slot] = {
 							field,
 							file: {
 								filepath,
@@ -443,7 +484,7 @@ var HttpRequest = class {
 								hashAlgorithm: algo,
 								hash: hasher ? hasher.digest("hex") : null
 							}
-						});
+						};
 						res();
 					});
 				});
@@ -455,6 +496,7 @@ var HttpRequest = class {
 			bb.on("partsLimit", () => abort(new HttpError("too many parts", 413, this.context)));
 			bb.on("error", (e) => abort(e instanceof Error ? e : new Error(String(e))));
 			bb.on("finish", () => {
+				received = true;
 				if (aborted) return;
 				Promise.all(pending).then(() => {
 					if (!aborted) resolve({
@@ -463,10 +505,32 @@ var HttpRequest = class {
 					});
 				}).catch(abort);
 			});
+			this.parser = new MultipartReception((error) => {
+				if (aborted || received) return false;
+				abort(error);
+				return true;
+			});
 			this.request.pipe(bb);
 		});
 	}
 	/**
+	* Interrompt la réception du corps en cours : la promesse de `initialize()`
+	* rejette avec `error`, rendue par le chemin d'erreur habituel — comme un
+	* corps qui dépasse sa limite (413).
+	*
+	* Sert le délai de réception HTTP/2 (`requestTimeout`), que `node:http2` ne
+	* borne pas. Sans effet hors réception : corps déjà reçu, lu en flux par
+	* l'action (`bodyStream`), ou méthode sans corps.
+	*
+	* @param error - la cause rendue au client (408 au délai dépassé)
+	* @returns vrai si une réception en cours a été interrompue
+	*/
+	abortBody(error) {
+		const parser = this.parser;
+		if (parser instanceof Parser || parser instanceof MultipartReception) return parser.fail(error);
+		return false;
+	}
+	/**
 	* Accumule un champ texte multipart. `foo[]` (ou répétition de `foo`) →
 	* tableau ; sinon valeur scalaire. (Anciennement délégué à formidable.)
 	*/
@@ -499,9 +563,25 @@ var HttpRequest = class {
 	}
 	async createFileUpload(name, file) {
 		const fileUpload = await this.context.uploadService?.createUploadFile(file, name);
-		if (fileUpload) (this.#uploads ??= []).push(fileUpload);
+		if (fileUpload) {
+			if (this.#uploads === null) {
+				this.#uploads = [];
+				this.context.onAfterResponse(() => this.#purgeUploads());
+			}
+			this.#uploads.push(fileUpload);
+		}
 		return fileUpload;
 	}
+	/**
+	* Efface, une fois la requête terminée (réponse envoyée ou client parti),
+	* les temporaires que l'action n'a pas déplacés — la règle de PHP. Un
+	* fichier déplacé (`move`/`moveAsync`) n'est plus à son chemin temporaire :
+	* l'effacement n'y trouve rien, et l'erreur est ignorée.
+	*/
+	#purgeUploads() {
+		const uploads = this.#uploads ?? NO_FILES;
+		return Promise.all(uploads.map((upload) => unlinkQuiet(upload.parsedFile.filepath))).then(() => void 0);
+	}
 	getMethod() {
 		return this.request.method;
 	}