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

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

@@ -21,6 +21,85 @@ const COLON = 58;
 * @returns les composants découpés, ou `null` (bail-out → vrai `new URL`).
 */
 function splitTarget(target) {
+	return splitTargetFast(target);
+}
+/**
+* Origine fixe d'un request-target analysé SANS requête HTTP (pont
+* `api.request`) : le chemin y est CONCATÉNÉ, jamais résolu comme relatif — un
+* `//autre/x` reste un pathname `//autre/x`, comme le verrait la porte HTTP,
+* au lieu de devenir une autorité.
+*/
+const DETACHED_ORIGIN = "http://request-target.invalid";
+const HASH = 35;
+const AT = 64;
+/**
+* Découpe un request-target en forme absolue (`http://hôte:port/chemin?q`) :
+* la forme qu'un client envoie à un proxy, et qu'un serveur d'origine DOIT
+* accepter (RFC 9112 §3.2.2). Il DOIT alors ignorer l'en-tête `Host` et prendre
+* l'hôte de la cible — le recoller à `Host` fabriquait un hôte qui n'existe pas.
+*
+* Seuls `http` et `https` sont reconnus (RFC 6455 §4.2.1 vaut aussi pour un
+* handshake WebSocket) ; le schéma de la cible ne remplace jamais celui de la
+* connexion. Une autorité porteuse d'identifiants (`user@hôte`, interdite par
+* RFC 9110 §4.2.4) n'est pas reconnue : `Host` garde la main.
+*
+* Chemin de chaque requête : un seul test de caractère pour la forme origine,
+* aucune allocation.
+*
+* @param target - le request-target brut, tel que reçu.
+* @returns l'autorité et la forme origine, ou `null` pour toute autre forme.
+*/
+function splitAbsoluteForm(target) {
+	if (target === void 0 || target.charCodeAt(0) === SLASH) return null;
+	const sep = target.indexOf("://");
+	if (sep !== 4 && sep !== 5) return null;
+	const scheme = target.slice(0, sep).toLowerCase();
+	if (scheme !== "http" && scheme !== "https") return null;
+	const start = sep + 3;
+	let end = start;
+	while (end < target.length) {
+		const code = target.charCodeAt(end);
+		if (code === SLASH || code === QMARK || code === HASH) break;
+		if (code === AT) return null;
+		end++;
+	}
+	if (end === start) return null;
+	const rest = target.slice(end);
+	return {
+		authority: target.slice(start, end),
+		target: rest.charCodeAt(0) === SLASH ? rest : `/${rest}`
+	};
+}
+/**
+* Analyse un request-target origin-form (`/chemin[?query]`) dans la forme
+* NORMALISÉE que la porte HTTP donne au routeur (`HttpRequest`) : découpe exacte
+* quand le parse WHATWG serait l'identité ({@link splitTarget}), vrai parse
+* WHATWG sinon — dot-segments résolus, `\` replié, percent-encoding posé.
+*
+* Pour qui reçoit un chemin hors d'une requête HTTP — le pont WebSocket
+* `api.request` — et doit router exactement comme HTTP : la même chaîne, deux
+* transports, une seule forme.
+*
+* @param target - le chemin reçu ; il doit commencer par `/`.
+* @returns pathname et search normalisés, ou `null` si `target` n'est pas un
+*   chemin origin-form analysable.
+*/
+function parseRequestTarget(target) {
+	if (target.charCodeAt(0) !== SLASH) return null;
+	const fast = splitTargetFast(target);
+	if (fast !== null) return fast;
+	let url;
+	try {
+		url = new URL(`${DETACHED_ORIGIN}${target}`);
+	} catch {
+		return null;
+	}
+	return {
+		pathname: url.pathname,
+		search: url.search
+	};
+}
+function splitTargetFast(target) {
 	if (typeof target !== "string" || target.length === 0) return null;
 	if (target.charCodeAt(0) !== SLASH) return null;
 	let prev = 0;
@@ -123,4 +202,4 @@ function isDigitsFrom(s, from) {
 	}
 	return true;
 }
