@nodefony/http 10.0.0-beta.3 → 10.0.0-beta.4

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

@@ -1,6 +1,6 @@
 import { extractClientIp, resolveFromRight } from "./trustProxy.js";
 import { isIPv4 } from "node:net";
-//#region nodefony/src/context/forwarded.ts
+// nodefony/src/context/forwarded.ts
 /**
 * Découpe une chaîne sur `sep` au **niveau supérieur uniquement**, en respectant
 * les `quoted-string` RFC 9110 §5.6.4 (`value = token / quoted-string`, RFC 7239 §4) : un
@@ -181,5 +181,4 @@ function resolveForwarded(headers, socketAddress, checker) {
 function hasForwardingHeaders(headers) {
 	return Boolean(headers.forwarded || headers["x-forwarded-for"] || headers["x-forwarded-proto"] || headers["x-forwarded-scheme"] || headers["x-forwarded-host"]);
 }
-//#endregion
 export { forwardedNodeIp, hasForwardingHeaders, parseForwarded, resolveForwarded };

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

@@ -1,5 +1,6 @@
 import HttpError from "../../errors/httpError.js";
 import { responseEnded } from "../responseEnded.js";
+import { alpnProtocolOf } from "../transport.js";
 import Cookie from "../../cookies/cookie.js";
 import Context from "../Context.js";
 import { sanitizeRequestId } from "../requestId.js";
@@ -11,7 +12,7 @@ import { describeSessionStoreFailure } from "../../session/sessionStoreFailure.j
 import { openSseStream } from "./SseStream.js";
 import { finallyMaybe, isPromise, thenMaybe, typeOf } from "nodefony";
 import url, { URL } from "node:url";
-//#region nodefony/src/context/http/HttpContext.ts
+// nodefony/src/context/http/HttpContext.ts
 /**
 * Même URL (chemin, requête, hôte) sous un autre schéma et un autre port.
 * `port` absent → port par défaut du schéma (omis de l'URL).
@@ -58,12 +59,13 @@ var HttpContext = class extends Context {
 	request;
 	response;
 	uploadService;
-	constructor(container, request, response, type) {
-		super(container, type);
+	constructor(container, request, response, serverType) {
+		super(container, serverType);
+		this.alpnProtocol = alpnProtocolOf(request);
 		this.uploadService = this.get("upload");
 		const perfSub = PERF_PROBE_SUB ? globalThis.__nfPerfProbe : void 0;
 		if (perfSub && perfSub.t0 !== 0n) perfSub.uploadNs += Number(process.hrtime.bigint() - perfSub.t0);
-		if (this.type === "http2") {
+		if (this.alpnProtocol === "h2" || this.alpnProtocol === "h2c") {
 			this.request = new Http2Request(request, this);
 			this.response = new Http2Response(response, this);
 		} else {
@@ -124,7 +126,7 @@ var HttpContext = class extends Context {
 	_onTimeout() {
 		if (this.listenerCount("onTimeout")) this.fire("onTimeout", this);
 		this._abortIfPending("Request timeout");
-		let error = null;
+		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);
@@ -414,5 +416,4 @@ var HttpContext = class extends Context {
 		this.response.setContentType("html", encoding);
 	}
 };
-//#endregion
 export { HttpContext as default, switchUrlScheme };

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

@@ -1,9 +1,9 @@
 import HttpError from "../../errors/httpError.js";
 import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
 import { hostnameOf } from "../domainMatcher.js";
-import { Parser, ParserJson, ParserQs, ParserXml, acceptParser } from "./parser.js";
+import { Parser, ParserJson, ParserQs, ParserRaw, ParserXml, acceptParser } from "./parser.js";
 import { isCanonicalAuthority, splitTarget } from "./urlFastPath.js";
-import { RequestContext, extend, useConfig } from "nodefony";
+import { RequestContext, useConfig } from "nodefony";
 import { createHash, randomUUID } from "node:crypto";
 import { URL } from "node:url";
 import fs from "node:fs";
@@ -12,7 +12,7 @@ import os from "node:os";
 import path from "node:path";
 import QS from "qs";
 import { Busboy } from "@fastify/busboy";
-//#region nodefony/src/context/http/Request.ts
+// nodefony/src/context/http/Request.ts
 const reg = /(.*)[[][\]]$/u;
 /**
 * Supprime un fichier temporaire d'upload sans jamais faire échouer le nettoyage :
@@ -34,6 +34,7 @@ const CHARSET_ALIASES = {
 	"utf-16le": "utf16le"
 };
 const QUOTE_TRIM = /^["']|["']$/gu;
+const NO_FILES = Object.freeze([]);
 const parse = {
 	POST: true,
 	PUT: true,
@@ -104,7 +105,7 @@ var HttpRequest = class {
 		let u = this.#url;
 		if (u === null) {
 			u = this.getUrl(this.sUrl);
-			u.query = this.queryGet;
+			u.query = this.query;
 			this.#url = u;
 		}
 		return u;
@@ -113,24 +114,28 @@ var HttpRequest = class {
 		this.#url = u;
 	}
 	parser = null;
-	queryPost = {};
-	queryGet = {};
-	queryFile = [];
-	query = {};
 	/**
-	* Le CORPS de la requête, parsé — nom universel de l'écosystème (Express,
-	* Fastify, NestJS), alias de {@link queryPost}.
-	*
-	* Ne pas confondre avec {@link query}, qui FUSIONNE la query string et le
-	* corps : `body` ne rend jamais un paramètre d'URL. Le data plane admin
-	* expose déjà cette sémantique (`IAdminRequest.body`) ; ce getter la rend
-	* disponible partout.
+	* Le CORPS de la requête, parsé (JSON, urlencoded, XML, champs multipart) —
+	* nom universel de l'écosystème (Express, Fastify, NestJS) et celui
+	* d'`IAdminRequest.body`. Jamais un paramètre d'URL : ceux-là sont dans
+	* {@link query}, et les deux ne fusionnent pas.
+	*/
+	body = {};
+	/** Fichiers reçus, alloués au PREMIER fichier seulement (cf {@link files}). */
+	#uploads = null;
+	/**
+	* Les fichiers reçus dans un corps multipart, déjà écrits dans le répertoire
+	* temporaire — lus par `@UploadedFile()` / `@UploadedFiles()`. Les champs
+	* texte du même corps sont dans {@link body}.
 	*
-	* Getter (aucune allocation) : `queryPost` reste la source unique.
+	* Lecture seule : une requête sans upload rend un vide partagé et gelé,
+	* aucune allocation.
 	*/
