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

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

package/dist/nodefony/src/cookies/cookie.js

@@ -1,10 +1,29 @@
 import { extend } from "nodefony";
 import crypto from "node:crypto";
-import { parseCookie } from "cookie";
+import { parseCookie, stringifySetCookie } from "cookie";
 import MS from "ms";
 // nodefony/src/cookies/cookie.ts
 const encode = encodeURIComponent;
-const decode = decodeURIComponent;
+/**
+* Décode une valeur de cookie sans jamais lever : une séquence `%` invalide
+* rend la valeur brute (règle du paquet `cookie`). Un `decodeURIComponent`
+* nu levait dans le constructeur du contexte, et la requête restait sans
+* réponse (`Cookie: a=50%25`).
+*/
+function decode(value) {
+	if (!value.includes("%")) return value;
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+/**
+* Lecture de l'en-tête `Cookie` SANS décodage : la valeur est décodée une
+* seule fois, par {@link Cookie.setValue}. Décoder aux deux endroits
+* transformait `a%2541` en `aA` au lieu de `a%41`.
+*/
+const RAW_VALUES = { decode: (value) => value };
 const cookieDefaultSettings = {
 	maxAge: 0,
 	path: "/",
@@ -15,9 +34,6 @@ const cookieDefaultSettings = {
 	signed: false,
 	secret: "!nodefony.secret!"
 };
-function parser(strToParse) {
-	return parseCookie(strToParse);
-}
 function cookiesParser(context) {
 	let cookies = null;
 	let co;
@@ -25,7 +41,7 @@ function cookiesParser(context) {
 		case "http":
 			if (context.request.request.headers.cookie) cookies = context.request.request.headers.cookie;
 			if (cookies) {
-				const obj = parser(cookies);
+				const obj = parseCookie(cookies, RAW_VALUES);
 				for (const cookie in obj) {
 					co = new Cookie(cookie, obj[cookie]);
 					context.addRequestCookie(co);
@@ -36,7 +52,7 @@ function cookiesParser(context) {
 		case "websocket": {
 			const cookieHeader = context.request?.headers.cookie;
 			if (cookieHeader) {
-				const parsed = parser(cookieHeader);
+				const parsed = parseCookie(cookieHeader, RAW_VALUES);
 				for (const name in parsed) {
 					co = new Cookie(name, parsed[name]);
 					context.addRequestCookie(co);
@@ -165,14 +181,39 @@ var Cookie = class Cookie {
 	setPriority(val) {
 		return val;
 	}
+	/**
+	* Durée de vie restante en SECONDES ENTIÈRES, `undefined` sous une seconde.
+	*
+	* RFC 6265 §4.1.1 : `max-age-av = "Max-Age=" non-zero-digit *DIGIT`. Un
+	* `Max-Age=3599.874` est ignoré par le navigateur, et le cookie devient un
+	* cookie de session. Arrondi INFÉRIEUR : le cookie ne survit jamais à son
+	* `Expires`.
+	*/
 	getMaxAge() {
-		if (this.expires && this.expires instanceof Date) {
-			const s = (this.expires.getTime() - (/* @__PURE__ */ new Date()).getTime()) / 1e3;
-			if (s > 0) this.maxAge = s;
-			else this.maxAge = void 0;
-		} else this.maxAge = this.originalMaxAge;
+		const seconds = this.expires instanceof Date ? (this.expires.getTime() - Date.now()) / 1e3 : this.originalMaxAge;
+		const whole = seconds === void 0 ? 0 : Math.floor(seconds);
+		this.maxAge = whole >= 1 ? whole : void 0;
 		return this.maxAge;
 	}
+	/**
+	* Vérifie la grammaire RFC 6265 §4.1.1 du nom, du `Path` et du `Domain`,
+	* au moment où le cookie est POSÉ sur la réponse.
+	*
+	* Sans elle, `path: "/; Domain=evil.example"` injectait un attribut, et un
+	* nom porteur de `;` partait tel quel. La grammaire est celle du paquet
+	* `cookie` : une seule implémentation.
+	*
+	* @throws {TypeError} nommant l'attribut hors grammaire.
+	*/
+	assertGrammar() {
+		const attributes = {
+			name: this.name,
+			value: ""
+		};
+		if (this.path !== void 0) attributes.path = this.path;
+		if (this.domain !== void 0) attributes.domain = this.domain;
+		stringifySetCookie(attributes);
+	}
 	toString() {
 		return `${this.name}=${encode(String(this.value))}`;
 	}
@@ -251,4 +292,4 @@ var Cookie = class Cookie {
 		return obj;
 	}
 };
-export { cookiesParser, Cookie as default, parser };
+export { cookiesParser, Cookie as default };

package/dist/nodefony/src/profiler/FrameProfile.js

@@ -37,12 +37,22 @@ var FrameProfile = class {
 	* invocation, il redevient exact, et le SQL se replace dans le waterfall.
 	*/
 	profilerQueries;
+	/**
+	* Ce profil sera-t-il gardé par le Profiler ? Faux quand seul le timing
+	* l'a ouvert (chemin d'outillage) : son id ne désigne alors aucun profil
+	* lisible, et ne doit pas être annoncé au client.
+	*/
+	get profiled() {
+		return this.profilerQueries !== null;
+	}
 	/** Resolver de la frame — porte route / controller / action. */
 	resolver = null;
 	/** Statut HTTP-équivalent de l'invocation (200, 403, 404…). */
 	response = null;
 	error = null;
 	timing;
+	clockStartMs;
+	durationMs = null;
 	constructor(init) {
 		this.requestId = init.requestId;
 		this.type = init.type;
@@ -54,9 +64,20 @@ var FrameProfile = class {
 		this.security = init.security;
 		this.securityTrace = init.securityTrace;
 		this.timing = init.timing;
+		this.clockStartMs = init.timing ? performance.now() : 0;
 		this.profilerQueries = init.queries ? [] : null;
 	}
 	/**
+	* Arrête l'horloge de la frame (au premier appel) et rend sa durée en ms ;
+	* `null` si le timing est éteint. Contrat de `IContext.stopClock`.
+	*
+	* @returns la durée de l'invocation, ou `null`
+	*/
+	stopClock() {
+		if (!this.timing) return null;
+		return this.durationMs ??= performance.now() - this.clockStartMs;
+	}
+	/**
 	* Ouvre une phase. Contrairement au `Context`, l'index est un **scan arrière**
 	* (pas de `Map<nom, index>`) : une frame porte une poignée de phases, et une
 	* phase peut être ré-entrante (une action qui en déclenche une autre) — la
@@ -88,6 +109,7 @@ var FrameProfile = class {
 	* @param error - l'erreur qui a interrompu la frame, le cas échéant.
 	*/
 	finish(status, error) {
+		this.stopClock();
 		this.response = { statusCode: status };
 		if (error !== void 0 && error !== null) this.error = { message: thrownMessage(error) };
 	}

package/dist/nodefony/src/profiler/Profiler.js

@@ -1,24 +1,9 @@
 import { profileLane } from "./aggregate.js";
+import { frameIndexOf } from "nodefony";
 // nodefony/src/profiler/Profiler.ts
-/**
-* Durée totale = (fin de la dernière phase) − (début de la 1ère).
-*
-* Une phase encore OUVERTE à la collecte (action interrompue par le départ du
-* client : flux SSE, outil MCP annulé) court jusqu'à la collecte — la compter
-* pour zéro publiait 0,3 ms pour un appel coupé à 3 s.
-*/
-function totalDuration(phases) {
-	if (phases.length === 0) return null;
-	const first = phases.at(0);
-	if (first === void 0 || typeof first.startMs !== "number") return null;
-	let end = first.startMs;
-	let now = null;
-	for (const p of phases) {
-		const e = p.durationMs === void 0 ? now ??= performance.now() : p.startMs + p.durationMs;
-		if (e > end) end = e;
-	}
-	const d = end - first.startMs;
-	return d >= 0 ? Math.round(d * 1e3) / 1e3 : null;
+/** Arrondit une durée à la microseconde (affichage du Suivi). */
+function roundMicro(ms) {
+	return ms === null ? null : Math.round(ms * 1e3) / 1e3;
 }
 /** Capacité par défaut du ring buffer (assez pour une session de debug). */
 const DEFAULT_CAP = 500;
@@ -46,6 +31,14 @@ var Profiler = class {
 	/** Dernier numéro d'ordre attribué (0 = aucun profil collecté). */
 	_seq = 0;
 	/**
+	* Démarrage du profileur, donc du processus (ms epoch, horloge du serveur) :
+	* aucune requête servie avant n'est connue. Rendu avec un profil absent, pour
+	* que le lecteur dise « le serveur a redémarré » plutôt que « évincé ».
+	*/
+	startedAt = Date.now();
+	/** Dernier vidage des anneaux (ms epoch), `null` s'il n'y en a jamais eu. */
+	_clearedAt = null;
+	/**
 	* @param cap - capacité de l'anneau de l'application.
 	* @param sideCap - capacité de chacun des anneaux de l'outillage et des
 	*          assets relayés.
@@ -77,7 +70,7 @@ var Profiler = class {
 			url: ctx.url ?? "",
 			scheme: ctx.scheme ?? "",
 			status: ctx.response?.statusCode ?? (ctx.error ? 500 : null),
-			durationMs: totalDuration(phases),
+			durationMs: roundMicro(ctx.stopClock()),
 			route: ctx.resolver?.route?.name ?? null,
 			controller: ctx.resolver?.controller?.name ?? null,
 			action: ctx.resolver?.actionName ?? null,
@@ -112,12 +105,17 @@ var Profiler = class {
 	}
 	/**
 	* Résumés des requêtes les plus récentes (récent → ancien), capés à `limit`.
+	*
+	* @param limit - nombre maximal de résumés
+	* @param connection - le requestId d'une connexion WebSocket : ses SEULES
+	*   frames du pont (`<connection>.<n>`, règle `frameIndexOf` du cœur)
 	*/
-	recent(limit = 60) {
+	recent(limit = 60, connection) {
 		const out = [];
 		const entries = this.#collectAfter(0).reverse();
 		for (const e of entries) {
 			if (out.length >= limit) break;
+			if (connection && frameIndexOf(e.requestId, connection) === null) continue;
 			out.push({
 				requestId: e.requestId,
 				ts: e.ts,
@@ -161,12 +159,17 @@ var Profiler = class {
 		const { app, tooling, asset } = this._lanes;
 		return app.size + tooling.size + asset.size;
 	}
-	/** Vide les anneaux. */
+	/** Vide les anneaux, et retient l'instant du vidage ({@link clearedAt}). */
 	clear() {
 		const { app, tooling, asset } = this._lanes;
 		app.clear();
 		tooling.clear();
 		asset.clear();
+		this._clearedAt = Date.now();
+	}
+	/** Dernier vidage des anneaux (ms epoch, horloge du serveur), `null` si aucun. */
+	get clearedAt() {
+		return this._clearedAt;
 	}
 	/**
 	* Profils de numéro supérieur à `from`, tous anneaux confondus, du plus

package/dist/nodefony/src/profiler/aggregate.js

@@ -1,4 +1,5 @@
 import { MODULE_PROXY_PREFIXES } from "../proxy/rules.js";
+import { isConsolePath } from "nodefony";
 // nodefony/src/profiler/aggregate.ts
 /**
 * Agrégation des profils de requêtes — règle PURE, sans horloge ni I/O.
@@ -22,20 +23,28 @@ const ROUTE_SAMPLE_CAP = 256;
 const SQL_SHAPE_CAP = 200;
 /** Exemples d'erreurs retenus (statut ≥ 500 ou exception). */
 const ERROR_SAMPLE_CAP = 10;
-/** Préfixe des routes de l'outillage (console, API d'administration, porte MCP). */
+/**
+* Préfixe de l'espace réservé au framework.
+*
+* @deprecated Ne dit pas ce qui est de l'outillage : une connexion
+*   d'utilisateur (`/nodefony/security/api/auth/…`) ou une route d'application
+*   (`/nodefony/test/index`) passent sous ce préfixe. La règle est
+*   `isConsolePath` (`nodefony`), que `profileLane` appelle.
+*/
 const TOOLING_URL_PREFIX = "/nodefony/";
 /**
-* Range un profil par provenance, d'après son URL. Seule règle du partage —
-* les anneaux du profileur et le filtre de l'agrégation la lisent tous deux.
+* Range un profil par provenance, d'après son URL. L'outillage est reconnu par
+* la règle du cœur, `isConsolePath` — la même que les Journaux, la barre de
+* débogage et le Studio : une connexion d'utilisateur reste de l'application.
+* Les anneaux du profileur et le filtre de l'agrégation la lisent tous deux.
 *
 * @param url - URL du profil, absolue ou chemin.
 * @returns la provenance du profil.
 */
 function profileLane(url) {
 	const path = urlPath(url);
-	if (path.startsWith("/nodefony/")) return "tooling";
 	for (const prefix of MODULE_PROXY_PREFIXES) if (path.startsWith(prefix)) return "asset";
-	return "app";
+	return isConsolePath(path) ? "tooling" : "app";
 }
 /**
 * Le profil vient-il de l'outillage (routes `/nodefony/…` ou assets relayés)
@@ -46,6 +55,17 @@ function profileLane(url) {
 function isToolingUrl(url) {
 	return profileLane(url) !== "app";
 }
+/**
+* Une requête de cette URL se profile-t-elle ? L'application toujours ;
+* l'outillage et les assets relayés seulement sur demande (`timing.tooling`)
+* — on ne mesure pas la façon dont on mesure.
+*
+* @param url - URL ou chemin de la requête (ou de la frame du pont)
+* @param tooling - profiler aussi l'outillage
+*/
+function isProfiledUrl(url, tooling) {
+	return tooling || profileLane(url) === "app";
+}
 /** Groupe des requêtes qu'aucune route n'a servies (404, statique, sondes). */
 const NO_ROUTE = "(aucune route)";
 /** Pseudo-phase : le temps de l'action hors phases imbriquées et hors SQL. */
@@ -419,4 +439,4 @@ function aggregateProfiles(entries, options = {}) {
 	for (const entry of entries) aggregator.add(entry);
 	return aggregator.result();
 }
-export { ACTION_SELF_PHASE, ERROR_SAMPLE_CAP, NO_ROUTE, N_PLUS_ONE_MIN_REPEATS, ROUTE_SAMPLE_CAP, SQL_SHAPE_CAP, TOOLING_URL_PREFIX, aggregateProfiles, createProfileAggregator, isFailedProfile, isToolingUrl, profileLane, sqlShape, urlPath };
+export { ACTION_SELF_PHASE, ERROR_SAMPLE_CAP, NO_ROUTE, N_PLUS_ONE_MIN_REPEATS, ROUTE_SAMPLE_CAP, SQL_SHAPE_CAP, TOOLING_URL_PREFIX, aggregateProfiles, createProfileAggregator, isFailedProfile, isProfiledUrl, isToolingUrl, profileLane, sqlShape, urlPath };

package/dist/nodefony/src/proxy/forward.js

@@ -1,3 +1,4 @@
+import { isUnsupportedTransferCoding } from "./rules.js";
 import http from "node:http";
 import https from "node:https";
 // nodefony/src/proxy/forward.ts
@@ -83,6 +84,71 @@ function viaLoops(via, pseudonym) {
 	for (const hop of hops) if (hop.trim().split(/\s+/)[1] === pseudonym) return true;
 	return false;
 }
+/** `1*DIGIT` (RFC 9110 §7.6.2) — compilé une fois. */
+const DIGITS = /^[0-9]+$/;
+/**
+* `Max-Forwards` reçu, tel qu'un intermédiaire doit le lire (RFC 9110 §7.6.2) :
+* sur `OPTIONS` et `TRACE` seulement — la même section permet de l'ignorer
+* pour toute autre méthode, et il part alors tel quel.
+*
+* @param method - méthode de la requête
+* @param value - en-tête `Max-Forwards` reçu
+* @returns `null` s'il n'y a rien à faire (autre méthode, en-tête absent) ;
+*   `-1` si la valeur n'est pas `1*DIGIT` — elle ne se décrémente pas, l'en-tête
+*   n'est donc pas transmis ; sinon la valeur reçue (`0` : le proxy répond
+*   lui-même, sans joindre l'amont).
+*/
+function receivedMaxForwards(method, value) {
+	if (value === void 0 || method !== "OPTIONS" && method !== "TRACE") return null;
+	const raw = (Array.isArray(value) ? value[0] : value)?.trim() ?? "";
+	return DIGITS.test(raw) ? Number(raw) : -1;
+}
+/**
+* En-têtes qu'une réponse à `TRACE` ne renvoie pas : ils portent des secrets
+* (RFC 9110 §9.3.8 : le destinataire final DEVRAIT exclure les champs
+* susceptibles de contenir des données sensibles).
+*/
+const TRACE_SENSITIVE = /^(?:authorization|proxy-authorization|cookie)$|token|secret|session|api-?key|csrf/i;
+/**
+* Corps `message/http` d'une réponse à `TRACE` : la requête reçue, en-têtes
+* sensibles et pseudo-en-têtes HTTP/2 retirés (RFC 9110 §9.3.8).
+*/
+function traceEcho(req) {
+	let echo = `TRACE ${req.url ?? "/"} HTTP/${req.httpVersion}\r\n`;
+	const authority = req.headers[":authority"];
+	if (req.headers.host === void 0 && typeof authority === "string") echo += `host: ${authority}\r\n`;
+	for (const name of Object.keys(req.headers)) {
+		if (name.charCodeAt(0) === 58 || TRACE_SENSITIVE.test(name)) continue;
+		echo += `${name}: ${flat(req.headers[name])}\r\n`;
+	}
+	return `${echo}\r\n`;
+}
+/**
+* Réponse du proxy en DESTINATAIRE FINAL, quand `Max-Forwards` est épuisé
+* (RFC 9110 §7.6.2) : `TRACE` renvoie la requête reçue (§9.3.8), `OPTIONS`
+* rend 200 avec `Allow` si le montage restreint ses méthodes, et
+* `Content-Length: 0` (§9.3.7). L'amont n'est jamais joint.
+*/
+function answerAsFinalRecipient(req, out, mount) {
+	req.resume();
+	if (req.method === "TRACE") {
+		const body = traceEcho(req);
+		out.writeHead(200, {
+			"content-type": "message/http",
+			"content-length": Buffer.byteLength(body),
+			"cache-control": "no-store"
+		});
+		out.end(body);
+		return;
+	}
+	const headers = {
+		"content-length": 0,
+		"cache-control": "no-store"
+	};
+	if (mount.methods !== void 0) headers.allow = mount.methods.join(", ");
+	out.writeHead(200, headers);
+	out.end();
+}
 /** Entrée `Via` de ce saut : `<version> <pseudonyme>` (RFC 9110 §7.6.3). */
 function viaEntry(httpVersion, pseudonym) {
 	return `${httpVersion.startsWith("2") ? "2" : httpVersion || "1.1"} ${pseudonym}`;
@@ -98,10 +164,7 @@ function viaEntry(httpVersion, pseudonym) {
 */
 function bodyFramingOf(req) {
 	const coding = req.headers["transfer-encoding"];
-	if (coding !== void 0) {
-		if (coding === "chunked") return "chunked";
-		return coding.trim().toLowerCase() === "chunked" ? "chunked" : "unsupported";
-	}
+	if (coding !== void 0) return isUnsupportedTransferCoding(coding) ? "unsupported" : "chunked";
 	if (req.headers["content-length"] !== void 0) return "length";
 	const stream = req.stream;
 	if (stream !== void 0 && !stream.endAfterHeaders) return "chunked";
@@ -264,8 +327,9 @@ function armConnectTimeout(upstream, ms, onTimeout) {
 * Relaie une requête HTTP vers l'amont et renvoie sa réponse au client.
 *
 * Le corps est transmis avec un cadrage cohérent ({@link bodyFramingOf}). Un
-* message qui porte déjà notre `Via` rend 508 sans contacter l'amont. Un
-* client parti coupe l'échange amont ; un amont injoignable rend 502 ; une
+* message qui porte déjà notre `Via` rend 508 sans contacter l'amont. Sur
+* `OPTIONS` et `TRACE`, `Max-Forwards` est décrémenté ; à `0`, le proxy répond
+* lui-même en destinataire final (RFC 9110 §7.6.2). Un client parti coupe l'échange amont ; un amont injoignable rend 502 ; une
 * connexion non établie à temps ou un amont muet rendent 504 — à condition
 * que rien n'ait encore été envoyé, sinon la réponse est interrompue (un
 * statut ne se rattrape pas). Un amont coupé en plein corps interrompt la
@@ -307,10 +371,21 @@ function forwardRequest(req, res, mount, target, from, relay) {
 			fail(501, NOT_IMPLEMENTED);
 			return;
 		}
+		const method = req.method ?? "GET";
+		const hops = receivedMaxForwards(method, req.headers["max-forwards"]);
+		if (hops === 0) {
+			answerAsFinalRecipient(req, out, mount);
+			return;
+		}
 		const options = requestOptions(target, mount, relay);
-		options.method = req.method ?? "GET";
+		options.method = method;
 		options.path = upstreamPath(req.url ?? "/", mount);
-		options.headers = requestHeadersFor(req.headers, mount, target, from, relay.pseudonym, framing);
+		const headers = requestHeadersFor(req.headers, mount, target, from, relay.pseudonym, framing);
+		if (hops !== null) {
+			if (hops > 0) headers["max-forwards"] = String(Math.min(hops - 1, 10));
+			else delete headers["max-forwards"];
+		}
+		options.headers = headers;
 		if (mount.timeoutMs !== void 0) options.timeout = mount.timeoutMs;
 		const request = requestFn(target)(options);
 		upstream = request;
@@ -414,6 +489,31 @@ function refuseUpgrade(socket, status, reason, headers) {
 	}
 	socket.end(`HTTP/1.1 ${status} ${reason}\r\n${extra}Connection: close\r\nContent-Length: 0\r\n\r\n`);
 }
+/** En-têtes du refus d'une version WebSocket inconnue — figés, partagés. */
+const WS_VERSION_REFUSAL_HEADERS = Object.freeze({
+	Upgrade: "websocket",
+	"Sec-WebSocket-Version": "13"
+});
+/**
+* Refuse un handshake WebSocket non conforme — la réponse qui convient à la
+* raison rendue par `websocketHandshakeProblem`, seule implémentation pour le
+* serveur WebSocket ET le proxy inverse.
+*
+* Une version inconnue reçoit `426` avec `Sec-WebSocket-Version: 13` : le
+* client apprend vers quelle version se rabattre (RFC 6455 §4.2.2 point 6,
+* §4.4), et le 426 porte l'`Upgrade` qu'exige RFC 9110 §15.5.22. Tout autre
+* défaut de forme reçoit `400`.
+*
+* @param socket - socket du client, encore en attente de sa réponse
+* @param problem - la raison rendue par `websocketHandshakeProblem`
+*/
+function refuseMalformedHandshake(socket, problem) {
+	if (problem === "Sec-WebSocket-Version ≠ 13") {
+		refuseUpgrade(socket, 426, "Upgrade Required", WS_VERSION_REFUSAL_HEADERS);
+		return;
+	}
+	refuseUpgrade(socket, 400, "Bad Request");
+}
 /** En-têtes d'une réponse d'amont REFUSANT l'upgrade, à ne pas recopier tels quels. */
 const REFUSAL_SKIP = /* @__PURE__ */ new Set([
 	"transfer-encoding",
@@ -497,4 +597,4 @@ function forwardUpgrade(req, socket, head, mount, target, from, relay) {
 	});
 	upstream.end();
 }
-export { MAX_VIA_HOPS, bodyFramingOf, forwardRequest, forwardUpgrade, rawHead, refuseUpgrade, requestHeadersFor, responseHeadersFor, rewriteLocation, upstreamPath, viaLoops };
+export { MAX_VIA_HOPS, bodyFramingOf, forwardRequest, forwardUpgrade, rawHead, receivedMaxForwards, refuseMalformedHandshake, refuseUpgrade, requestHeadersFor, responseHeadersFor, rewriteLocation, upstreamPath, viaLoops };

package/dist/nodefony/src/proxy/generateProxyConfig.js

@@ -152,6 +152,12 @@ defaults
   # \`timeout server\` ne s'applique plus au tunnel. Sans cette ligne, la valeur
   # implicite coupe des sockets que le heartbeat gardait pourtant vivantes.
   timeout tunnel  ${idleSeconds}s
+  # Forwarded (RFC 7239) posé par haproxy lui-même (>= 2.8) : il met entre
+  # guillemets ce qui n'est pas un jeton — une IPv6 (\`for="[2001:db8::1]"\`),
+  # un \`host\` qui porte un port. Un \`set-header\` écrit à la main laissait
+  # \`for=2001:db8::1\`, valeur invalide (§6). \`proto\` suit \`ssl_fc\` : le
+  # scheme vu par le CLIENT. Vaut pour tous les backends.
+  option forwarded proto host for
 
 frontend fe_nodefony
   bind *:${intro.listen}
@@ -173,8 +179,6 @@ frontend fe_nodefony
   http-request set-header X-Forwarded-Proto http  unless { ssl_fc }
   http-request set-header X-Forwarded-Host  %[req.hdr(host)]
   http-request set-header X-Real-IP         %[src]
-  http-request set-header Forwarded "for=%[src];proto=https;host=%[req.hdr(host)]" if { ssl_fc }
-  http-request set-header Forwarded "for=%[src];proto=http;host=%[req.hdr(host)]" unless { ssl_fc }
 
 ${h2cPort === null ? "  default_backend be_nodefony\n" : "  # h2c (servers.h2c) : HTTP/2 en clair vers le backend, plusieurs flux par\n  # connexion. WebSocket reste en HTTP/1.1 sur le port HTTP : le port h2c\n  # n'annonce pas le CONNECT étendu (RFC 8441).\n  use_backend be_nodefony if { hdr(upgrade) -i websocket }\n  default_backend be_nodefony_h2c\n"}
 backend be_nodefony