@nodefony/http 10.0.0-beta.5 → 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;

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

@@ -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,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;
 	}
 }
@@ -110,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.
@@ -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";
 		}
@@ -311,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
@@ -320,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`).
@@ -390,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);
@@ -406,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 };

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

@@ -0,0 +1,71 @@
+import { decideBackpressure, nextDropBalance } from "nodefony";
+// nodefony/src/context/websocket/wsFrameRate.ts
+/** Durée d'une fenêtre de comptage (ms) : la borne s'exprime en trames PAR SECONDE. */
+const FRAME_RATE_WINDOW_MS = 1e3;
+let rejectedTotal = 0;
+/**
+* Nombre cumulé de trames entrantes écartées par la borne de débit dans ce processus (unité : une trame reçue).
+*
+* Monotone, `0` tant que la borne est désactivée. Relayé par la sonde du hub
+* temps réel sous le nom figé `frameRateRejectedTotal` (ADR-0021 §S9).
+*
+* @returns le cumul depuis le démarrage du processus
+*/
+const frameRateRejectedTotal = () => rejectedTotal;
+/**
+* Lit une borne numérique dans les options du serveur WebSocket d'un contexte.
+*
+* Sans allocation ni conversion de type : un serveur sans `options` (HTTP) ou
+* une clé absente rendent `0`.
+*/
+const readOption = (server, key) => {
+	if (typeof server !== "object" || server === null) return 0;
+	if (!("options" in server)) return 0;
+	const opts = server.options;
+	if (typeof opts !== "object" || opts === null || !(key in opts)) return 0;
+	const value = Reflect.get(opts, key);
+	return typeof value === "number" ? value : 0;
+};
+/**
+* Borne de débit entrante du serveur WebSocket (`maxFramesPerSecond`) ; `0` = désactivée.
+*
+* Appelée à chaque trame : une lecture de propriété, aucune allocation.
+*
+* @param server - le serveur du contexte (`context.server`)
+* @returns trames admises par seconde, `0` si la borne est désactivée
+*/
+const readFrameRateBound = (server) => readOption(server, "maxFramesPerSecond");
+/**
+* Solde de refus qui ferme la connexion (`frameRateCloseAfterRejects`) ; `0` = jamais.
+*
+* @param server - le serveur du contexte (`context.server`)
+* @returns le solde de fermeture
+*/
+const readFrameRateCloseAfter = (server) => readOption(server, "frameRateCloseAfterRejects");
+/**
+* Décide du sort d'une trame reçue, AVANT tout décodage : l'admettre, l'écarter, ou fermer la connexion.
+*
+* Compte des TRAMES, pas des octets (`maxPayload` borne déjà la taille). La
+* décision est la règle unique du cœur (`decideBackpressure`), appliquée au
+* nombre de trames de la fenêtre : écarter au-delà de la borne, fermer quand le
+* solde de refus atteint `closeAfter` — jamais au premier dépassement. Une
+* trame écartée est comptée dans {@link frameRateRejectedTotal}.
+*
+* @param win - la fenêtre de la connexion (mutée)
+* @param now - l'instant de réception (ms)
+* @param bound - trames admises par seconde (`> 0`)
+* @param closeAfter - solde de refus qui ferme (`0` = jamais)
+* @returns `"send"` (admettre), `"drop"` (écarter) ou `"close"` (fermer en `1008`)
+*/
+const admitFrame = (win, now, bound, closeAfter) => {
+	if (now - win.start >= 1e3) {
+		win.start = now;
+		win.count = 0;
+	}
+	win.count += 1;
+	const verdict = decideBackpressure(win.count, bound, "drop", closeAfter, win.balance);
+	win.balance = nextDropBalance(verdict, win.balance);
+	if (verdict !== "send") rejectedTotal += 1;
+	return verdict;
+};
+export { FRAME_RATE_WINDOW_MS, admitFrame, frameRateRejectedTotal, readFrameRateBound, readFrameRateCloseAfter };

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

@@ -1,15 +1,18 @@
+import { binaryPayloadLabel } from "nodefony";
 // nodefony/src/context/websocket/wsLogContent.ts
 /**
-* Formatage **pur** (0 état, 0 dépendance) du CONTENU d'un message WebSocket pour
-* le log de trace (Suivi de requête Studio). Séparé de `WebsocketContext` pour
-* être testable aux limites sans serveur.
+* Formatage **pur** (0 état) du CONTENU d'un message WebSocket pour le log de trace
+* (Suivi de requête Studio). Séparé de `WebsocketContext` pour être testable aux
+* limites sans serveur.
 *
 * 🔒 Robustesse binaire (cf doc `ws` — `socket.send(data)` accepte
 * `String | Number | Object | Buffer | ArrayBuffer | TypedArray | DataView |
 * Buffer[] | Blob`, et l'event `message` livre `Buffer | ArrayBuffer | Buffer[]`).
-* **Toute** charge binaire est résumée `[binary N B]` — JAMAIS sérialisée
-* (`JSON.stringify(new Uint8Array(...))` produirait `{"0":..,"1":..}`, énorme et
-* faux). Seules string et objets « JSON » sont rendus en texte (borné).
+* **Toute** charge binaire est résumée `[binary N B]` — JAMAIS vidée octet par
+* octet (`JSON.stringify(new Uint8Array(...))` produirait `{"0":..,"1":..}`, énorme
+* et faux). Quand la connexion a négocié un codec de frame (CBOR, ADR-0022 §2), la
+* trame est en plus DÉCODÉE pour être lisible : le débogage se fait à l'observation,
+* jamais en changeant le fil.
 */
 /** Cap de troncature du contenu loggé (octets/chars). Borne ring + JSONL. */
 const WS_LOG_CONTENT_CAP = 4096;
@@ -40,28 +43,63 @@ function binaryByteLength(data) {
 	return -1;
 }
 /**
+* Octets imbriqués dans une valeur JSON : leur étiquette, jamais leur vidage.
+*
+* Lit la valeur BRUTE chez son parent (`this[key]`) : `JSON.stringify` appelle
+* `toJSON` avant le replacer, et un `Buffer` — ce que rend un décodage depuis la
+* trame de `ws` — y deviendrait `{"type":"Buffer","data":[…]}`.
+*/
+function binaryAsLabel(key, value) {
+	const raw = Reflect.get(this, key);
+	if (ArrayBuffer.isView(raw)) return binaryPayloadLabel(raw.byteLength);
+	if (raw instanceof ArrayBuffer) return binaryPayloadLabel(raw.byteLength);
+	return value;
+}
+/** Sérialisation d'une valeur pour une ligne de journal — jamais de levée. */
+function stringifyForLog(value) {
+	let s;
+	try {
+		s = JSON.stringify(value, binaryAsLabel);
+	} catch {
+		return String(value);
+	}
+	return typeof s === "string" ? s : String(value);
+}
+/** Tronque à `cap` caractères, ellipse comprise au-delà. */
+function bound(s, cap) {
+	return s.length > cap ? `${s.slice(0, cap)}…` : s;
+}
+/**
 * Formate une charge utile WS en chaîne **bornée** et **sûre** pour le log :
 *  - `string` → tronquée à `cap` (+ ellipse) ;
-*  - binaire (cf {@link binaryByteLength}) → `[binary N B]` (jamais de dump) ;
+*  - binaire (cf {@link binaryByteLength}) → `[binary N B]` (jamais de vidage) ;
+*    avec un `codec`, une trame d'un seul tenant est aussi décodée :
+*    `[binary N B] <protocole> <frame en JSON>`, octets imbriqués étiquetés ;
+*    illisible → `[binary N B] <protocole> illisible` ;
 *  - `null`/`undefined` → `""` ;
 *  - objet « JSON » → `JSON.stringify` compact tronqué (cycle, `bigint`, valeur
 *    non sérialisable → repli `String(...)`).
 *
 * @param data - charge utile (RECEIVE/SEND/BROADCAST).
 * @param cap - longueur max avant troncature (défaut {@link WS_LOG_CONTENT_CAP}).
+* @param codec - codec des trames binaires de la connexion, `null` = octets bruts.
+* @returns la ligne à journaliser, jamais plus longue que `cap` + 1.
 */
-function formatWsLogContent(data, cap = WS_LOG_CONTENT_CAP) {
-	if (typeof data === "string") return data.length > cap ? `${data.slice(0, cap)}…` : data;
+function formatWsLogContent(data, cap = WS_LOG_CONTENT_CAP, codec = null) {
+	if (typeof data === "string") return bound(data, cap);
 	if (data === null || data === void 0) return "";
 	const bytes = binaryByteLength(data);
-	if (bytes >= 0) return `[binary ${bytes} B]`;
-	let s;
-	try {
-		s = JSON.stringify(data);
-	} catch {
-		return String(data);
+	if (bytes >= 0) {
+		const label = binaryPayloadLabel(bytes);
+		if (codec === null || !(data instanceof Uint8Array)) return label;
+		let frame;
+		try {
+			frame = codec.decode(data);
+		} catch {
+			return `${label} ${codec.protocol} illisible`;
+		}
+		return bound(`${label} ${codec.protocol} ${stringifyForLog(frame)}`, cap);
 	}
-	if (typeof s !== "string") return String(data);
-	return s.length > cap ? `${s.slice(0, cap)}…` : s;
+	return bound(stringifyForLog(data), cap);
 }
 export { WS_LOG_CONTENT_CAP, binaryByteLength, formatWsLogContent };