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

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.
 	*/
@@ -83,10 +93,15 @@ var Http2Response = class extends HttpResponse {
 		const stream = this.stream;
 		if (!stream) return super.send(chunk, encoding);
 		if (stream.destroyed || !stream.writable) {
+			this.settleHeadResponse();
 			this.log("HTTP/2 stream not writable before send — skip", "DEBUG");
 			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,11 +117,29 @@ 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) {
+				this.settleHeadResponse();
+				return this.stream;
+			}
 			return this.stream.end(chunk, encoding || this.encoding);
 		}
 		return super.end(chunk, encoding);
 	}
+	/**
+	* Termine la réponse de compatibilité d'un HEAD, dont Node a clos le flux de
+	* lui-même au `respond()`.
+	*
+	* Sans ce geste, `Http2ServerResponse` n'émet ni `finish` ni `close` : le
+	* démontage de la requête, branché sur ce `close` (ligne d'accès, profil,
+	* hooks d'après-réponse, libération du scope DI), n'a jamais lieu. Les statuts
+	* que Node termine aussi d'office (204, 205, 304) émettent leur `close` seuls,
+	* et un flux détruit (client parti) aussi : ils ne sont pas touchés. Hors du
+	* chemin servi — appelé seulement quand le flux est déjà clos.
+	*/
+	settleHeadResponse() {
+		const raw = this.response;
+		if (raw !== null && this.context.method === "HEAD" && this.stream?.destroyed === false && !raw.writableEnded) raw.end();
+	}
 	getStatusMessage(code) {
 		if (code) {
 			if (this.response) return http.STATUS_CODES[code] || this.statusMessage;
@@ -121,5 +154,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/requestTrace.js

@@ -0,0 +1,104 @@
+import diagnosticsChannel from "node:diagnostics_channel";
+// nodefony/src/context/requestTrace.ts
+/**
+* Nom du `TracingChannel` qui encadre chaque requête HTTP et chaque handshake
+* WebSocket — forme `module.fonction` recommandée par la documentation de
+* `node:diagnostics_channel` ; les sous-canaux sont
+* `tracing:nodefony.http.request:start`, `:end`, `:asyncStart`, `:asyncEnd`,
+* `:error`.
+*/
+const REQUEST_TRACE_CHANNEL = "nodefony.http.request";
+const tracing = diagnosticsChannel.tracingChannel(REQUEST_TRACE_CHANNEL);
+const startChannel = tracing.start;
+const endChannel = tracing.end;
+const asyncStartChannel = tracing.asyncStart;
+const asyncEndChannel = tracing.asyncEnd;
+const errorChannel = tracing.error;
+/**
+* Dit si quelqu'un écoute le canal — LA garde du chemin chaud : ~1,6 ns
+* mesurées, aucune allocation. Lue une seule fois, au début de la requête :
+* un abonné arrivé ensuite ne voit que les requêtes suivantes (règle des
+* `TracingChannel`, qui interdit une fin sans début).
+*
+* @returns `true` si au moins un sous-canal a un abonné
+*/
+function hasRequestTraceSubscribers() {
+	return tracing.hasSubscribers;
+}
+/**
+* Crée le message de la requête et le range sur son contexte. À n'appeler
+* que sous {@link hasRequestTraceSubscribers} : c'est la seule allocation
+* du canal, et elle n'a lieu que si quelqu'un écoute.
+*
+* @param context - le contexte qui vient d'être construit
+* @param protocol - requête HTTP ou handshake WebSocket
+* @returns le message, de forme fixe, dont les champs de résultat valent `null`
+*/
+function openRequestTrace(context, protocol) {
+	const trace = {
+		requestId: context.requestId,
+		protocol,
+		method: context.method,
+		scheme: context.scheme,
+		url: context.url,
+		route: null,
+		routePath: null,
+		module: null,
+		statusCode: null,
+		durationMs: null,
+		error: null
+	};
+	context.requestTrace = trace;
+	return trace;
+}
+/**
+* Exécute la partie synchrone du traitement sous `start.runStores` puis
+* publie `end` — la séquence de `TracingChannel.tracePromise`. Les stores
+* liés au canal (`bindStore`, ce que fait un agent APM) restent actifs pour
+* toute la suite asynchrone de la requête.
+*
+* @param trace - le message de la requête
+* @param fn - la fonction qui sert la requête
+* @param thisArg - le receveur de `fn`
+* @param args - les arguments de `fn`
+* @returns ce que rend `fn` — un contexte ou sa promesse
+*/
+function runTraced(trace, fn, thisArg, ...args) {
+	try {
+		return startChannel.runStores(trace, fn, thisArg, ...args);
+	} finally {
+		endChannel.publish(trace);
+	}
+}
+/**
+* Termine la trace de la requête : remplit les champs de résultat puis
+* publie `error` (s'il y a une exception), `asyncStart` et `asyncEnd`.
+* Idempotent — le premier appel gagne, les suivants ne font rien : un
+* handshake WebSocket a plusieurs sorties, une seule publie la fin.
+*
+* La durée est celle de l'horloge unique du contexte (`stopClock`), la même
+* que celle de la ligne d'accès : le canal n'en mesure aucune.
+*
+* @param context - le contexte de la requête
+* @param statusCode - le statut rendu au client, `null` s'il n'y en a pas eu
+* @param error - l'exception attrapée par le pipeline, `null` ou `undefined` sinon
+*/
+function closeRequestTrace(context, statusCode, error) {
+	const trace = context.requestTrace;
+	if (trace === null) return;
+	context.requestTrace = null;
+	const route = context.resolver?.route ?? null;
+	trace.route = route?.name ?? null;
+	const path = route?.path;
+	trace.routePath = path === void 0 ? null : path === "" ? "/" : path;
+	trace.module = context.logModule ?? route?.module?.name ?? null;
+	trace.statusCode = statusCode;
+	trace.durationMs = context.stopClock();
+	if (error !== null && error !== void 0) {
+		trace.error = error;
+		errorChannel.publish(trace);
+	}
+	asyncStartChannel.publish(trace);
+	asyncEndChannel.publish(trace);
+}
+export { REQUEST_TRACE_CHANNEL, closeRequestTrace, hasRequestTraceSubscribers, openRequestTrace, runTraced };

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/timingMode.js

@@ -0,0 +1,21 @@
+// nodefony/src/context/timingMode.ts
+/**
+* Résout le mode de chronométrage d'une requête depuis `timing.enabled` et
+* l'environnement — la SEULE règle, appelée par le constructeur du `Context`.
+*
+* Défaut (`null`, pas d'avis) : la durée partout, les phases hors production.
+* La durée coûte deux lectures d'horloge, l'équivalent de quelques pourcents
+* de la ligne d'accès qu'elle complète ; les phases coûtent une lecture par
+* phase, un tableau et un index par requête — réservées au développement, ou
+* à un diagnostic à chaud (`true`). `false` coupe tout, durée comprise.
+*
+* @param enabled - valeur de `timing.enabled` (`true`, `false`, `null`)
+* @param environment - environnement normalisé du noyau (`"production"`…)
+* @returns le mode de la requête — une chaîne littérale, rien d'alloué
+*/
+function resolveTimingMode(enabled, environment) {
+	if (enabled === false) return "off";
+	if (enabled === true) return "phases";
+	return environment === "production" ? "clock" : "phases";
+}
+export { resolveTimingMode };

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 };

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

@@ -0,0 +1,30 @@
+// nodefony/src/context/unsentResponse.ts
+/**
+* Rédige l'avertissement de développement d'une requête restée sans réponse :
+* l'action a rendu une valeur que le framework ne sait pas envoyer, et la
+* requête a attendu son délai d'expiration.
+*
+* Le message nomme l'action fautive, ce qu'elle a rendu, et le geste qui
+* convient à ce cas — `null` est presque toujours une entité absente, qui
+* appelle un 404.
+*
+* @param resolver - le resolver de la requête (route, controller, action,
+*   valeur non rendue), `null` si aucune route n'a été résolue.
+* @param url - l'URL de la requête, repli quand aucune route n'est connue.
+* @returns le texte de l'avertissement.
+*/
+function unsentResponseWarning(resolver, url) {
+	const controller = resolver?.controller?.name;
+	const actionName = resolver?.actionName;
+	const action = controller && actionName ? `${controller}.${actionName}` : null;
+	const route = resolver?.route?.name ?? null;
+	const where = action ? `L'action ${action}${route ? ` (route ${route})` : ""}` : `L'action de ${route ?? url}`;
+	const returned = resolver?.unrendered ?? null;
+	const consequence = "et n'a rien envoyé : la requête a attendu son délai d'expiration.";
+	if (returned === "null") return `${where} a rendu null ${consequence} Pour le framework, null veut dire « l'action répond elle-même ». Entité absente → lever HttpError(…, 404) ; sinon rendre la valeur, ou envoyer la réponse soi-même.`;
+	if (returned === "undefined") return `${where} n'a rien rendu ${consequence} Un « return » oublié ? Rendre la valeur (objet, chaîne, nombre, booléen, Buffer : envoyés automatiquement), ou envoyer la réponse soi-même.`;
+	if (returned?.startsWith("une instance de")) return `${where} a rendu ${returned}, qui ne s'envoie pas telle quelle, ${consequence} Rendre un objet simple (sa forme JSON), ou envoyer la réponse soi-même.`;
+	if (returned !== null) return `${where} a rendu une valeur de type ${returned} ${consequence} Rendre un objet, une chaîne, un nombre, un booléen ou un Buffer, ou envoyer la réponse soi-même.`;
+	return `${where} n'a rien envoyé : la requête a attendu son délai d'expiration. Rendre la valeur, ou envoyer la réponse soi-même.`;
+}
+export { unsentResponseWarning };

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

@@ -4,7 +4,7 @@ import { toWsCloseReason } from "./wsCloseReason.js";
 import { RequestContext } from "nodefony";
 import http from "node:http";
 import Ws from "ws";
-//#region nodefony/src/context/websocket/Response.ts
+// nodefony/src/context/websocket/Response.ts
 /**
 * Codes d'erreur d'écriture « le client est PARTI » : reload de page, onglet
 * fermé, HMR — la socket TCP est morte côté client pendant qu'une frame était
@@ -71,7 +71,11 @@ var WebsocketResponse = class {
 		const payload = data ?? this.body;
 		if (payload == null) throw new Error("no data");
 		return new Promise((resolve, reject) => {
-			if (!this.connection || this.connection.readyState !== Ws.OPEN) return reject(/* @__PURE__ */ new Error("WebSocket not open"));
+			if (!this.connection || this.connection.readyState === Ws.CONNECTING) return reject(/* @__PURE__ */ new Error("WebSocket not open"));
+			if (this.connection.readyState !== Ws.OPEN) {
+				this.log("WS send: client déjà déconnecté — frame perdue", "DEBUG");
+				return resolve(this);
+			}
 			const { max, policy, closeAfterDrops } = readBackpressureOptions(this.context.server);
 			const decision = decideSend(this.connection, max, policy, closeAfterDrops);
 			if (decision !== "send") {
@@ -122,7 +126,7 @@ var WebsocketResponse = class {
 	setBody(ele, encoding) {
 		if (typeof ele === "string") this.body = Buffer.from(ele, encoding ?? this.encoding);
 		else if (ele instanceof ArrayBuffer || ele instanceof SharedArrayBuffer) this.body = Buffer.from(ele);
-		else if ("buffer" in ele && ele.buffer instanceof ArrayBuffer) this.body = Buffer.from(ele.buffer);
+		else if (ArrayBuffer.isView(ele)) this.body = Buffer.from(ele.buffer, ele.byteOffset, ele.byteLength);
 		return this.body;
 	}
 	drop(reasonCode, description) {
@@ -176,14 +180,38 @@ var WebsocketResponse = class {
 	clean() {
 		this.connection = null;
 		this.body = null;
+		this.handshakeHeaders = null;
 	}
 	setEncoding(encoding) {
 		return this.encoding = encoding;
 	}
-	setHeader() {
+	/**
+	* En-têtes de la réponse au handshake, retenus tant que la socket n'est pas
+	* acceptée : ils ne partent que dans un REFUS (`refuseHandshake`) — le `101`
+	* de `ws` ne les porte pas. `null` tant que personne n'en pose (le cas
+	* nominal : aucune allocation).
+	*/
+	handshakeHeaders = null;
+	/**
+	* Retient un en-tête du handshake (cf {@link handshakeHeaders}) ; sans effet
+	* une fois la socket ouverte, où il n'y a plus de réponse HTTP.
+	*
+	* @param name - nom de l'en-tête
+	* @param value - valeur
+	* @returns toujours `true`
+	*/
+	setHeader(name, value) {
+		if (this.connection !== null) return true;
+		this.handshakeHeaders ??= {};
+		this.handshakeHeaders[name] = typeof value === "object" ? value.join(", ") : value;
 		return true;
 	}
-	setHeaders() {
+	setHeaders(obj) {
+		if (this.connection !== null) return true;
+		for (const name of Object.keys(obj)) {
+			const value = obj[name];
+			if (value !== void 0) this.setHeader(name, value);
+		}
 		return true;
 	}
 	addCookie(cookie) {
@@ -193,5 +221,4 @@ var WebsocketResponse = class {
 	setCookies() {}
 	setCookie(_cookie) {}
 };
-//#endregion
 export { WebsocketResponse as default, isPeerGoneError };