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

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/http/webResponse.js

@@ -0,0 +1,56 @@
+import { HOP_BY_HOP } from "../../proxy/forward.js";
+import { Readable } from "node:stream";
+// nodefony/src/context/http/webResponse.ts
+/**
+* En-têtes qu'une réponse RELAYÉE (issue de `fetch`) ne garde pas. Son corps a
+* déjà été DÉCODÉ par `fetch` : `content-encoding` et `content-length`
+* décrivent encore les octets compressés de l'amont, et les recopier
+* annoncerait un corps qui n'est pas celui qu'on envoie. Ses cookies
+* appartiennent à l'amont : les relayer les poserait sous le domaine de
+* l'application.
+*/
+const UPSTREAM_ONLY = /* @__PURE__ */ new Set([
+	"content-encoding",
+	"content-length",
+	"set-cookie"
+]);
+/** Corps d'une `Response` sans corps (`new Response(null, { status: 204 })`). */
+const emptyBody = () => Readable.from([], { objectMode: false });
+/**
+* Traduit une `Response` Web standard en statut, en-têtes et corps pour le flux
+* d'octets — sans la lire : le corps reste un flux.
+*
+* Deux origines, deux règles, que `response.type` distingue :
+* - **construite par l'application** (`new Response(…)`, `Response.json(…)`,
+*   `Response.redirect(…)` — `type === "default"`) : ses en-têtes sont les
+*   siens, cookies compris (`getSetCookie()`), et partent tels quels ;
+* - **relayée** (issue de `fetch` — `"basic"`, `"cors"`…) : `content-encoding`,
+*   `content-length` et `set-cookie` de l'amont sont écartés (voir
+*   `UPSTREAM_ONLY`).
+*
+* Les en-têtes de connexion (RFC 9110 §7.6.1 — la liste du relais,
+* `HOP_BY_HOP`) ne partent jamais : ils décrivent un saut, et HTTP/2 les
+* refuse.
+*
+* @param response - une `Response` dont le corps n'a pas été consommé.
+* @returns statut, en-têtes filtrés et corps.
+*/
+function webResponseParts(response) {
+	const relayed = response.type !== "default";
+	const headers = {};
+	for (const [name, value] of response.headers) {
+		if (name === "set-cookie" || HOP_BY_HOP.has(name)) continue;
+		if (relayed && UPSTREAM_ONLY.has(name)) continue;
+		headers[name] = value;
+	}
+	if (!relayed) {
+		const cookies = response.headers.getSetCookie();
+		if (cookies.length > 0) headers["set-cookie"] = cookies;
+	}
+	return {
+		status: response.status,
+		headers,
+		source: response.body ?? emptyBody()
+	};
+}
+export { webResponseParts };

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

@@ -1,4 +1,5 @@
 import HttpResponse from "../http/Response.js";
+import { closeStreamAfterGrace } from "../../servers/http2StreamGrace.js";
 import { thenMaybe } from "nodefony";
 import http from "node:http";
 import http2 from "node:http2";
@@ -10,8 +11,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 +29,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];
@@ -66,15 +70,13 @@ var Http2Response = class extends HttpResponse {
 					if (this.statusCode > 599) this.statusCode = 500;
 				}
 				this.statusMessage = this.getStatusMessage();
+				this.putCorrelationHeaders();
 				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;
-				const traceparent = this.context.traceparent;
-				if (traceparent) this.headers["traceparent"] = traceparent;
-				this.stream.respond(this.headers, { endStream: false });
+				this.stream.respond(this.headers, { endStream: this.headers["grpc-status"] !== void 0 });
 			} else this.log("Headers already sent !!", "WARNING");
 		} else return super.writeHead(statusCode, headers);
 	}
