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

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";
+import crypto from "node:crypto";
 // 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,8 +41,9 @@ 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) {
+					if (cookie === "") continue;
 					co = new Cookie(cookie, obj[cookie]);
 					context.addRequestCookie(co);
 				}
@@ -36,8 +53,9 @@ 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) {
+					if (name === "") continue;
 					co = new Cookie(name, parsed[name]);
 					context.addRequestCookie(co);
 				}
@@ -165,14 +183,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 +294,4 @@ var Cookie = class Cookie {
 		return obj;
 	}
 };
-export { cookiesParser, Cookie as default, parser };
+export { cookiesParser, Cookie as default };

package/dist/nodefony/src/errors/httpError.js

@@ -1,41 +1,51 @@
 import { clc, nodefonyError } from "nodefony";
 // nodefony/src/errors/httpError.ts
-const exclude = {
-	context: true,
-	resolver: true,
-	container: true,
-	secure: true,
-	request: true,
-	response: true
-};
+/** Références vivantes (circulaires) jamais sérialisées, quel que soit l'environnement. */
+const EXCLUDED_KEYS = /* @__PURE__ */ new Set([
+	"context",
+	"resolver",
+	"container",
+	"secure",
+	"request",
+	"response"
+]);
+/**
+* Sérialise les propriétés propres d'une erreur HTTP, sans jamais LIRE celles
+* qu'on écarte.
+*
+* Ne pas lire compte : `stack` est un accesseur paresseux de V8, et sa première
+* lecture FORMATE la pile (`prepareStackTrace`, plusieurs µs). Lire puis
+* supprimer, c'est payer ce formatage pour le jeter — ce que faisait le rendu
+* d'erreur en production, sur chaque 404.
+*
+* @param error - l'erreur à sérialiser (en pratique un `HttpError`).
+* @param omit - clés à écarter EN PLUS des références vivantes, ou `null`.
+* @returns un objet plat, prêt pour `JSON.stringify`.
+*/
+function serializeHttpError(error, omit = null) {
+	const alt = {};
+	for (const key of Object.getOwnPropertyNames(error)) {
+		if (EXCLUDED_KEYS.has(key) || omit?.has(key)) continue;
+		alt[key] = Reflect.get(error, key);
+	}
+	return alt;
+}
 const jsonHttpError = {
 	configurable: true,
 	writable: true,
 	value() {
-		const alt = {};
-		const storeKey = function(key) {
-			if (key in exclude) return;
-			alt[key] = this[key];
-		};
-		Object.getOwnPropertyNames(this).forEach(storeKey, this);
-		return alt;
+		return serializeHttpError(this);
 	}
 };
