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

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

@@ -31,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.
@@ -151,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/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

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

@@ -1,5 +1,7 @@
-import { isLoopbackHostname } from "nodefony";
+import { isLoopbackHostname, parseBareOrigin } from "nodefony";
 // nodefony/src/proxy/rules.ts
+/** Schémas d’amont d’un relais : un proxy inverse ne parle que HTTP. */
+const PROXY_ORIGIN_PROTOCOLS = ["http:", "https:"];
 /**
 * Règles d'un montage du proxy inverse — UNIQUE source, lue par le schéma de
 * configuration (`proxy.mounts`) ET par `ReverseProxy.mount()` : un montage
@@ -49,17 +51,7 @@ function normalizePrefix(prefix) {
 * @returns l'URL analysée, ou `null` si ce n'est pas une origine http(s) nue
 */
 function parseProxyOrigin(origin) {
-	let url;
-	try {
-		url = new URL(origin);
-	} catch {
-		return null;
-	}
-	if (url.protocol !== "http:" && url.protocol !== "https:") return null;
-	if (!/^https?:\/\/[^/?#]+\/?$/i.test(origin.trim())) return null;
-	if (url.search !== "" || url.hash !== "") return null;
-	if (url.username !== "" || url.password !== "") return null;
-	return url;
+	return parseBareOrigin(origin, PROXY_ORIGIN_PROTOCOLS);
 }
 /**
 * Examine un montage. Rend TOUS les refus, pas le premier : une configuration
@@ -163,6 +155,29 @@ const UPGRADE_WEBSOCKET = /^\s*websocket\s*$/i;
 /** Le jeton `upgrade` dans une liste `Connection` (RFC 9110 §7.6.1). */
 const CONNECTION_UPGRADE = /(?:^|,)\s*upgrade\s*(?:,|$)/i;
 /**
+* Le corps reçu porte-t-il un codage de transfert que le serveur ne sait pas
+* défaire ? Seul `chunked` est compris : Node le retire, mais laisse en place
+* tout codage qui le précède (`gzip, chunked`) — le corps livré serait encore
+* compressé. RFC 9112 §6.1 : un tel message reçoit 501. Un `chunked` qui n'est
+* pas le DERNIER codage est déjà refusé par Node en 400 (§6.3).
+*
+* Seule règle, pour le serveur d'origine et pour le proxy inverse. Chemin de
+* chaque requête : une lecture d'en-tête, rien d'autre sans `Transfer-Encoding`.
+*
+* @param coding - valeur de l'en-tête `Transfer-Encoding`, absente le plus souvent
+* @returns `true` quand le corps ne peut pas être lu tel qu'annoncé
+*/
+function isUnsupportedTransferCoding(coding) {
+	if (coding === void 0 || coding === "chunked") return false;
+	return coding.trim().toLowerCase() !== "chunked";
+}
+/**
+* Raison rendue par {@link websocketHandshakeProblem} quand le client parle une
+* autre version du protocole : la seule qui appelle une réponse distincte —
+* le client doit apprendre vers quelle version se rabattre (RFC 6455 §4.4).
+*/
+const WS_UNSUPPORTED_VERSION = "Sec-WebSocket-Version ≠ 13";
+/**
 * Un upgrade est-il un handshake WebSocket conforme (RFC 6455 §4.2.1) ? Seul
 * un tel handshake est relayé : un `Upgrade` quelconque (`h2c`…) raccordé
 * octet pour octet ouvrirait un tunnel que rien n'inspecte.
@@ -180,9 +195,9 @@ function websocketHandshakeProblem(method, headers) {
 	if (typeof upgrade !== "string" || !UPGRADE_WEBSOCKET.test(upgrade)) return "Upgrade autre que websocket";
 	const connection = headers.connection;
 	if (!(typeof connection === "string" ? CONNECTION_UPGRADE.test(connection) : Array.isArray(connection) && connection.some((token) => CONNECTION_UPGRADE.test(token)))) return "Connection sans upgrade";
-	if (headers["sec-websocket-version"] !== "13") return "Sec-WebSocket-Version ≠ 13";
+	if (headers["sec-websocket-version"] !== "13") return WS_UNSUPPORTED_VERSION;
 	const key = headers["sec-websocket-key"];
 	if (typeof key !== "string" || !WS_KEY.test(key)) return "Sec-WebSocket-Key invalide";
 	return null;
 }
-export { MODULE_PROXY_PREFIXES, RESERVED_PROXY_PREFIXES, isAmbiguousPath, normalizePrefix, parseProxyOrigin, proxyMountProblems, websocketHandshakeProblem };
+export { MODULE_PROXY_PREFIXES, RESERVED_PROXY_PREFIXES, WS_UNSUPPORTED_VERSION, isAmbiguousPath, isUnsupportedTransferCoding, normalizePrefix, parseProxyOrigin, proxyMountProblems, websocketHandshakeProblem };

package/dist/nodefony/src/servers/upgradeDispatch.js

@@ -1,7 +1,60 @@
+import { refuseMalformedHandshake, refuseUpgrade } from "../proxy/forward.js";
 import { websocketHandshakeProblem } from "../proxy/rules.js";
-import { refuseUpgrade } from "../proxy/forward.js";
 import { STATUS_CODES } from "node:http";
+import { WebSocketServer } from "ws";
 // nodefony/src/servers/upgradeDispatch.ts
+/**
+* Sous-protocole choisi par handshake, entre {@link IUpgradeAdmission.selectSubprotocol}
+* et le rappel `handleProtocols` de `ws` — qui ne reçoit que la requête. Une
+* table faible plutôt qu'une variable « en cours » : un `verifyClient`
+* asynchrone sépare les deux instants, et deux handshakes s'y croiseraient.
+* Une entrée n'existe que pour un handshake qui a choisi.
+*/
+const chosenSubprotocols = /* @__PURE__ */ new WeakMap();
+/**
+* Fabrique l'option `handleProtocols` du serveur `ws` de Nodefony : le choix
+* retenu par l'admission ({@link IUpgradeAdmission.selectSubprotocol}) s'il y
+* en a un, sinon `fallback` (celle de la configuration), sinon le premier
+* offert — le défaut de `ws` 8, conservé pour tout contrôleur qui ne choisit
+* pas.
+*
+* @param fallback - l'option `handleProtocols` de la configuration, s'il y en a une
+* @returns le rappel à passer à `new WebSocketServer({ handleProtocols })`
+*/
+function createSubprotocolHandler(fallback) {
+	return (protocols, request) => {
+		const chosen = chosenSubprotocols.get(request);
+		if (chosen !== void 0) {
+			chosenSubprotocols.delete(request);
+			return chosen !== false && protocols.has(chosen) ? chosen : false;
+		}
+		if (fallback !== void 0) return fallback(protocols, request);
+		const first = protocols.values().next();
+		return first.done === true ? false : first.value;
+	};
+}
+/**
+* Construit le serveur `ws` de Nodefony à partir des options de la
+* configuration, en forçant ce que Nodefony gère — seul endroit où ces
+* options sont posées, pour le serveur clair comme pour le sécurisé :
+*
+* - `noServer` : l'upgrade passe d'abord par le proxy inverse, puis par
+*   {@link attachUpgradeDispatch} ;
+* - `clientTracking` : requis par `broadcast()` et le heartbeat ;
+* - `handleProtocols` : le sous-protocole CHOISI par le contrôleur
+*   ({@link createSubprotocolHandler}), celui de la configuration à défaut.
+*
+* @param options - options `ws` issues de la configuration du serveur WebSocket
+* @returns le serveur, sans écoute propre
+*/
+function createNodefonyWebSocketServer(options) {
+	return new WebSocketServer({
+		...options,
+		noServer: true,
+		clientTracking: true,
+		handleProtocols: createSubprotocolHandler(options.handleProtocols)
+	});
+}
 /** Défaut sans noyau : tout upgrade conforme est accepté puis émis en `connection`. */
 function acceptAll(wss) {
 	return (req, admission) => {
@@ -38,6 +91,9 @@ var UpgradeAdmission = class {
 		this.#onPendingError = () => socket.destroy();
 		socket.on("error", this.#onPendingError);
 	}
+	selectSubprotocol(protocol) {
+		if (!this.#settled) chosenSubprotocols.set(this.req, protocol);
+	}
 	#settle() {
 		if (this.#settled) return false;
 		this.#settled = true;
@@ -71,6 +127,7 @@ var UpgradeAdmission = class {
 	}
 	refuse(status, headers) {
 		if (!this.#settle()) return;
+		chosenSubprotocols.delete(this.req);
 		refuseUpgrade(this.socket, status, STATUS_CODES[status] ?? "Refused", headers);
 	}
 };
@@ -114,8 +171,9 @@ function attachUpgradeDispatch(server, wss, relay, refusal, admit = acceptAll(ws
 			refuseUpgrade(socket, status, STATUS_CODES[status] ?? "Refused");
 			return;
 		}
-		if (websocketHandshakeProblem(req.method, req.headers) !== null) {
-			refuseUpgrade(socket, 400, STATUS_CODES[400] ?? "Bad Request");
+		const problem = websocketHandshakeProblem(req.method, req.headers);
+		if (problem !== null) {
+			refuseMalformedHandshake(socket, problem);
 			return;
 		}
 		admit(req, new UpgradeAdmission(wss, req, socket, head));
@@ -125,4 +183,4 @@ function attachUpgradeDispatch(server, wss, relay, refusal, admit = acceptAll(ws
 		server.removeListener("upgrade", onUpgrade);
 	};
 }
-export { attachUpgradeDispatch };
+export { attachUpgradeDispatch, createNodefonyWebSocketServer, createSubprotocolHandler };

package/dist/types/index.d.ts

@@ -68,9 +68,13 @@ declare class Http extends Module<IHttpConfig> {
 }
 export default Http;
 export { defineHttpConfig, httpConfigJsonSchema, } from "./nodefony/config/defineModuleConfig.js";
+export { parseRequestTarget } from "./nodefony/src/context/http/urlFastPath.js";
+export { isContentlessStatus } from "./nodefony/src/context/http/Response.js";
+export type { ISplitTarget } from "./nodefony/src/context/http/urlFastPath.js";
 export { httpConfigSchema } from "./nodefony/config/config.js";
 export type { IHttpConfig, IHttpConfigInput, } from "./nodefony/interfaces/IHttpConfig.js";
 export { decideSend, readBackpressureOptions, type WsBackpressurePolicy, type WsSendDecision, type IWsBackpressureOptions, type IBackpressureSocket, type IBackpressureTarget, } from "./nodefony/src/context/websocket/wsBackpressure.js";
+export { admitFrame, frameRateRejectedTotal, readFrameRateBound, readFrameRateCloseAfter, FRAME_RATE_WINDOW_MS, type IFrameRateWindow, type IWsFrameRateOptions, } from "./nodefony/src/context/websocket/wsFrameRate.js";
 export { isWebsocketContext } from "./nodefony/src/context/websocket/isWebsocketContext.js";
 export { REQUEST_TRACE_CHANNEL } from "./nodefony/src/context/requestTrace.js";
 export type { IRequestTrace, RequestTraceProtocol, } from "./nodefony/interfaces/IRequestTrace.js";
@@ -81,6 +85,8 @@ export type { IRateLimitStore, IRateLimitOptions, RateLimitVerdict, } from "./no
 export { Context, Session, SessionsService, HttpError, HttpKernel, Response, Http2Response, Response as HttpResponse, wsResponse, wsResponse as WebsocketResponse, Cookie, HttpContext, WebsocketContext, HttpRequest, Http2Request, DefaultErrorRenderer, DefaultRequestLogger, JsonAuditLogger, PrettyRequestLogger, Profiler, };
 export { SseStream, openSseStream, acceptsEventStream, SSE_HEARTBEAT_MS, } from "./nodefony/src/context/http/SseStream.js";
 export type { ISseStreamOptions, ISseSendOptions, } from "./nodefony/src/context/http/SseStream.js";
+export { openByteStream } from "./nodefony/src/context/http/ByteStream.js";
+export type { ByteStreamEndReason, ByteStreamSource, IByteStreamOptions, IByteStreamResult, } from "./nodefony/src/context/http/ByteStream.js";
 export { schemaMismatchOf, type SchemaMismatchConfidence, } from "./nodefony/service/error-renderer.js";
 export { toValidationFields, type IValidationField, } from "./nodefony/service/error-renderer.js";
 export type { ProfileEntry, ProfileSummary, ProfilePhase, ProfileQuery, ProfileSecurity, IProfileBatch, IProfilerReader, } from "./nodefony/src/profiler/Profiler.js";

package/dist/types/nodefony/config/config.d.ts

@@ -115,6 +115,8 @@ export declare const httpConfigSchema: z.ZodObject<{
             close: "close";
             drop: "drop";
         }>>;
+        maxFramesPerSecond: z.ZodDefault<z.ZodNumber>;
+        frameRateCloseAfterRejects: z.ZodDefault<z.ZodNumber>;
     }, z.core.$loose>>;
     websocketSecure: z.ZodDefault<z.ZodObject<{
         keepaliveInterval: z.ZodDefault<z.ZodNumber>;
@@ -139,6 +141,8 @@ export declare const httpConfigSchema: z.ZodObject<{
             close: "close";
             drop: "drop";
         }>>;
+        maxFramesPerSecond: z.ZodDefault<z.ZodNumber>;
+        frameRateCloseAfterRejects: z.ZodDefault<z.ZodNumber>;
     }, z.core.$loose>>;
     statics: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/types/nodefony/interfaces/ISecurity.d.ts

@@ -40,12 +40,37 @@ export interface IFirewallGate {
     enforceCsrf(context: ContextType): void;
     /** Répond au preflight CORS ; `204` quand la réponse est déjà envoyée. */
     handleCors(context: ContextType): number | undefined;
-    /** Pose les en-têtes de sécurité (CSP, HSTS…) de la réponse. */
-    applySecurityHeaders(context: ContextType): void;
+    /**
+     * Pose les en-têtes de sécurité applicatifs (CSP, Permissions-Policy…) de la
+     * réponse, appelé par la réponse juste avant son `writeHead`.
+     *
+     * @param contentType - `Content-Type` de la réponse, qui choisit la politique ;
+     *   `null` = réponse sans contenu ; omis = type inconnu (politique complète).
+     * @param servedAsFile - corps servi tel quel (fichier statique, relais) : aucun
+     *   gabarit ne l'a écrit, il ne peut pas porter de nonce.
+     */
+    applySecurityHeaders(context: ContextType, contentType?: string | null, servedAsFile?: boolean): void;
     /**
      * Le revalidateur de l'identité authentifiée de la requête courante, pour une
      * connexion longue qui la gardera (flux SSE) : la même règle que les sockets
      * WebSocket. `null` pour un anonyme — rien à révoquer.
      */
     currentRevalidator?(): ((nowMs?: number) => Promise<boolean>) | null;
+    /**
+     * Prévenu quand le noyau HTTP a recalculé ses en-têtes de transport (édition à
+     * chaud de `securityHeaders`) : la politique de contenu suit `frameOptions`,
+     * qui pilote aussi `frame-ancestors`.
+     */
+    onTransportHeadersChanged?(): void;
+    /**
+     * Déclare les sources qu'un module ajoute à la politique de contenu
+     * (`{ "connect-src": ["wss://rt.example.com"] }`). Un second appel du même
+     * module REMPLACE sa contribution. Absent quand aucun pare-feu ne pose de CSP.
+     *
+     * @param moduleName - module qui contribue, clé de sa contribution
+     * @param fragment - sources par directive, origines exactes (sans joker)
+     */
+    registerCspOrigins?(moduleName: string, fragment: Readonly<Record<string, readonly string[]>>): void;
+    /** Retire la contribution CSP de `moduleName`. */
+    unregisterCspOrigins?(moduleName: string): void;
 }

package/dist/types/nodefony/service/ProfilerAdminApi.d.ts

@@ -13,7 +13,8 @@ import type { Profiler } from "../src/profiler/Profiler.js";
  *    `?connection=<requestId>` : les seules frames de cette socket WebSocket
  *  - `GET /nodefony/profiler/api/summary` → les profils de l'anneau agrégés par
  *    route (percentiles, phases, formes SQL, N+1, erreurs — `aggregateProfiles`)
- *  - `GET /nodefony/profiler/api/{id}`    → profil complet (phases) d'un requestId
+ *  - `GET /nodefony/profiler/api/{id}`    → profil complet (phases) d'un requestId ;
+ *    absent → 404 `{ startedAt, clearedAt }` : depuis quand l'anneau sait quelque chose
  *  - `DELETE /nodefony/profiler/api/recent` → vide le ring buffer
  *
  * La debug bar (toute page, dev) lit `X-Request-Id` de SON appel AJAX puis

package/dist/types/nodefony/service/error-renderer.d.ts

@@ -34,10 +34,11 @@ export declare function toValidationFields(error: Error): IValidationField[] | n
 /**
  * Reconnaît un identifiant MAL FORMÉ refusé par la base, et rend la valeur fautive.
  *
- * Deux moteurs le disent : MongoDB par une `CastError` de Mongoose (la clé est
- * un ObjectId), PostgreSQL par `22P02` (la clé est un `uuid` ou un entier).
- * SQLite et MySQL rangent la clé en texte : ils ne lèvent rien, la lecture rend
- * simplement « rien », d'où leur 404 — c'est la cohérence avec eux qui est visée.
+ * Trois sources le disent : MongoDB par une `CastError` de Mongoose (la clé est
+ * un ObjectId), PostgreSQL par `22P02` (la clé est un `uuid` ou un entier), et
+ * le kit de colonnes portable par une `ColumnValueError` de genre `uuid` ou
+ * `integer` — il refuse sur les trois moteurs la clé que PostgreSQL refuserait. Une clé rangée en
+ * texte NATIF ne lève rien, la lecture rend « rien » : le même 404.
  *
  * Même descente dans `cause` que {@link isUniqueViolation} (Drizzle enveloppe).
  *

package/dist/types/nodefony/service/http-kernel.d.ts

@@ -147,11 +147,20 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
      * dans `onHttpRequest` (0 alloc/concat par requête).
      */
     private computeSecurityHeaderCaches;
+    /**
+     * En-têtes du transport d'une réponse, figés au démarrage — ce que
+     * `HttpResponse` place en tête de sa réserve.
+     *
+     * @param type - famille du serveur qui a reçu la requête.
+     * @returns la liste plate `[nom, valeur, …]`, noms en minuscules.
+     */
+    transportHeaders(type: ServerType): readonly string[];
     /**
      * Ce que ce kernel ÉMET réellement comme en-têtes de sécurité transport.
      *
      * Ces trois en-têtes (HSTS, X-Frame-Options, X-Content-Type-Options) sont posés
-     * ici, à l'entrée brute, pour couvrir aussi les statiques et les pages d'erreur
+     * par `@nodefony/http` sur TOUTE réponse (en tête de la réserve de `HttpResponse`),
+     * statiques et pages d'erreur comprises
      * — pas par `@nodefony/security`, dont les clés homonymes sont inertes. Toute
      * console d'administration doit donc lire CE point, sinon elle affiche une
      * intention de configuration au lieu de l'état appliqué.
@@ -522,6 +531,10 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
     /**
      * Chemin d'erreur de {@link handleHttp} : libère le scope d'un contexte qui
      * n'a pas pu se construire, puis rend l'erreur au client (`onError`).
+     *
+     * Sans contexte, `onError` n'a rien sur quoi écrire : la réponse BRUTE
+     * reçoit alors un 500 nu. Sinon HTTP/1.1 coupait la connexion sans un octet
+     * et HTTP/2 laissait le flux pendu.
      */
     private failHttp;
     /**
@@ -715,7 +728,7 @@ declare class HttpKernel extends Service implements IHttpKernelInterface {
         once(event: "close", listener: () => void): unknown;
     }): boolean;
     /**
-     * Re-valide tous les flux SSE et ferme ceux dont l'identité est morte.
+     * Re-valide tous les flux en cours et ferme ceux dont l'identité est morte.
      * Publique pour qu'un banc la déclenche sans attendre le tick.
      */
     revalidateStreams(): Promise<void>;