@@ -126,8 +128,9 @@ var Http2Response = class extends HttpResponse {
 		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()`.
+	* Termine la réponse de compatibilité d'un HEAD, ou d'une réponse gRPC
+	* _Trailers-Only_ (statut gRPC dans les en-têtes), dont le flux s'est clos
+	* 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,
@@ -138,7 +141,7 @@ var Http2Response = class extends HttpResponse {
 	*/
 	settleHeadResponse() {
 		const raw = this.response;
-		if (raw !== null && this.context.method === "HEAD" && this.stream?.destroyed === false && !raw.writableEnded) raw.end();
+		if (raw !== null && (this.context.method === "HEAD" || this.headers["grpc-status"] !== void 0) && this.stream?.destroyed === false && !raw.writableEnded) raw.end();
 	}
 	getStatusMessage(code) {
 		if (code) {
@@ -153,5 +156,45 @@ var Http2Response = class extends HttpResponse {
 			message: ""
 		};
 	}
+	/**
+	* Règle le sort d'un corps non lu quand la réponse part avant qu'il soit
+	* consommé (408 délai, 413 trop gros, refus précoce) : les octets en tampon
+	* sont jetés, puis — une fois la réponse écrite — le flux est fermé en
+	* `NO_ERROR` si le client ÉMET ENCORE.
+	*
+	* RFC 9113 §8.1 : après une réponse complète, le serveur PEUT demander au
+	* client d'arrêter d'émettre par un `RST_STREAM` `NO_ERROR`. `node:http2` ne
+	* le fait pas : le flux resterait ouvert tant que le client émet, et un
+	* client lent garderait sa place de flux sur la session. Attendre `finish`
+	* (fin d'écriture) garantit que la réponse elle-même n'est pas tronquée.
+	*
+	* « Émet encore » se décide après une GRÂCE d'un aller-retour
+	* ({@link closeStreamAfterGrace} : un `PING` par session pour tous les
+	* flux qui attendent, puis l'état du flux). Fini → le flux se ferme seul,
+	* sans `RST_STREAM` ; sinon — client qui émet encore, ou muet — fermé.
+	* Jamais de coupe avant la grâce : un `RST_STREAM` soumis pendant que la
+	* réponse attend dans la file de nghttp2 la fait jeter, et le client reçoit
+	* une fin de flux sans statut. grpc-go, Go `net/http2` et nginx coupent AUSSITÔT : Node, lui,
+	* répond avant de lire les trames DATA déjà en route, et la coupe
+	* immédiate frappait des clients qui finissaient d'émettre — le client
+	* HTTP/2 de Go la lit en erreur (ADR-0026 D13 point 1, constaté par la
+	* suite de conformité de Connect). `request.complete` ne dit rien ici : il
+	* ne passe à `true` qu'une fois le corps CONSOMMÉ.
+	*
+	* Chemin d'erreur seulement : un `PING` par aller-retour et par session,
+	* quel que soit le nombre de refus en attente.
+	*
+	* Sans effet si le corps est entièrement consommé, ou le flux déjà fermé.
+	* Peut s'appeler avant comme après l'écriture de la réponse.
+	*/
+	closeUnfinishedRequest() {
+		const stream = this.stream;
+		if (stream === null || stream.closed || stream.destroyed) return;
+		const request = this.context.request.request;
+		if (request.complete) return;
+		request.resume();
+		if (stream.writableFinished) closeStreamAfterGrace(stream);
+		else stream.once("finish", () => closeStreamAfterGrace(stream));
+	}
 };
 export { Http2Response as default, mergeResponseHeaders };

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

@@ -1,3 +1,4 @@
+import { rpcOutcomeOf } from "./rpcOutcome.js";
 import diagnosticsChannel from "node:diagnostics_channel";
 // nodefony/src/context/requestTrace.ts
 /**
@@ -46,7 +47,8 @@ function openRequestTrace(context, protocol) {
 		module: null,
 		statusCode: null,
 		durationMs: null,
-		error: null
+		error: null,
+		rpc: null
 	};
 	context.requestTrace = trace;
 	return trace;
@@ -82,8 +84,9 @@ function runTraced(trace, fn, thisArg, ...args) {
 * @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
+* @param rpc - l'appel RPC de la requête, `null` hors RPC : copié, jamais publié tel quel
 */
-function closeRequestTrace(context, statusCode, error) {
+function closeRequestTrace(context, statusCode, error, rpc = null) {
 	const trace = context.requestTrace;
 	if (trace === null) return;
 	context.requestTrace = null;
@@ -93,6 +96,7 @@ function closeRequestTrace(context, statusCode, error) {
 	trace.routePath = path === void 0 ? null : path === "" ? "/" : path;
 	trace.module = context.logModule ?? route?.module?.name ?? null;
 	trace.statusCode = statusCode;
+	trace.rpc = rpcOutcomeOf(rpc);
 	trace.durationMs = context.stopClock();
 	if (error !== null && error !== void 0) {
 		trace.error = error;

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

@@ -0,0 +1,20 @@
+// nodefony/src/context/rpcOutcome.ts
+/**
+* Copie le résultat d'un appel RPC — les quatre champs, jamais la fiche
+* d'appel entière, qui porte le contrôleur et le contexte (ADR-0026 D10). La
+* forme est fixe : un objet par appel, alloué seulement par qui publie (audit
+* JSON, canal de traçage avec abonné).
+*
+* @param call - l'appel RPC de la requête, `null` hors RPC.
+* @returns sa copie, `null` hors RPC.
+*/
+function rpcOutcomeOf(call) {
+	if (call === null) return null;
+	return {
+		system: call.system,
+		method: call.method,
+		code: call.code,
+		codeName: call.codeName
+	};
+}
+export { rpcOutcomeOf };

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/websocket/Response.js

@@ -194,13 +194,23 @@ var WebsocketResponse = class {
 	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.
+	* une fois la socket ouverte, où il n'y a plus de réponse HTTP — sauf
+	* `Retry-After` posé par une action invoquée par le pont `api.request` : il
+	* va au puits de CETTE invocation, et le pont le sert avec le refus. Le même
+	* code de contrôleur dit donc « réessaie dans N s » sur les deux transports.
+	* Seul cet en-tête passe : un `Set-Cookie` ou un `WWW-Authenticate` n'a
+	* aucun sens sur une trame, et rien d'autre ne doit fuir par là.
 	*
 	* @param name - nom de l'en-tête
 	* @param value - valeur
 	* @returns toujours `true`
 	*/
 	setHeader(name, value) {
+		const sink = RequestContext.get()?.renderSink;
+		if (sink) {
+			if (name.toLowerCase() === "retry-after" && typeof value !== "object") sink.retryAfter = String(value);
+			return true;
+		}
 		if (this.connection !== null) return true;
 		this.handshakeHeaders ??= {};
 		this.handshakeHeaders[name] = typeof value === "object" ? value.join(", ") : value;
@@ -215,8 +225,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,13 +1,14 @@
-import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
-import { closeRequestTrace } from "../requestTrace.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, frameRequestId, 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";
@@ -51,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;
 }
 /**
@@ -72,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;
 	}
 }
@@ -106,15 +107,27 @@ function handshakeRefusalStatus(context, error) {
 * le gate court-circuite AVANT toute allocation/concat (0 surcoût hot path).
 */
 let wsContentLogging = null;
-var WebsocketContext = class extends Context {
+var WebsocketContext = class WebsocketContext 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.
@@ -271,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";
 		}
@@ -284,7 +297,7 @@ var WebsocketContext = class extends Context {
 	}
 	async send(data, encoding) {
 		if (this.response) {
-			const payload = data ?? this.response.body;
+			const payload = data ?? WebsocketContext.takeRenderedBody(this.response);
 			const sink = RequestContext.get()?.renderSink;
 			if (sink) {
 				sink.body = payload;
@@ -297,9 +310,21 @@ var WebsocketContext = class extends Context {
 		}
 		throw new Error("No response found");
 	}
+	/**
+	* Rend le corps rendu (`setBody`) en le RETIRANT de la réponse : une trame
+	* envoyée n'a plus à vivre aussi longtemps que la connexion.
+	*
+	* @param response - la réponse de ce contexte
+	* @returns le corps rendu, ou `null` s'il n'y en a pas
+	*/
+	static takeRenderedBody(response) {
+		const body = response.body;
+		response.body = null;
+		return body;
+	}
 	broadcast(data, encoding) {
 		if (this.response) {
-			const payload = data ?? this.response.body;
+			const payload = data ?? WebsocketContext.takeRenderedBody(this.response);
 			if (payload) {
 				this.logMessageContent("BROADCAST", payload);
 				this.fire("onMessage", payload, this, "BROADCAST");
@@ -311,6 +336,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
@@ -320,9 +367,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`).
@@ -390,11 +436,33 @@ 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);
-		if (this.response) this.response.body = Buffer.isBuffer(data) ? data : Buffer.from(data);
 		try {
 			if (!this.resolver) this.resolver = this.router?.resolve(this) ?? null;
 			else this.resolver.match(this.resolver.route, this);
@@ -406,7 +474,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 };