-var HttpError = class extends nodefonyError {
-	context;
-	response;
-	request;
+var HttpError = class HttpError extends nodefonyError {
 	url;
 	controller;
 	action;
 	jsonResponse;
 	constructor(message, code, context) {
 		super(message, code);
-		this.context = context;
 		const res = context?.response;
-		this.response = res ?? void 0;
-		this.request = context?.request ?? void 0;
-		this.url = this.context?.url;
+		this.url = context?.url;
 		if (res && code) res.statusCode = code;
 		if (!this.message && res) this.message = res.body?.toString() || res.statusMessage || res.getStatusMessage();
 		const resolver = context?.resolver;
@@ -43,8 +53,31 @@ var HttpError = class extends nodefonyError {
 		this.action = resolver?.actionName ?? void 0;
 		if (res) this.jsonResponse = `${res.statusCode} ${res.statusMessage}`.trim();
 	}
+	/**
+	* Construit un VERDICT de protocole (404, 405, 426…) sans capturer de pile.
+	*
+	* La pile d'un verdict pointe toujours au même endroit du noyau ou du routeur
+	* et ne dit rien de la requête ; la capturer coûte ~3,6 µs à profondeur
+	* réelle (`micro-error-path.mjs`), payés par chaque requête d'un scanner.
+	* Réservé à ce que le framework DÉCIDE — une panne garde sa pile. `stack` ne
+	* porte que l'en-tête (`HttpError: Not Found`).
+	*
+	* @param message - message du verdict.
+	* @param code - statut HTTP (ou code de fermeture WebSocket).
+	* @param context - contexte de la requête, comme pour le constructeur.
+	* @returns l'erreur, sans pile.
+	*/
+	static withoutStack(message, code, context) {
+		const limit = Error.stackTraceLimit;
+		Error.stackTraceLimit = 0;
+		try {
+			return new HttpError(message, code, context);
+		} finally {
+			Error.stackTraceLimit = limit;
+		}
+	}
 	toString() {
-		if (this.context) return `${clc.red(this.message)}
+		if (this.url !== void 0) return `${clc.red(this.message)}
     ${clc.blue("Name :")} ${this.name}
     ${clc.blue("Type :")} ${this.errorType}
     ${clc.green("Controller :")} ${this.controller}
@@ -65,4 +98,4 @@ var HttpError = class extends nodefonyError {
 	}
 };
 Object.defineProperty(HttpError.prototype, "toJSON", jsonHttpError);
-export { HttpError as default };
+export { HttpError as default, serializeHttpError };

package/dist/nodefony/src/grpc/cors.js

@@ -0,0 +1,59 @@
+import { hasGrpcRoutes } from "./refusal.js";
+// nodefony/src/grpc/cors.ts
+/**
+* Les listes de Connect (`cors` de `@connectrpc/connect`, `connect-cors.md`),
+* recopiées : `@nodefony/http` principal ne charge jamais Connect, pair
+* facultatif (ADR-0026 D12). La copie est COMPARÉE à l'original par un test
+* (`grpcCors.test.ts`) : une version de Connect qui change ses listes le fait
+* tomber.
+*/
+const GRPC_CORS = Object.freeze({
+	allowedMethods: Object.freeze(["POST", "GET"]),
+	allowedHeaders: Object.freeze([
+		"Content-Type",
+		"Connect-Protocol-Version",
+		"Connect-Timeout-Ms",
+		"Connect-Content-Encoding",
+		"Connect-Accept-Encoding",
+		"Content-Encoding",
+		"Accept-Encoding",
+		"Grpc-Message-Type",
+		"X-Grpc-Web",
+		"X-User-Agent",
+		"Grpc-Timeout"
+	]),
+	exposedHeaders: Object.freeze([
+		"Grpc-Status",
+		"Grpc-Message",
+		"Grpc-Status-Details-Bin",
+		"Content-Encoding",
+		"Connect-Content-Encoding"
+	])
+});
+/**
+* `Access-Control-Expose-Headers` d'une réponse RPC, composé une fois au
+* chargement.
+*/
+const RPC_EXPOSED_HEADERS = GRPC_CORS.exposedHeaders.join(", ");
+/**
+* Les listes CORS que demandent les protocoles RPC — dès qu'un service gRPC
+* est déclaré dans le processus, `null` sinon. Le pare-feu les ajoute à la
+* politique de l'application au démarrage (`onReady`) : le préflight ne
+* connaît pas la route, l'union est la seule voie (ADR-0026 D9 point 2).
+*
+* @returns les listes, ou `null` sans service gRPC déclaré.
+* @experimental Surface gRPC, ADR-0026 D11.
+*/
+function rpcCorsLists() {
+	return hasGrpcRoutes() ? GRPC_CORS : null;
+}
+/**
+* Les listes de Connect telles que recopiées, sans condition — réservé au test
+* qui les compare à l'original.
+*
+* @internal
+*/
+function grpcCorsCopy() {
+	return GRPC_CORS;
+}
+export { RPC_EXPOSED_HEADERS, grpcCorsCopy, rpcCorsLists };

package/dist/nodefony/src/grpc/limits.js

@@ -0,0 +1,16 @@
+// nodefony/src/grpc/limits.ts
+/**
+* Borne par défaut d'un message gRPC, reçu ou émis : 4 Mio (ADR-0026 D4,
+* points 1 et 2). C'est la borne de réception des implémentations de
+* référence (`grpc-js`, `grpc-go`) ; l'adaptateur Connect, lui, n'en pose
+* aucune (`limit-io.js` : `0xffffffff`). Seule source de cette valeur : le
+* schéma de la section `grpc` et le point d'entrée gRPC la lisent ici.
+*/
+const GRPC_DEFAULT_MAX_MESSAGE_BYTES = 4194304;
+/**
+* Plus grande borne qu'accepte l'adaptateur Connect pour `readMaxBytes` et
+* `writeMaxBytes` (`limit-io.js#validateReadWriteMaxBytes`) : la longueur
+* d'une enveloppe tient sur 32 bits.
+*/
+const GRPC_MAX_MESSAGE_BYTES = 4294967295;
+export { GRPC_DEFAULT_MAX_MESSAGE_BYTES, GRPC_MAX_MESSAGE_BYTES };