-	get body() {
-		return this.queryPost;
+	get files() {
+		return this.#uploads ?? NO_FILES;
 	}
+	/** Les paramètres d'URL, seuls — jamais un champ du corps ({@link body}). */
+	query = {};
 	queryStringOptions;
 	charset = "utf8";
 	uploadOption = {};
@@ -185,7 +190,6 @@ var HttpRequest = class {
 		if (this.search) query = QS.parse(this.search.slice(1), this.queryStringOptions ?? {});
 		else query = {};
 		if (this.#url !== null) this.#url.query = query;
-		this.queryGet = query;
 		this.query = query;
 		if (PERF_PROBE_SUB) perfMark("reqQueryNs");
 		this.contentType = this.getContentType(this.request);
@@ -201,11 +205,11 @@ var HttpRequest = class {
 	* remplace le `once("onRequestEnd")` du ctor qui allouait 1 onceWrapper +
 	* 1 closure à CHAQUE requête.
 	*
-	* Il porte le CORPS (`queryPost`), pas la fusion `query` : un seul sens de
+	* Il porte le CORPS (`body`), jamais les paramètres d'URL : un seul sens de
 	* `body` dans tout le framework, celui de l'écosystème et d'`IAdminRequest`.
 	*/
 	fireRequestEnd() {
-		this.request.body = this.queryPost;
+		this.request.body = this.body;
 		if (this.context.listenerCount("onRequestEnd") === 0) return false;
 		return this.context.fireAsync("onRequestEnd", this);
 	}
@@ -315,7 +319,7 @@ var HttpRequest = class {
 					await this.fireRequestEnd();
 					return BODY_DONE;
 				}
-				this.parser = new Parser(this);
+				this.parser = new ParserRaw(this);
 				return this.parser;
 		}
 	}
@@ -362,8 +366,7 @@ var HttpRequest = class {
 			return this.parser;
 		}
 		const { fields, files } = await this.streamMultipart(bb);
-		this.queryPost = fields;
-		this.query = extend({}, this.query, this.queryPost);
+		this.body = fields;
 		for (const pf of files) await this.createFileUpload(pf.field, pf.file);
 		this.context.requestEnded = true;
 		await this.fireRequestEnd();
@@ -478,7 +481,7 @@ var HttpRequest = class {
 	}
 	accepts(Type) {
 		let parts = [];
-		let subtype = "*";
+		let subtype;
 		let type = "*";
 		if (Type) parts = Type.split("/");
 		switch (parts.length) {
@@ -496,7 +499,7 @@ var HttpRequest = class {
 	}
 	async createFileUpload(name, file) {
 		const fileUpload = await this.context.uploadService?.createUploadFile(file, name);
-		if (fileUpload) this.queryFile.push(fileUpload);
+		if (fileUpload) (this.#uploads ??= []).push(fileUpload);
 		return fileUpload;
 	}
 	getMethod() {
@@ -561,7 +564,9 @@ var HttpRequest = class {
 	/**
 	* Scheme effectif côté client : `Forwarded`/`X-Forwarded-*` résolu de façon
 	* canonique (this.forwarded, gated proxy de confiance) ; sinon le transport
-	* réel. HTTP/2 remplace la lecture du socket par le pseudo-header `:scheme`.
+	* réel. Vaut pour HTTP/2 aussi : le pseudo-en-tête `:scheme` vient du client
+	* (RFC 9113 §8.3.1) et n'est jamais cru — sur h2c, `:scheme: https` ferait
+	* passer une connexion claire pour chiffrée.
 	*/
 	resolveScheme(request) {
 		if (this.forwarded?.proto) return this.forwarded.proto;
@@ -589,9 +594,8 @@ var HttpRequest = class {
 		return new URL(sUrl, baseUrl);
 	}
 	log(pci, severity, msgid, msg) {
-		if (!msgid) msgid = `${this.context.type} REQUEST `;
+		if (!msgid) msgid = `${this.context.serverType} REQUEST `;
 		return this.context.log(pci, severity, msgid, msg);
 	}
 };
-//#endregion
 export { HttpRequest as default };

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

@@ -2,7 +2,7 @@ import Cookie from "../../cookies/cookie.js";
 import { thenMaybe, typeOf } from "nodefony";
 import http from "node:http";
 import mime from "mime-types";
-//#region nodefony/src/context/http/Response.ts
+// nodefony/src/context/http/Response.ts
 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;
@@ -55,7 +55,8 @@ var HttpResponse = class {
 	constructor(response, context) {
 		this.context = context;
 		this.response = response;
-		this.timeout = this.context.httpKernel?.responseTimeout[this.context.type];
+		const responseTimeout = this.context.httpKernel?.responseTimeout;
+		this.timeout = this.context.serverType === "https" ? responseTimeout?.https : responseTimeout?.http;
 	}
 	/**
 	* Filet posé juste avant l'émission des en-têtes : si aucun `Content-Type`
@@ -153,16 +154,33 @@ var HttpResponse = class {
 		const serialized = [];
 		for (const cookie of cookies) {
 			const s = cookie.serialize();
-			this.log(`ADD COOKIE ==> ${s}`, "DEBUG");
+			this.logCookie(cookie, s);
 			serialized.push(s);
 		}
 		return this.setHeader("Set-Cookie", serialized);
 	}
 	setCookie(cookie) {
 		const serialize = cookie.serialize();
-		this.log(`ADD COOKIE ==> ${serialize}`, "DEBUG");
+		this.logCookie(cookie, serialize);
 		return this.setHeader("Set-Cookie", serialize);
 	}
+	/**
+	* Journalise en DEBUG un cookie posé, sa VALEUR MASQUÉE : nom et attributs
+	* seulement. Le journal de développement se lit par le plan d'administration
+	* — un identifiant de session y entrerait chez quiconque le consulte.
+	* La ligne n'est construite que si DEBUG passe le gate du syslog pour ce
+	* `msgid` (debug ciblé compris) : rien n'est alloué en production.
+	*
+	* @param cookie - le cookie posé.
+	* @param serialized - sa forme `Set-Cookie`, déjà calculée pour l'en-tête.
+	*/
+	logCookie(cookie, serialized) {
+		const msgid = `${this.context.serverType} RESPONSE `;
+		const syslog = this.context.syslog;
+		if (syslog && !syslog.severityEnabled("DEBUG", msgid)) return;
+		const attrs = serialized.indexOf("; ", cookie.name.length + 1);
+		this.log(`ADD COOKIE ==> ${cookie.name}=<masqué>${attrs === -1 ? "" : serialized.slice(attrs)}`, "DEBUG", msgid);
+	}
 	setHeader(name, value) {
 		if (this.response) {
 			if (this.flushing) {
@@ -459,9 +477,8 @@ var HttpResponse = class {
 		return this;
 	}
 	log(pci, severity, msgid, msg) {
-		if (!msgid) msgid = `${this.context.type} RESPONSE `;
+		if (!msgid) msgid = `${this.context.serverType} RESPONSE `;
 		return this.context.log(pci, severity, msgid, msg);
 	}
 };
-//#endregion
 export { HttpResponse as default };

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

@@ -3,7 +3,7 @@ import Http2Response from "../http2/Response.js";
 import { RequestContext } from "nodefony";
 import http from "node:http";
 import { AsyncResource } from "node:async_hooks";
-//#region nodefony/src/context/http/SseStream.ts
+// 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. */
@@ -346,5 +346,4 @@ function startSseStream(context, options, settings) {
 	if (options.retry !== void 0) sse.retry(options.retry);
 	return sse;
 }
-//#endregion
 export { SSE_HEARTBEAT_MS, SSE_MAX_EVENT_BYTES, SSE_STALL_TIMEOUT_MS, SseStream, acceptsEventStream, openSseStream };

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

@@ -1,8 +1,8 @@
 import HttpError from "../../errors/httpError.js";
-import { escapeRegExp, extend } from "nodefony";
+import { escapeRegExp } from "nodefony";
 import QS from "qs";
 import xml2js from "xml2js";
-//#region nodefony/src/context/http/parser.ts
+// nodefony/src/context/http/parser.ts
 var Parser = class {
 	request;
 	chunks;
@@ -73,6 +73,27 @@ var Parser = class {
 		return this;
 	}
 };
+/**
+* Corps d'un type que le framework ne décode pas : livré TEL QU'IL EST REÇU,
+* jamais remplacé par un objet vide qui mentirait.
+*
+* - `text/*` → une chaîne, décodée au `charset` du `Content-Type` (UTF-8 par
+*   défaut) — comme une trame texte RFC 6455 ;
+* - tout autre type, et un corps sans `Content-Type` (RFC 9110 §8.3 : supposé
+*   `application/octet-stream`) → les OCTETS : le `Buffer` déjà assemblé dans
+*   `request.data`, sans copie — donc un `Uint8Array`, le type d'octets que
+*   la socket livrera aussi (#618). Un même schéma passe par les deux portes.
+*
+* Un corps VIDE laisse `body` tel quel : une requête sans charge ne change pas.
+*/
+var ParserRaw = class extends Parser {
+	async parse() {
+		await super.parse();
+		const data = this.request.data;
+		if (data.length > 0) this.request.body = this.request.contentType?.startsWith("text/") ? data.toString(this.request.charset) : data;
+		return this;
+	}
+};
 var ParserQs = class extends Parser {
 	parserOptions;
 	charset = "utf8";
@@ -83,8 +104,7 @@ var ParserQs = class extends Parser {
 	}
 	async parse() {
 		await super.parse();
-		this.request.queryPost = QS.parse(this.request.data.toString(this.charset), this.parserOptions);
-		this.request.query = extend({}, this.request.query, this.request.queryPost);
+		this.request.body = QS.parse(this.request.data.toString(this.charset), this.parserOptions);
 		this.request.context.requestEnded = true;
 		return this;
 	}
@@ -102,7 +122,7 @@ var ParserXml = class extends Parser {
 		return new Promise((resolve, reject) => {
 			this.xmlParser.parseString(this.request.data.toString(this.charset), (err, result) => {
 				if (err) return reject(err);
-				this.request.queryPost = result;
+				this.request.body = result;
 				this.request.context.requestEnded = true;
 				return resolve(this);
 			});
@@ -110,7 +130,14 @@ var ParserXml = class extends Parser {
 	}
 };
 /**
-* Parse un corps `application/json` (ou `*+json`) en objet → `queryPost`
+* Vrai pour un objet ou un tableau JSON — ce que `body` peut porter.
+* Un tableau passe : `@Body()` le rend tel quel (envoi en lot).
+*/
+function isJsonContainer(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Parse un corps `application/json` (ou `*+json`) en objet → `body`
 * (source lue par le décorateur `@Body`). Reprend le rôle de l'ancien plugin
 * `json` de formidable, supprimé avec le passage à busboy (multipart seul).
 * Lenient : un corps JSON malformé est ignoré (pas de throw — `parse()` est
@@ -127,8 +154,8 @@ var ParserJson = class extends Parser {
 		await super.parse();
 		const text = this.request.data.toString(this.charset).trim();
 		if (text) try {
-			this.request.queryPost = JSON.parse(text);
-			this.request.query = extend({}, this.request.query, this.request.queryPost);
+			const parsed = JSON.parse(text);
+			if (isJsonContainer(parsed)) this.request.body = parsed;
 		} catch {}
 		this.request.context.requestEnded = true;
 		return this;
@@ -183,5 +210,4 @@ const acceptParser = function(acc) {
 		return ACCEPT_ANY;
 	}
 };
-//#endregion
-export { Parser, ParserJson, ParserQs, ParserXml, acceptParser };
+export { Parser, ParserJson, ParserQs, ParserRaw, ParserXml, acceptParser };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/context/http/urlFastPath.ts
+// nodefony/src/context/http/urlFastPath.ts
 const PATH_SAFE = /* @__PURE__ */ new Uint8Array(128);
 const SEARCH_SAFE = /* @__PURE__ */ new Uint8Array(128);
 const HOST_SAFE = /* @__PURE__ */ new Uint8Array(128);
@@ -123,5 +123,4 @@ function isDigitsFrom(s, from) {
 	}
 	return true;
 }
-//#endregion
 export { isCanonicalAuthority, splitTarget };

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

@@ -1,5 +1,6 @@
+import { requestAuthority } from "../transport.js";
 import HttpRequest from "../http/Request.js";
-//#region nodefony/src/context/http2/Request.ts
+// nodefony/src/context/http2/Request.ts
 var Http2Request = class extends HttpRequest {
 	request;
 	constructor(request, context) {
@@ -7,8 +8,9 @@ var Http2Request = class extends HttpRequest {
 		this.context = context;
 		this.request = request;
 	}
+	/** `:authority`, sinon `Host` — cf `requestAuthority` (RFC 9113 §8.3.1). */
 	getHost() {
-		return this.headers[":authority"];
+		return requestAuthority(this.request.headers);
 	}
 	getUserAgent() {
 		return this.headers["user-agent"];
@@ -19,11 +21,5 @@ var Http2Request = class extends HttpRequest {
 	getRawTarget() {
 		return this.headers[":path"];
 	}
-	resolveScheme() {
-		if (this.forwarded?.proto) return this.forwarded.proto;
-		if (this.headers[":scheme"] === "https") return "https";
-		return "http";
-	}
 };
-//#endregion
 export { Http2Request as default };

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

@@ -2,8 +2,13 @@ import HttpResponse from "../http/Response.js";
 import { thenMaybe } from "nodefony";
 import http from "node:http";
 import http2 from "node:http2";
-//#region nodefony/src/context/http2/Response.ts
+// nodefony/src/context/http2/Response.ts
 const HTTP2_HEADER_STATUS = http2.constants.HTTP2_HEADER_STATUS;
+/** Réponse Node déjà libérée : aucun en-tête posé à reprendre. */
+const emptyHeaders = {
+	getHeaderNames: () => [],
+	getHeader: () => void 0
+};
 /**
 * Compose les en-têtes d'une réponse HTTP/2 : ceux posés sur la réponse, puis
 * ceux passés à `writeHead`, qui gagnent.
@@ -14,14 +19,19 @@ const HTTP2_HEADER_STATUS = http2.constants.HTTP2_HEADER_STATUS;
 * (`ERR_HTTP2_HEADER_SINGLE_VALUE`), soit une 500 sur tout média servi en
 * HTTP/2. HTTP/2 n'a de toute façon que des noms en minuscules (RFC 9113 §8.2.1).
 *
+* Les en-têtes posés se lisent nom par nom (`getHeaderNames`, déjà en
+* minuscules) : `getHeaders()` les recopiait d'abord dans un objet sans
+* prototype, avant cette fusion — 3,8 µs par réponse pour 12 en-têtes,
+* contre 1,1 µs en une passe.
+*
 * @param statusMessage - message de statut, recopié en `x-status-message`
-* @param current - en-têtes déjà posés sur la réponse
+* @param current - la réponse Node qui porte les en-têtes déjà posés
 * @param extra - en-têtes passés à `writeHead` (objet, ou liste plate clé/valeur)
 * @returns les en-têtes à transmettre à `respond()`
 */
 function mergeResponseHeaders(statusMessage, current, extra) {
 	const merged = { "x-status-message": statusMessage };
-	for (const key in current) merged[key.toLowerCase()] = current[key];
+	for (const name of current.getHeaderNames()) merged[name] = current.getHeader(name);
 	if (Array.isArray(extra)) for (let i = 0; i + 1 < extra.length; i += 2) merged[String(extra[i]).toLowerCase()] = extra[i + 1];
 	else if (extra) for (const key in extra) {
 		const value = extra[key];
@@ -58,7 +68,7 @@ var Http2Response = class extends HttpResponse {
 				this.statusMessage = this.getStatusMessage();
 				this.setLength();
 				this.ensureContentTypeHeader();
-				this.headers = mergeResponseHeaders(this.statusMessage, this.getHeaders(), headers);
+				this.headers = mergeResponseHeaders(this.statusMessage, this.response ?? emptyHeaders, headers);
 				this.headers[HTTP2_HEADER_STATUS] = this.statusCode;
 				const requestId = this.context.requestId;
 				if (requestId) this.headers["x-request-id"] = requestId;
@@ -69,9 +79,9 @@ var Http2Response = class extends HttpResponse {
 		} else return super.writeHead(statusCode, headers);
 	}
 	/**
-	* Écrit le corps sur le flux HTTP/2. Synchrone pour une redirection, un flux
-	* fermé ou le repli HTTP/1 ; une promesse quand le corps est écrit sur le
-	* flux, réglée par le rappel d'écriture (#505).
+	* Écrit le corps sur le flux HTTP/2 et, pour une réponse unique, le termine
+	* d'un seul `end(corps)`. Synchrone, sauf en streaming (`flush()`) : une
+	* promesse réglée par le rappel d'écriture, la contre-pression (#505).
 	*
 	* @returns la réponse, ou sa promesse.
 	*/
@@ -87,6 +97,10 @@ var Http2Response = class extends HttpResponse {
 			return this;
 		}
 		if (chunk) this.setBody(chunk);
+		if (!_flush && !this.flushing) {
+			stream.end(this.payload, this.payloadEncoding);
+			return this;
+		}
 		return new Promise((resolve, reject) => {
 			stream.write(this.payload, this.payloadEncoding, (error) => {
 				if (error) return reject(error);
@@ -102,7 +116,7 @@ var Http2Response = class extends HttpResponse {
 	*/
 	end(chunk, encoding) {
 		if (this.stream) {
-			if (this.stream.destroyed || this.stream.closed) return this.stream;
+			if (this.stream.writableEnded || this.stream.destroyed || this.stream.closed) return this.stream;
 			return this.stream.end(chunk, encoding || this.encoding);
 		}
 		return super.end(chunk, encoding);
@@ -121,5 +135,4 @@ var Http2Response = class extends HttpResponse {
 		};
 	}
 };
-//#endregion
 export { Http2Response as default, mergeResponseHeaders };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/context/metaData.ts
+// nodefony/src/context/metaData.ts
 /**
 * Assemble l'enveloppe `metaData` d'une requête EN PLACE (builder monomorphe) :
 * met à jour les champs de `target.nodefony` dans un ordre fixe → V8 garde une
@@ -43,5 +43,4 @@ function buildMetaData(target, src, override) {
 	}
 	return target;
 }
-//#endregion
 export { buildMetaData };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/context/requestId.ts
+// nodefony/src/context/requestId.ts
 /**
 * Validation de l'identifiant de corrélation `X-Request-Id` fourni par le
 * client, avant qu'il ne soit adopté comme `Context.requestId`.
@@ -37,5 +37,4 @@ function sanitizeRequestId(raw) {
 	if (!raw || raw.length > 128) return null;
 	return SAFE_REQUEST_ID.test(raw) ? raw : null;
 }
-//#endregion
 export { MAX_REQUEST_ID_LENGTH, sanitizeRequestId };

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

@@ -1,5 +1,5 @@
 import http2 from "node:http2";
-//#region nodefony/src/context/responseEnded.ts
+// nodefony/src/context/responseEnded.ts
 /**
 * La réponse a-t-elle été TERMINÉE par le serveur ? Règle UNIQUE, pour HTTP/1.1
 * comme pour HTTP/2 — l'écouteur `close` du noyau (client parti → 499) et le
@@ -23,5 +23,4 @@ function responseEnded(response) {
 	const stream = response.stream;
 	return stream.writableEnded && !stream.aborted;
 }
-//#endregion
 export { responseEnded };

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

@@ -0,0 +1,45 @@
+// nodefony/src/context/transport.ts
+/**
+* Famille du protocole traité par un contexte, déduite du serveur qui l'a
+* reçu. Règle UNIQUE : `Context` la pose à la construction.
+*
+* @param serverType - identité du serveur (`http`, `https`, `ws`, `wss`)
+* @returns `"websocket"` pour `ws`/`wss`, `"http"` sinon
+*/
+function protocolNameOf(serverType) {
+	return serverType === "ws" || serverType === "wss" ? "websocket" : "http";
+}
+/**
+* Protocole du saut qui a porté cette requête jusqu'au processus, au sens du
+* registre IANA des identifiants ALPN. Règle UNIQUE : `HttpContext` la lit pour
+* choisir ses classes de requête et de réponse.
+*
+* La valeur se CONSTATE sur la requête, elle ne se déduit pas du serveur : un
+* même serveur TLS reçoit HTTP/1.1 et h2 (`allowHTTP1`). Pour h2, c'est la
+* session de Node qui tranche — `Http2Session.alpnProtocol` vaut `"h2c"` sur
+* une session en clair, l'ALPN négocié (`"h2"`) sur une session TLS.
+*
+* @param request - la requête Node reçue par le serveur
+* @returns `"http/1.1"`, `"h2"` ou `"h2c"`
+*/
+function alpnProtocolOf(request) {
+	if (request.httpVersionMajor !== 2) return "http/1.1";
+	return (request.stream?.session)?.alpnProtocol === "h2c" ? "h2c" : "h2";
+}
+/**
+* Autorité (hôte et port) d'une requête, HTTP/1.1 comme HTTP/2. Règle UNIQUE
+* des lecteurs du serveur.
+*
+* `:authority` d'abord, puis `Host` (RFC 9113 §8.3.1). Le repli n'est pas un
+* confort : un intermédiaire qui convertit une requête HTTP/1.1 de forme origine
+* (`GET /chemin`) en HTTP/2 ne DOIT PAS fabriquer `:authority` — il garde
+* `Host`. C'est ce que fait HAProxy `proto h2` vers un port h2c : sans ce repli,
+* l'hôte est introuvable et la requête part en 421.
+*
+* @param headers - en-têtes de la requête Node (`IncomingMessage` ou `Http2ServerRequest`).
+* @returns l'autorité, ou `undefined` si la requête n'en porte aucune.
+*/
+function requestAuthority(headers) {
+	return headers[":authority"] ?? headers.host;
+}
+export { alpnProtocolOf, protocolNameOf, requestAuthority };

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

@@ -1,5 +1,5 @@
 import { BlockList, isIPv4, isIPv6 } from "node:net";
-//#region nodefony/src/context/trustProxy.ts
+// nodefony/src/context/trustProxy.ts
 const PRESETS = {
 	loopback: [[
 		"127.0.0.0",
@@ -164,5 +164,4 @@ function extractClientIp(xff, socketAddress, checker) {
 	}
 	return resolveFromRight(s.split(",").map((part) => part.trim()).filter(Boolean), socketAddress, checker);
 }
-//#endregion
 export { buildTrustProxy, extractClientIp, resolveFromRight };