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

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

@@ -1,8 +1,43 @@
 import Cookie from "../../cookies/cookie.js";
 import { thenMaybe, typeOf } from "nodefony";
-import http from "node:http";
+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;
@@ -15,6 +50,40 @@ const REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
 	308
 ]);
 const NO_CONTENT_LENGTH_STATUS = /* @__PURE__ */ new Set([204, 304]);
+const NO_CONTENT_STATUS = /* @__PURE__ */ new Set([
+	204,
+	205,
+	304
+]);
+/**
+* Vrai pour un statut dont la réponse n'a, par définition, aucun contenu —
+* 204, 205 et 304 (RFC 9110 §15.3.5, §15.3.6, §15.4.5).
+*
+* Seule source de cette liste : la réponse s'en sert pour ne jamais écrire de
+* corps, le résolveur pour terminer une action qui ne rend rien.
+*
+* @param status - le code de statut de la réponse.
+* @returns `true` quand aucun corps ne doit partir.
+*/
+function isContentlessStatus(status) {
+	return NO_CONTENT_STATUS.has(status);
+}
+/** Espace ou tabulation : l'OWS de RFC 9110 §5.6.3. */
+const isOws = (code) => code === 32 || code === 9;
+/**
+* Valeur d'en-tête sans espace de bord (RFC 9110 §5.5 ; RFC 9113 §8.2.1 en fait
+* un MUST NOT en HTTP/2). Ne copie la chaîne que dans le cas rare où il y a
+* quelque chose à rogner.
+*/
+function trimFieldValue(value) {
+	const last = value.length - 1;
+	if (last < 0 || !isOws(value.charCodeAt(0)) && !isOws(value.charCodeAt(last))) return value;
+	let start = 0;
+	let end = last;
+	while (start <= end && isOws(value.charCodeAt(start))) start++;
+	while (end >= start && isOws(value.charCodeAt(end))) end--;
+	return value.slice(start, end + 1);
+}
 const CONTENT_TYPE_CACHE_MAX = 64;
 const contentTypeCache = /* @__PURE__ */ new Map();
 /**
@@ -38,6 +107,26 @@ function resolveContentType(type) {
 	if (contentTypeCache.size < CONTENT_TYPE_CACHE_MAX) contentTypeCache.set(type, resolved);
 	return resolved;
 }
+/**
+* Valeur d'en-tête sous la forme que Node accepte (une liste figée est copiée),
+* rognée de ses espaces de bord.
+*/
+function toHeaderValue(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "string") return trimFieldValue(value);
+	return value.map(trimFieldValue);
+}
+/**
+* Contrôle d'un en-tête comme le fait `setHeader` natif — nom, puis chaque
+* valeur (un nombre est toujours valide).
+*
+* @throws TypeError `ERR_INVALID_HTTP_TOKEN` / `ERR_INVALID_CHAR`.
+*/
+function assertHeader(name, value) {
+	validateHeaderName(name);
+	if (typeof value === "string") validateHeaderValue(name, value);
+	else if (typeof value !== "number") for (const item of value) validateHeaderValue(name, item);
+}
 var HttpResponse = class {
 	context;
 	response;
@@ -46,12 +135,38 @@ var HttpResponse = class {
 	flushing = false;
 	encoding = "utf-8";
 	#text = null;
-	#textEncoding = "utf-8";
+	#textEncoding = "utf8";
 	#buffer = null;
 	contentType = "application/octet-stream";
 	headers = {};
 	timeout;
 	cookies = {};
+	/**
+	* En-têtes posés, remis TELS QUELS en un seul `writeHead(statut, liste)` :
+	* un `setHeader` natif par en-tête coûtait validation, rangement dans la
+	* table de Node puis relecture au `writeHead` — 41 % de plus pour le même
+	* bloc (`micro-write-head.mjs`). Et un seul `setHeader` natif avant le
+	* `writeHead` suffit à faire retomber Node sur son chemin lent.
+	* `null` tant que rien n'est posé ; amorcée avec les en-têtes du transport.
+	*/
+	#headers = null;
+	/**
+	* Pare-feu qui posera les en-têtes de sécurité applicatifs juste avant
+	* l'émission des en-têtes, une fois le type de la réponse fixé : la politique
+	* suit ce type (ADR-0024 §C11). Armé par le noyau HTTP au routage, consommé
+	* une fois ; `null` sans module de sécurité.
+	*/
+	headerPolicy = null;
+	/**
+	* Vrai une fois la réserve recopiée sur la réponse Node ({@link commitHeaders}) :
+	* 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;
@@ -68,16 +183,16 @@ var HttpResponse = class {
 	* contenu (RFC 9110 §8.3), et il n'y en a pas.
 	*/
 	ensureContentTypeHeader() {
-		if (this.response && !this.response.hasHeader("content-type") && !this.#isBodyless()) this.response.setHeader("content-type", this.contentType);
+		if (this.response && !this.hasHeader("content-type") && !this.#isBodyless()) this.setHeader("content-type", this.contentType);
 	}
 	/**
-	* Vrai quand la réponse n'a pas de corps : 204 et 304 n'en ont jamais
-	* (RFC 9110 §15.3.5, §15.4.5) ; ailleurs, un corps posé et VIDE. Un corps
-	* jamais posé ne dit rien — un flux peut suivre l'en-tête — et `HEAD` rend
-	* les en-têtes du `GET` (§9.3.2) : tous deux gardent le défaut.
+	* Vrai quand la réponse n'a pas de corps : 204, 205 et 304 n'en ont jamais
+	* (RFC 9110 §15.3.5, §15.3.6, §15.4.5) ; ailleurs, un corps posé et VIDE. Un
+	* corps jamais posé ne dit rien — un flux peut suivre l'en-tête — et `HEAD`
+	* rend les en-têtes du `GET` (§9.3.2) : tous deux gardent le défaut.
 	*/
 	#isBodyless() {
-		if (NO_CONTENT_LENGTH_STATUS.has(this.statusCode)) return true;
+		if (NO_CONTENT_STATUS.has(this.statusCode)) return true;
 		if (this.context.method === "HEAD") return false;
 		if (this.#text !== null) return this.#text === "" && !this.flushing;
 		return this.#buffer?.length === 0 && !this.flushing;
@@ -100,9 +215,12 @@ var HttpResponse = class {
 	/**
 	* Corps tel qu'il part sur le fil : le texte s'il n'a jamais été encodé, sinon
 	* les octets — vide légal si rien n'a été posé (`write(null)` jetterait
-	* ERR_STREAM_NULL_VALUES).
+	* ERR_STREAM_NULL_VALUES). Vide aussi sous un statut sans contenu : un corps
+	* posé par l'application sous un 205 ne part pas (RFC 9110 §15.3.6) — Node
+	* ne l'écarte de lui-même que pour 204 et 304.
 	*/
 	get payload() {
+		if (NO_CONTENT_STATUS.has(this.statusCode)) return "";
 		return this.#text ?? this.#buffer ?? "";
 	}
 	/** Encodage à passer avec {@link payload} (ignoré par Node pour des octets). */
@@ -113,6 +231,7 @@ var HttpResponse = class {
 		this.response = null;
 		this.body = null;
 		this.cookies = {};
+		this.#headers = null;
 	}
 	isHeaderSent() {
 		if (this.response) return this.response.headersSent;
@@ -126,7 +245,10 @@ var HttpResponse = class {
 		this.timeout = ms;
 	}
 	addCookie(cookie) {
-		if (cookie instanceof Cookie) return this.cookies[cookie.name] = cookie;
+		if (cookie instanceof Cookie) {
+			cookie.assertGrammar();
+			return this.cookies[cookie.name] = cookie;
+		}
 		throw new Error("Response addCookies not valid cookies");
 	}
 	deleteCookie(cookie) {
@@ -150,19 +272,22 @@ var HttpResponse = class {
 		const cookies = Object.values(this.cookies);
 		const first = cookies.at(0);
 		if (first === void 0) return;
-		if (cookies.length === 1) return this.setCookie(first);
+		if (cookies.length === 1) {
+			this.setCookie(first);
+			return;
+		}
 		const serialized = [];
 		for (const cookie of cookies) {
 			const s = cookie.serialize();
 			this.logCookie(cookie, s);
 			serialized.push(s);
 		}
-		return this.setHeader("Set-Cookie", serialized);
+		this.setHeader("Set-Cookie", serialized);
 	}
 	setCookie(cookie) {
 		const serialize = cookie.serialize();
 		this.logCookie(cookie, serialize);
-		return this.setHeader("Set-Cookie", serialize);
+		this.setHeader("Set-Cookie", serialize);
 	}
 	/**
 	* Journalise en DEBUG un cookie posé, sa VALEUR MASQUÉE : nom et attributs
@@ -181,20 +306,219 @@ var HttpResponse = class {
 		const attrs = serialized.indexOf("; ", cookie.name.length + 1);
 		this.log(`ADD COOKIE ==> ${cookie.name}=<masqué>${attrs === -1 ? "" : serialized.slice(attrs)}`, "DEBUG", msgid);
 	}
+	/**
+	* Pose un en-tête de la réponse ; en flux chunké déjà ouvert, le range en
+	* trailer. Le nom et la valeur sont VALIDÉS ici, comme le ferait Node : une
+	* valeur invalide (saut de ligne…) lève tout de suite et n'entre jamais dans
+	* la réserve — sinon elle lèverait au `writeHead`, et la page d'erreur
+	* rejouerait le même en-tête.
+	*
+	* @param name - nom de l'en-tête (casse indifférente).
+	* @param value - valeur ; une liste émet une ligne par élément (`Set-Cookie`).
+	* @throws TypeError `ERR_INVALID_HTTP_TOKEN` / `ERR_INVALID_CHAR` sur un nom
+	*   ou une valeur qu'un en-tête HTTP ne peut pas porter.
+	*/
 	setHeader(name, value) {
 		if (this.response) {
 			if (this.flushing) {
 				const obj = {};
-				obj[name] = value;
+				obj[name] = toHeaderValue(value);
 				this.addTrailers(obj);
 				return;
 			}
 			if (!this.response.headersSent) {
+				assertHeader(name, value);
 				const lower = name.toLowerCase();
-				if (lower === "vary") return this.response.setHeader(lower, this.#mergeVary(value));
-				return this.response.setHeader(lower, value);
+				this.#put(lower, lower === "vary" ? this.#mergeVary(value) : toHeaderValue(value));
+			}
+		}
+	}
+	/**
+	* Pose un en-tête dont la valeur a DÉJÀ été validée par l'appelant — une
+	* table figée et contrôlée au démarrage (en-têtes de sécurité). Node la
+	* validera une fois, au `writeHead` ; la revalider ici effaçait le gain de
+	* l'écriture groupée (`micro-write-head.mjs`, ligne « plat validé »).
+	*
+	* ⚠️ Jamais pour une valeur venue d'une requête : elle passe par {@link setHeader}.
+	*
+	* @param name - nom de l'en-tête (casse indifférente).
+	* @param value - valeur contrôlée au démarrage.
+	*/
+	setValidatedHeader(name, value) {
+		if (this.response === null || this.response.headersSent) return;
+		if (this.flushing) {
+			this.setHeader(name, value);
+			return;
+		}
+		this.#put(name.toLowerCase(), value);
+	}
+	/**
+	* Pose un en-tête validé au démarrage SAUF si la réponse en porte déjà un :
+	* la valeur du framework est un défaut, celle que l'application a écrite
+	* gagne. Même coût que {@link setValidatedHeader} — le rangement cherche
+	* l'en-tête de toute façon.
+	*
+	* @param name - nom de l'en-tête (casse indifférente).
+	* @param value - valeur contrôlée au démarrage.
+	*/
+	setDefaultHeader(name, value) {
+		if (this.response === null || this.response.headersSent) return;
+		const lower = name.toLowerCase();
+		if (this.flushing) {
+			if (!this.hasHeader(lower)) this.setHeader(name, value);
+			return;
+		}
+		if (this.#indexOf(lower) === -1) this.#store().push(lower, value);
+	}
+	/**
+	* Pose les en-têtes de la politique armée ({@link headerPolicy}) pour une
+	* réponse de type `contentType` — une fois, juste avant l'émission.
+	*
+	* Un `304` n'en reçoit aucun : ses en-têtes REMPLACENT ceux de la
+	* représentation en cache (RFC 9111 §4.3.4). Une politique courte y
+	* réduirait la page gardée, un nonce neuf la désaccorderait de ses balises.
+	*
+	* @param contentType - type de la réponse ; `null` = sans contenu ; `undefined`
+	*   = inconnu (politique complète).
+	* @param servedAsFile - corps écrit par un tiers (fichier statique, relais),
+	*   qui ne peut pas porter de nonce.
+	*/
+	applyHeaderPolicy(contentType, servedAsFile = false) {
+		const policy = this.headerPolicy;
+		if (policy === null) return;
+		this.headerPolicy = null;
+		if (this.statusCode === 304) return;
+		policy.applySecurityHeaders(this.context, contentType, servedAsFile);
+	}
+	/**
+	* Type qui choisit la politique : `null` pour une réponse sans contenu (204,
+	* corps vide) — même si un `Content-Type` y a été posé, rien n'y sera rendu ;
+	* sinon le `Content-Type` posé.
+	*/
+	contentTypeForPolicy() {
+		if (this.#isBodyless()) return null;
+		const value = this.getHeader("content-type");
+		return typeof value === "string" ? value : null;
+	}
+	/**
+	* La réserve, amorcée au premier usage avec les en-têtes du transport
+	* (`Server`, `X-Content-Type-Options`, `X-Frame-Options`, HSTS) que le
+	* noyau a figés au démarrage — posés EN TÊTE, comme à l'entrée de la requête.
+	*/
+	#store() {
+		if (this.#headers === null) {
+			const transport = this.#committed ? null : this.context.httpKernel?.transportHeaders(this.context.serverType);
+			this.#headers = transport ? [...transport] : [];
+		}
+		return this.#headers;
+	}
+	/** Position du nom (minuscules) dans la réserve, ou -1. */
+	#indexOf(lower) {
+		const list = this.#headers;
+		if (list === null) return -1;
+		for (let i = 0; i < list.length; i += 2) if (list[i] === lower) return i;
+		return -1;
+	}
+	/** Range un en-tête, en remplaçant sa valeur s'il est déjà posé. */
+	#put(lower, value) {
+		const list = this.#store();
+		const at = this.#indexOf(lower);
+		if (at === -1) list.push(lower, value);
+		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,
+	* 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(contentType) {
+		const res = this.response;
+		if (res === null || res.headersSent) return;
+		if (this.headerPolicy !== null) {
+			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];
+			const value = list[i + 1];
+			if (typeof name === "string" && value !== void 0) res.setHeader(name, value);
+		}
+		this.#headers = null;
+		this.#committed = true;
+	}
+	/**
+	* Recopie la réserve sur la réponse Node au PREMIER `setHeader` qu'un tiers
+	* y fera — fichier statique servi, redirection de dossier — et seulement
+	* alors : un raté du repli statique (la 404 d'une route inconnue) ne recopie
+	* 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, 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 || 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();
+				this.commitHeaders();
+				return Reflect.apply(native, res, [name, value]);
+			}
+		});
+	}
+	/**
+	* 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.defineProperty(res, "setHeader", { value: native });
+	}
+	/**
+	* Retire un en-tête, de la réserve comme de la réponse Node.
+	*
+	* @param name - nom de l'en-tête (casse indifférente).
+	*/
+	removeHeader(name) {
+		const at = this.#indexOf(name.toLowerCase());
+		if (at !== -1) this.#headers?.splice(at, 2);
+		if (this.response && !this.response.headersSent) this.response.removeHeader(name);
 	}
 	/**
 	* Union des tokens `Vary` déjà posés et de ceux qu'on ajoute, sans doublon.
@@ -207,7 +531,7 @@ var HttpResponse = class {
 	*/
 	#mergeVary(value) {
 		const incoming = (Array.isArray(value) ? value.join(",") : String(value)).split(",").map((t) => t.trim()).filter(Boolean);
-		const current = this.response?.getHeader("vary");
+		const current = this.getHeader("vary");
 		const all = [...(Array.isArray(current) ? current.join(",") : String(current ?? "")).split(",").map((t) => t.trim()).filter(Boolean), ...incoming];
 		if (all.some((t) => t === "*")) return "*";
 		const seen = /* @__PURE__ */ new Set();
@@ -226,10 +550,10 @@ var HttpResponse = class {
 				const value = obj[head];
 				if (value !== void 0) this.setHeader(head, value);
 			}
-			return this.headers = this.response?.getHeaders();
+			return this.headers = this.getHeaders();
 		}
 		this.log("headers already sended ", "WARNING");
-		return this.headers = this.response.getHeaders();
+		return this.headers = this.getHeaders();
 	}
 	setContentType(type, encoding) {
 		if (type && encoding) {
@@ -238,8 +562,12 @@ var HttpResponse = class {
 				const mytype = resolved.bare;
 				this.contentType = mytype;
 				this.encoding = encoding;
-				if (mytype === "application/json" || mytype.endsWith("+json")) return this.setHeader("Content-Type", mytype);
-				return this.setHeader("Content-Type", `${mytype}; charset=${encoding}`);
+				if (mytype === "application/json" || mytype.endsWith("+json")) {
+					this.setHeader("Content-Type", mytype);
+					return;
+				}
+				this.setHeader("Content-Type", `${mytype}; charset=${encoding}`);
+				return;
 			}
 		}
 		if (type && !encoding) {
@@ -249,10 +577,11 @@ var HttpResponse = class {
 				this.contentType = mytype;
 				const charset = resolved.charset;
 				if (charset) this.encoding = charset;
-				return this.setHeader("Content-Type", mytype);
+				this.setHeader("Content-Type", mytype);
+				return;
 			}
 		}
-		return this.setHeader("Content-Type", `${this.contentType}; charset=${this.encoding}`);
+		this.setHeader("Content-Type", `${this.contentType}; charset=${this.encoding}`);
 	}
 	setFileMimeType(type, encoding) {
 		let myType = this.getMimeType(type);
@@ -261,7 +590,7 @@ var HttpResponse = class {
 			myType = "application/octet-stream";
 		}
 		this.contentType = myType;
-		return this.setContentType(myType, encoding || this.encoding);
+		this.setContentType(myType, encoding || this.encoding);
 	}
 	setContentTypeByExtension(extention) {
 		const ismime = mime.contentType(extention);
@@ -269,7 +598,8 @@ var HttpResponse = class {
 			this.contentType = ismime;
 			let charset = mime.charset(this.contentType);
 			if (charset) this.encoding = charset;
-			return this.setHeader("Content-Type", ismime);
+			this.setHeader("Content-Type", ismime);
+			return;
 		}
 		this.log(`setContentTypeByExtension: ${extention}  not found`, "WARNING");
 	}
@@ -337,19 +667,23 @@ 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");
 		if (this.getHeader("Transfer-Encoding") === "chunked") {
-			this.response?.removeHeader("Content-Length");
+			this.removeHeader("Content-Length");
 			return 0;
 		}
 		if (NO_CONTENT_LENGTH_STATUS.has(this.statusCode)) return 0;
+		if (this.statusCode === 205) {
+			this.#put("content-length", "0");
+			return 0;
+		}
 		const actualBody = body || this.#text || this.#buffer;
 		if (actualBody) {
 			const length = typeof actualBody === "string" && actualBody === this.#text ? Buffer.byteLength(actualBody, this.#textEncoding) : Buffer.byteLength(actualBody);
-			this.setHeader("Content-Length", String(length));
+			this.#put("content-length", String(length));
 			return length;
 		}
 		return 0;
@@ -362,27 +696,68 @@ var HttpResponse = class {
 				if (this.statusCode > 599) this.statusCode = 500;
 			}
 			this.statusMessage = this.getStatusMessage();
-			if (this.context.requestId) this.response.setHeader("x-request-id", this.context.requestId);
-			if (this.context.traceparent) this.response.setHeader("traceparent", this.context.traceparent);
+			if (headers) this.#apply(headers);
+			this.putCorrelationHeaders();
 			this.setLength();
 			this.ensureContentTypeHeader();
+			this.applyHeaderPolicy(this.contentTypeForPolicy());
+			const list = this.#store();
 			const std = http.STATUS_CODES[this.statusCode];
-			if (this.statusMessage === std) this.response.writeHead(this.statusCode, headers);
+			if (this.statusMessage === std) this.response.writeHead(this.statusCode, list);
 			else {
 				const safeMsg = this.statusMessage.replace(/[^\x20-\x7E]/g, "").trim() || (std ?? "Unknown Error");
-				this.response.writeHead(this.statusCode, safeMsg, headers);
+				this.response.writeHead(this.statusCode, safeMsg, list);
 			}
 		} else {
 			this.log("Headers already sent !!", "WARNING");
 			throw new Error(`Headers already sent !!`);
 		}
 	}
+	/**
+	* Range dans la réserve les en-têtes passés à `writeHead` — ils l'emportent
+	* sur ceux déjà posés, comme chez Node.
+	*/
+	#apply(headers) {
+		if (Array.isArray(headers)) {
+			for (let i = 0; i + 1 < headers.length; i += 2) {
+				const value = headers[i + 1];
+				if (value !== void 0) this.setHeader(String(headers[i]), value);
+			}
+			return;
+		}
+		for (const name in headers) {
+			const value = headers[name];
+			if (value !== void 0) this.setHeader(name, value);
+		}
+	}
+	/** La réserve amorcée — pour une remise sous une autre forme (HTTP/2). */
+	headerList() {
+		return this.#store();
+	}
 	addTrailers(headers) {
 		return this.response?.addTrailers(headers);
 	}
+	/**
+	* Écrit un morceau d'une réponse en flux, sans la terminer — c'est `end()`
+	* qui la clôt après le dernier.
+	*
+	* Au premier morceau, les en-têtes partent SANS longueur ni corps posé (le
+	* patron de `SseStream`), et le cadrage revient à Node : `chunked` pour un
+	* client HTTP/1.1, fermeture de connexion pour un HTTP/1.0 (RFC 9112 §6.1 —
+	* pas de `Transfer-Encoding` à qui ne le connaît pas), trames DATA en HTTP/2
+	* où l'en-tête est interdit (RFC 9113 §8.2.2). Ne JAMAIS le poser à la main :
+	* une fois `flushing` levé, `setHeader` range en trailer, et un
+	* `Transfer-Encoding` en trailer est un message malformé (RFC 9110 §6.5.1).
+	*
+	* @param chunk - le morceau à écrire.
+	* @param encoding - l'encodage d'un morceau texte.
+	* @returns la promesse réglée quand le flux accepte l'écriture suivante.
+	*/
 	flush(chunk, encoding) {
-		this.flushing = true;
-		this.setHeader("Transfer-Encoding", "chunked");
+		if (!this.flushing) {
+			if (!this.isHeaderSent()) this.writeHead();
+			this.flushing = true;
+		}
 		return this.send(chunk, encoding, true);
 	}
 	/**
@@ -445,15 +820,62 @@ var HttpResponse = class {
 		if (!this.response) throw new Error(`response not found`);
 		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).
+	*
+	* @param name - nom de l'en-tête (casse indifférente).
+	*/
 	getHeader(name) {
+		const at = this.#indexOf(name.toLowerCase());
+		if (at !== -1) return this.#headers?.[at + 1];
 		return this.response?.getHeader(name);
 	}
 	hasHeader(name) {
-		if (this.response) return this.response.hasHeader(name);
+		if (this.response) return this.#indexOf(name.toLowerCase()) !== -1 || this.response.hasHeader(name);
 		throw new Error(`Respose not foud`);
 	}
+	/** Tous les en-têtes posés, noms en minuscules — une copie, à chaque appel. */
 	getHeaders() {
-		return this.response?.getHeaders();
+		const out = { ...this.response?.getHeaders() };
+		const list = this.#headers;
+		if (list !== null) for (let i = 0; i + 1 < list.length; i += 2) {
+			const name = list[i];
+			if (typeof name === "string") out[name] = list[i + 1];
+		}
+		return out;
 	}
 	redirect(url, status, headers) {
 		this.context.isRedirect = true;
@@ -481,4 +903,4 @@ var HttpResponse = class {
 		return this.context.log(pci, severity, msgid, msg);
 	}
 };
-export { HttpResponse as default };
+export { UNREAD_BODY_DRAIN_LIMIT, UNREAD_BODY_LINGER_MS, HttpResponse as default, isContentlessStatus };