-export { isCanonicalAuthority, splitTarget };
+export { isCanonicalAuthority, parseRequestTarget, splitAbsoluteForm, splitTarget };

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

@@ -1,5 +1,5 @@
-import { requestAuthority } from "../transport.js";
 import HttpRequest from "../http/Request.js";
+import { requestAuthority } from "../transport.js";
 // nodefony/src/context/http2/Request.ts
 var Http2Request = class extends HttpRequest {
 	request;

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

@@ -10,8 +10,9 @@ const emptyHeaders = {
 	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.
+* Compose les en-têtes d'une réponse HTTP/2 : ceux qu'un tiers a écrits sur la
+* réponse Node, puis ceux de la réserve de la réponse, puis ceux passés à
+* `writeHead` — chacun l'emporte sur le précédent.
 *
 * Les clés sont ramenées en MINUSCULES : `getHeaders()` rend `content-type`,
 * un contrôleur passe `Content-Type` — fusionnées telles quelles, les deux
@@ -27,11 +28,13 @@ const emptyHeaders = {
 * @param statusMessage - message de statut, recopié en `x-status-message`
 * @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)
+* @param stored - la réserve de la réponse, liste plate aux noms en minuscules
 * @returns les en-têtes à transmettre à `respond()`
 */
-function mergeResponseHeaders(statusMessage, current, extra) {
+function mergeResponseHeaders(statusMessage, current, extra, stored) {
 	const merged = { "x-status-message": statusMessage };
 	for (const name of current.getHeaderNames()) merged[name] = current.getHeader(name);
+	if (stored) for (let i = 0; i + 1 < stored.length; i += 2) merged[String(stored[i])] = stored[i + 1];
 	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];
@@ -68,7 +71,8 @@ var Http2Response = class extends HttpResponse {
 				this.statusMessage = this.getStatusMessage();
 				this.setLength();
 				this.ensureContentTypeHeader();
-				this.headers = mergeResponseHeaders(this.statusMessage, this.response ?? emptyHeaders, headers);
+				this.applyHeaderPolicy(this.contentTypeForPolicy());
+				this.headers = mergeResponseHeaders(this.statusMessage, this.response ?? emptyHeaders, headers, this.headerList());
 				this.headers[HTTP2_HEADER_STATUS] = this.statusCode;
 				const requestId = this.context.requestId;
 				if (requestId) this.headers["x-request-id"] = requestId;
@@ -93,6 +97,7 @@ 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;
 		}
@@ -116,11 +121,29 @@ var Http2Response = class extends HttpResponse {
 	*/
 	end(chunk, encoding) {
 		if (this.stream) {
-			if (this.stream.writableEnded || 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;

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/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

@@ -42,4 +42,23 @@ function alpnProtocolOf(request) {
 function requestAuthority(headers) {
 	return headers[":authority"] ?? headers.host;
 }
-export { alpnProtocolOf, protocolNameOf, requestAuthority };
+/**
+* Une requête HTTP/2 nomme-t-elle deux hôtes — `:authority` ET un `Host`
+* différent ? RFC 9113 §8.3.1 : « SHOULD treat a request as malformed ». Le
+* serveur lit `:authority` ({@link requestAuthority}), mais un code qui lit
+* `headers.host` verrait un autre hôte que celui que le routage et le
+* pare-feu ont jugé.
+*
+* Chemin de chaque requête : une lecture d'en-tête ; la comparaison n'a lieu
+* que si les deux sont présents (un navigateur n'envoie pas `Host` en HTTP/2).
+*
+* @param headers - en-têtes de la requête Node.
+* @returns `true` quand les deux autorités diffèrent (casse ignorée).
+*/
+function hasConflictingAuthority(headers) {
+	const authority = headers[":authority"];
+	if (authority === void 0) return false;
+	const host = headers.host;
+	return host !== void 0 && host.toLowerCase() !== authority.toLowerCase();
+}
+export { alpnProtocolOf, hasConflictingAuthority, protocolNameOf, requestAuthority };

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

@@ -215,8 +215,10 @@ var WebsocketResponse = class {
 		return true;
 	}
 	addCookie(cookie) {
-		if (cookie instanceof Cookie) this.cookies[cookie.name] = cookie;
-		else throw new Error("Response addCookies not valid cookies");
+		if (cookie instanceof Cookie) {
+			cookie.assertGrammar();
+			this.cookies[cookie.name] = cookie;
+		} else throw new Error("Response addCookies not valid cookies");
 	}
 	setCookies() {}
 	setCookie(_cookie) {}

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

@@ -1,12 +1,14 @@
-import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
 import Context from "../Context.js";
-import { toWsCloseReason } from "./wsCloseReason.js";
 import WebsocketResponse from "./Response.js";
+import { toWsCloseReason } from "./wsCloseReason.js";
 import { sanitizeRequestId } from "../requestId.js";
 import { FrameProfile } from "../../profiler/FrameProfile.js";
-import { formatWsLogContent } from "./wsLogContent.js";
+import { WS_LOG_CONTENT_CAP, formatWsLogContent } from "./wsLogContent.js";
+import { admitFrame, readFrameRateBound, readFrameRateCloseAfter } from "./wsFrameRate.js";
+import { closeRequestTrace } from "../requestTrace.js";
+import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
 import { parseWebsocketUrl } from "./websocketUrl.js";
-import { RequestContext, logColor } from "nodefony";
+import { IDENTITY_DEAD_CLOSE_CODE, NOT_FOUND_CLOSE_CODE, ORIGIN_REFUSED_CLOSE_CODE, RequestContext, frameRequestId, logColor } from "nodefony";
 import { AsyncResource } from "node:async_hooks";
 import url, { URL } from "node:url";
 import Ws from "ws";
@@ -50,7 +52,7 @@ function toWsCloseCode(code) {
 	if (code === 1e3 || code >= 1001 && code <= 1003 || code >= 1007 && code <= 1011 || code >= 3e3 && code <= 4999) return code;
 	if (code >= 500 && code < 600) return 1011;
 	if (code === 401 || code === 403 || code === 421) return 1008;
-	if (code >= 400 && code < 500) return 4004;
+	if (code >= 400 && code < 500) return NOT_FOUND_CLOSE_CODE;
 	return 1011;
 }
 /**
@@ -71,11 +73,11 @@ function toHandshakeStatus(code) {
 		case 1003:
 		case 1007: return 400;
 		case 1008:
-		case 4003: return 403;
-		case 4001: return 401;
+		case ORIGIN_REFUSED_CLOSE_CODE: return 403;
+		case IDENTITY_DEAD_CLOSE_CODE: return 401;
 		case 1009: return 413;
 		case 1013: return 503;
-		case 4004: return 404;
+		case NOT_FOUND_CLOSE_CODE: return 404;
 		default: return 500;
 	}
 }
@@ -109,11 +111,23 @@ var WebsocketContext = class extends Context {
 	request;
 	response = null;
 	acceptedProtocol;
+	/**
+	* Codec des trames BINAIRES de cette connexion, posé par la couche qui l'a négocié
+	* (le temps réel, ADR-0022 §2). Hors production, le traceur s'en sert pour
+	* afficher une trame binaire décodée plutôt que sa seule taille ; jamais lu en
+	* production. `null` = octets bruts, résumés à leur taille.
+	*/
+	frameCodec = null;
 	port;
 	rejected = false;
 	teardownWired = false;
 	connection = null;
 	/**
+	* Fenêtre de la borne de débit entrante — `null` tant que la borne est
+	* désactivée ou qu'aucune trame n'est arrivée (créée au premier usage).
+	*/
+	frameRate = null;
+	/**
 	* Le verdict du handshake encore à rendre : posé par le noyau tant que le
 	* pipeline décide (pare-feu, garde de l'action), `null` dès que la socket
 	* est acceptée ou refusée. Tant qu'il est là, AUCUN `101` n'est parti.
@@ -173,16 +187,16 @@ var WebsocketContext = class extends Context {
 			this.log(`PROXY WEBSOCKET REQUEST ${fwd.fromStandard ? "Forwarded (RFC 7239)" : "x-forwarded"} VIA : ${this.proxy.proxyVia}`, "DEBUG");
 		}
 	}
-	log(pci, severity, msgid, msg) {
+	log(pci, severity, msgid, msg, moduleName) {
 		if (!msgid) msgid = "WEBSOCKET CONTEXT";
-		return super.log(pci, severity, msgid, msg);
+		return super.log(pci, severity, msgid, msg, moduleName);
 	}
 	logRequest(httpError, acceptedProtocol) {
 		try {
 			const logger = this.httpKernel?.getRequestLogger();
 			if (!logger) return;
 			const entry = logger.renderWebsocket(this, httpError ?? null, acceptedProtocol ?? null);
-			const pdu = this.log(entry.text, entry.severity, entry.msgid);
+			const pdu = this.log(entry.text, entry.severity, entry.msgid, void 0, this.logModule ?? this.resolver?.route?.module?.name);
 			pdu.requestId ??= this.requestId;
 			return pdu;
 		} catch {
@@ -215,6 +229,7 @@ var WebsocketContext = class extends Context {
 		this.rejected = true;
 		this.webSocketState = "error";
 		admission.refuse(status, this.response?.handshakeHeaders ?? null);
+		if (this.requestTrace !== null) closeRequestTrace(this, status, this.error);
 		return true;
 	}
 	async connect() {
@@ -228,6 +243,7 @@ var WebsocketContext = class extends Context {
 		this.requestEnded = true;
 		this.connection.on("message", AsyncResource.bind(this.handleMessage.bind(this)));
 		this.logRequest(null, this.acceptedProtocol ?? null);
+		if (this.requestTrace !== null) closeRequestTrace(this, 101, null);
 		this.webSocketState = "connected";
 		return this.connection;
 	}
@@ -268,7 +284,7 @@ var WebsocketContext = class extends Context {
 				}
 			});
 		} else if (!this.isRejected()) {
-			this.reject(4004, "Not Found");
+			this.reject(NOT_FOUND_CLOSE_CODE, "Not Found");
 			this.rejected = true;
 			this.webSocketState = "error";
 		}
@@ -308,6 +324,28 @@ var WebsocketContext = class extends Context {
 		return null;
 	}
 	/**
+	* Le contenu des messages est-il journalisé ? Hors production seulement —
+	* décidé une fois pour le processus (P8 : runtime ∈ {development, production},
+	* `resolveRuntimeEnv`).
+	*/
+	tracesMessageContent() {
+		wsContentLogging ??= this.kernel?.environment !== "production";
+		return wsContentLogging;
+	}
+	/**
+	* Traceur des trames SORTANTES écrites hors de {@link send} — le temps réel
+	* écrit droit sur la socket. À demander UNE fois par connexion : `null` en
+	* production, donc l'appelant choisit son chemin d'écriture à l'ouverture et
+	* ne paie rien par trame.
+	*
+	* @returns une fonction qui journalise une trame comme `send` (`WS SEND`),
+	*   ou `null` quand le contenu des messages n'est pas journalisé.
+	*/
+	outboundTracer() {
+		if (!this.tracesMessageContent()) return null;
+		return (data) => this.logMessageContent("SEND", data);
+	}
+	/**
 	* Logge le CONTENU d'un message WS (corrélé `requestId` via l'override `log`),
 	* gaté hors prod et borné — le Suivi de requête (Studio) le surface alors par
 	* direction. Hot path : le gate booléen court-circuite en prod AVANT toute
@@ -317,9 +355,8 @@ var WebsocketContext = class extends Context {
 	* @param data - charge utile (string, Buffer binaire, objet, ou null).
 	*/
 	logMessageContent(dir, data) {
-		wsContentLogging ??= this.kernel?.environment !== "production";
-		if (!wsContentLogging) return;
-		this.log(formatWsLogContent(data), "DEBUG", `WS ${dir}`);
+		if (!this.tracesMessageContent()) return;
+		this.log(formatWsLogContent(data, WS_LOG_CONTENT_CAP, this.frameCodec), "DEBUG", `WS ${dir}`);
 	}
 	/**
 	* Ouvre le profil d'**une invocation** du pont RPC (une frame `api.request`).
@@ -337,10 +374,11 @@ var WebsocketContext = class extends Context {
 	*          zéro allocation dans ce cas.
 	*/
 	beginFrame(method, framePath) {
-		if (!this.profiling && !this.timingEnabled) return null;
+		const profiled = this.profiling && this.httpKernel?.shouldProfile(framePath) === true;
+		if (!profiled && !this.timingEnabled) return null;
 		this.#frameSeq += 1;
 		return new FrameProfile({
-			requestId: `${this.requestId}.${this.#frameSeq}`,
+			requestId: frameRequestId(this.requestId, this.#frameSeq),
 			type: this.type,
 			scheme: this.scheme,
 			method,
@@ -350,7 +388,7 @@ var WebsocketContext = class extends Context {
 			security: this.security ?? null,
 			securityTrace: this.securityTrace,
 			timing: this.timingEnabled,
-			queries: this.profiling
+			queries: profiled
 		});
 	}
 	/**
@@ -358,7 +396,7 @@ var WebsocketContext = class extends Context {
 	* Profiler (no-op hors dev, ou si aucun profil n'a été ouvert).
 	*/
 	collectFrame(frame) {
-		if (frame === null || !this.profiling) return;
+		if (frame === null || !frame.profiled) return;
 		this.get("profiler")?.collect(frame);
 	}
 	/**
@@ -386,7 +424,30 @@ var WebsocketContext = class extends Context {
 		}
 		super.phaseEnd(name);
 	}
+	/**
+	* Applique la borne de débit entrante à une trame : `true` = l'admettre.
+	*
+	* Écartée → comptée (`frameRateRejectedTotal`) ; solde de refus atteint →
+	* connexion fermée en `1008` (RFC 6455 §7.4.1, violation de politique).
+	*
+	* @param bound - trames admises par seconde (`> 0`)
+	* @returns `true` si la trame poursuit son chemin
+	*/
+	admitInboundFrame(bound) {
+		const now = Date.now();
+		this.frameRate ??= {
+			start: now,
+			count: 0,
+			balance: 0
+		};
+		const verdict = admitFrame(this.frameRate, now, bound, readFrameRateCloseAfter(this.server));
+		if (verdict === "send") return true;
+		if (verdict === "close") this.connection?.close(1008, "frame rate");
+		return false;
+	}
 	async handleMessage(data, isBinary) {
+		const bound = readFrameRateBound(this.server);
+		if (bound > 0 && !this.admitInboundFrame(bound)) return void 0;
 		this.webSocketState = "message";
 		const message = isBinary ? data : data.toString();
 		this.logMessageContent("RECEIVE", message);
@@ -402,7 +463,7 @@ var WebsocketContext = class extends Context {
 				} } });
 				return callAsPromise(this.resolver, [message]);
 			} else if (!this.rejected) {
-				this.reject(4004, "Not Found");
+				this.reject(NOT_FOUND_CLOSE_CODE, "Not Found");
 				this.rejected = true;
 			}
 			return;

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

@@ -1,3 +1,4 @@
+import { splitAbsoluteForm } from "../http/urlFastPath.js";
 // nodefony/src/context/websocket/websocketUrl.ts
 /**
 * URL d'une requête d'upgrade WebSocket, telle que le pipeline la lit.
@@ -8,6 +9,10 @@
 * un hôte de l'autre — et une route acceptée par l'une serait refusée par
 * l'autre.
 *
+* Une cible en forme absolue (`http://hôte/chemin`, RFC 6455 §4.2.1) donne son
+* hôte, et l'en-tête `Host` est ignoré (RFC 9112 §3.2.2) — la même règle que
+* `HttpRequest.getHost`.
+*
 * @param scheme - `ws` ou `wss`
 * @param host - en-tête `Host` de la requête (`localhost` s'il manque)
 * @param rawUrl - cible brute de la requête (`/` si elle manque)
@@ -15,6 +20,8 @@
 * @throws TypeError si l'hôte ou la cible ne forment pas une URL
 */
 function parseWebsocketUrl(scheme, host, rawUrl) {
+	const absolute = splitAbsoluteForm(rawUrl);
+	if (absolute !== null) return new URL(`${scheme}://${absolute.authority}${absolute.target}`);
 	return new URL(`${scheme}://${host ?? "localhost"}${rawUrl ?? "/"}`);
 }
 export { parseWebsocketUrl };

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

@@ -1,3 +1,4 @@
+import { TRY_AGAIN_LATER_CLOSE_CODE, decideBackpressure, nextDropBalance } from "nodefony";
 // nodefony/src/context/websocket/wsBackpressure.ts
 /**
 * Relit le seuil + la politique depuis les options du `WebSocketServer`.
@@ -29,27 +30,26 @@ const readBackpressureOptions = (wss) => {
 * « Try Again Later » → le client peut back-off + reconnecter). NE FAIT PAS le `send()`
 * — le caller émet uniquement si le retour vaut `"send"`.
 *
+* La DÉCISION est celle du cœur (`decideBackpressure` / `nextDropBalance`, partagée
+* avec `NodefonySocket`) ; cette fonction n'en porte que l'état (compteurs sur la
+* socket) et le geste serveur (fermeture `1013`).
+*
 * @param ws - la socket destinataire
 * @param max - seuil d'octets (`<= 0` → désactivé)
 * @param policy - action au dépassement
+* @param closeAfterDrops - solde de refus qui ferme (`0` = jamais)
 * @returns `"send"` (émettre) · `"drop"` (sauter cette frame) · `"close"` (socket fermée)
 */
 const decideSend = (ws, max, policy, closeAfterDrops = 0) => {
-	const sock = ws;
-	if (max <= 0 || (ws.bufferedAmount ?? 0) <= max) {
-		if (sock._nfDropStreak) sock._nfDropStreak -= 1;
-		return "send";
-	}
-	sock._nfDrops = (sock._nfDrops ?? 0) + 1;
-	const streak = sock._nfDropStreak = (sock._nfDropStreak ?? 0) + 1;
-	if (policy === "close") {
-		ws.close(1013, "backpressure");
-		return "close";
-	}
-	if (closeAfterDrops > 0 && streak >= closeAfterDrops) {
-		ws.close(1013, "backpressure");
-		return "close";
+	const balance = ws._nfDropStreak ?? 0;
+	const verdict = decideBackpressure(ws.bufferedAmount ?? 0, max, policy, closeAfterDrops, balance);
+	if (verdict === "send") {
+		if (balance > 0) ws._nfDropStreak = balance - 1;
+		return verdict;
 	}
-	return "drop";
+	ws._nfDrops = (ws._nfDrops ?? 0) + 1;
+	ws._nfDropStreak = nextDropBalance(verdict, balance);
+	if (verdict === "close") ws.close(TRY_AGAIN_LATER_CLOSE_CODE, "backpressure");
+	return verdict;
 };
 export { decideSend, readBackpressureOptions };