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

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

@@ -0,0 +1,442 @@
+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.
+*
+* Une seule implémentation pour tout ce qui résume le profileur : l'outil MCP
+* qui observe l'application (`nodefony_observe`), celui qui tire lui-même des
+* requêtes sur une route, et demain la console d'administration. Elle est
+* bornée par construction : un échantillon de durées par route, un nombre
+* maximal de formes SQL retenues, quelques exemples d'erreurs — observer une
+* application chargée ne fait jamais grossir la mémoire avec la fenêtre.
+*/
+/**
+* Répétitions d'une même forme SQL, dans UNE requête, à partir desquelles on
+* signale un N+1. En dessous, ce sont des boucles courtes légitimes (quelques
+* lectures de configuration, une pagination) qu'on signalerait à tort.
+*/
+const N_PLUS_ONE_MIN_REPEATS = 5;
+/** Durées retenues par route pour les percentiles (échantillonnage au-delà). */
+const ROUTE_SAMPLE_CAP = 256;
+/** Formes SQL distinctes retenues ; les suivantes ne sont plus que comptées. */
+const SQL_SHAPE_CAP = 200;
+/** Exemples d'erreurs retenus (statut ≥ 500 ou exception). */
+const ERROR_SAMPLE_CAP = 10;
+/**
+* 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. 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);
+	for (const prefix of MODULE_PROXY_PREFIXES) if (path.startsWith(prefix)) return "asset";
+	return isConsolePath(path) ? "tooling" : "app";
+}
+/**
+* Le profil vient-il de l'outillage (routes `/nodefony/…` ou assets relayés)
+* plutôt que de l'application.
+*
+* @param url - URL du profil, absolue ou chemin.
+*/
+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. */
+const ACTION_SELF_PHASE = "action.self";
+/** Longueur maximale d'un message d'erreur rapporté. */
+const ERROR_MESSAGE_MAX = 200;
+/**
+* Réduit une requête SQL (ou le descripteur d'une commande NoSQL) à sa FORME :
+* valeurs remplacées par `?`, listes de valeurs repliées, blancs compactés.
+*
+* Deux requêtes qui ne diffèrent que par leurs valeurs ont la même forme — c'est
+* ce qui permet de reconnaître un N+1. Et aucune valeur ne survit : la forme
+* peut sortir dans un rapport sans emporter une donnée personnelle.
+*
+* @param sql - le texte tel que l'adaptateur l'a poussé au profileur.
+* @returns la forme normalisée.
+*/
+function sqlShape(sql) {
+	return sql.replace(/:\s*"(?:[^"\\]|\\.)*"/g, ":?").replace(/:\s*(?:-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null)\b/g, ":?").replace(/\[[^[\]{}]+\]/g, "[?…]").replace(/'(?:[^']|'')*'/g, "?").replace(/\$\d+/g, "?").replace(/(?<![\w$])\d+(?:\.\d+)?/g, "?").replace(/\bin\s*\(\s*\?(?:\s*,\s*\?)*\s*\)/gi, "in (?…)").replace(/\bvalues\s*\([^()]*\)(?:\s*,\s*\([^()]*\))*/gi, "values (…)").replace(/\s+/g, " ").trim();
+}
+/** Phase `action` terminée : sa durée est connue. */
+function isFinishedAction(p) {
+	return p.name === "action" && p.durationMs !== null;
+}
+/**
+* Temps de l'action hors phases imbriquées et hors SQL : le code de l'action
+* elle-même et des services qu'elle appelle.
+*
+* Les phases imbriquées (`initialize`, `render`, `send`…) ne sont pas
+* nommées ici : est imbriquée toute phase terminée qui tient dans l'intervalle
+* de l'action. Les intervalles (phases et SQL) sont fusionnés avant d'être
+* retranchés — une requête SQL lancée pendant le rendu n'est pas comptée deux
+* fois.
+*
+* @returns la durée propre en ms, ou `null` sans phase `action` terminée.
+*/
+function actionSelfMs(entry) {
+	const action = entry.phases.find(isFinishedAction);
+	if (action === void 0) return null;
+	const start = action.startMs;
+	const end = start + action.durationMs;
+	const inner = [];
+	for (const p of entry.phases) {
+		if (p === action || p.durationMs === null) continue;
+		const pEnd = p.startMs + p.durationMs;
+		if (p.startMs >= start && pEnd <= end) inner.push([p.startMs, pEnd]);
+	}
+	for (const q of entry.queries ?? []) {
+		if (q.startMs === void 0) continue;
+		const qStart = Math.max(q.startMs, start);
+		const qEnd = Math.min(q.startMs + q.durationMs, end);
+		if (qEnd > qStart) inner.push([qStart, qEnd]);
+	}
+	inner.sort((a, b) => a[0] - b[0]);
+	let covered = 0;
+	let curStart = -Infinity;
+	let curEnd = -Infinity;
+	for (const [s, e] of inner) if (s > curEnd) {
+		if (curEnd > curStart) covered += curEnd - curStart;
+		curStart = s;
+		curEnd = e;
+	} else if (e > curEnd) curEnd = e;
+	if (curEnd > curStart) covered += curEnd - curStart;
+	return Math.max(0, action.durationMs - covered);
+}
+/**
+* Une requête en ERREUR du serveur : statut ≥ 500, ou exception levée sans
+* verdict client. Règle unique — le rapport, ses exemples et la lecture de leurs
+* journaux en dépendent.
+*
+* Un statut 4xx n'en est JAMAIS une, même porteur d'une exception : un refus
+* 401/403 (l'authentification lève une `AuthenticationError`) ou une ressource
+* absente est le verdict rendu au client, compté à part — le lister parmi les
+* erreurs ferait chercher une panne là où il manque une identité.
+*
+* @param entry - le profil (seuls statut et erreur sont lus).
+*/
+function isFailedProfile(entry) {
+	if (entry.status === null) return entry.error !== null;
+	if (entry.status >= 500) return true;
+	return entry.status < 400 && entry.error !== null;
+}
+/**
+* Le chemin d'une URL de profil. Le profileur enregistre l'URL ABSOLUE
+* (`http://hôte:port/chemin`) : un filtre écrit sur le chemin ne mordrait
+* jamais dessus. Sans `URL` à construire — appelée sur chaque profil lu.
+*/
+function urlPath(url) {
+	if (url.startsWith("/")) return url;
+	const scheme = url.indexOf("://");
+	if (scheme === -1) return url;
+	const slash = url.indexOf("/", scheme + 3);
+	return slash === -1 ? "/" : url.slice(slash);
+}
+/** Percentile au rang le plus proche, sur un tableau TRIÉ non vide. */
+function percentile(sorted, p) {
+	if (sorted.length === 0) return null;
+	const rank = Math.ceil(p / 100 * sorted.length) - 1;
+	return sorted[Math.min(Math.max(rank, 0), sorted.length - 1)] ?? null;
+}
+/** Arrondi au centième de milliseconde : au-delà, c'est du bruit de mesure. */
+function round(ms) {
+	return Math.round(ms * 100) / 100;
+}
+function emptyStatus() {
+	return {
+		s2xx: 0,
+		s3xx: 0,
+		s4xx: 0,
+		s5xx: 0,
+		unauthorized: 0,
+		forbidden: 0
+	};
+}
+function countStatus(status, code) {
+	if (code === null) return;
+	if (code >= 500) status.s5xx += 1;
+	else if (code >= 400) {
+		status.s4xx += 1;
+		if (code === 401) status.unauthorized += 1;
+		else if (code === 403) status.forbidden += 1;
+	} else if (code >= 300) status.s3xx += 1;
+	else if (code >= 200) status.s2xx += 1;
+}
+function addPhase(phases, name, ms) {
+	const total = phases[name] ??= {
+		totalMs: 0,
+		count: 0
+	};
+	total.totalMs += ms;
+	total.count += 1;
+}
+/**
+* Crée un accumulateur de profils.
+*
+* @param options - seuil N+1, prise en compte de l'outillage, aléa injecté.
+* @returns l'accumulateur ; son `result()` peut être appelé à tout moment.
+*/
+function createProfileAggregator(options = {}) {
+	const minRepeats = options.nPlusOneMinRepeats ?? 5;
+	const includeTooling = options.includeTooling ?? false;
+	const random = options.random ?? Math.random;
+	const routes = /* @__PURE__ */ new Map();
+	const nPlusOne = /* @__PURE__ */ new Map();
+	const shapes = /* @__PURE__ */ new Map();
+	const errors = [];
+	let requests = 0;
+	let http = 0;
+	let ws = 0;
+	let filteredTooling = 0;
+	let untimed = 0;
+	let sqlShapesDropped = 0;
+	const droppedShapes = /* @__PURE__ */ new Set();
+	function routeAcc(entry, route) {
+		const key = `${entry.kind}\u0000${route}`;
+		let acc = routes.get(key);
+		if (acc === void 0) {
+			acc = {
+				stats: {
+					route,
+					kind: entry.kind,
+					controller: entry.controller,
+					action: entry.action,
+					count: 0,
+					untimed: 0,
+					served: 0,
+					p50Ms: null,
+					p95Ms: null,
+					maxMs: null,
+					status: emptyStatus(),
+					errors: 0,
+					queries: {
+						total: 0,
+						perRequestMax: 0,
+						totalMs: 0
+					},
+					phases: {}
+				},
+				samples: [],
+				seen: 0
+			};
+			routes.set(key, acc);
+		}
+		return acc;
+	}
+	function sample(acc, ms) {
+		acc.seen += 1;
+		if (acc.samples.length < 256) {
+			acc.samples.push(ms);
+			return;
+		}
+		const slot = Math.floor(random() * acc.seen);
+		if (slot < 256) acc.samples[slot] = ms;
+	}
+	function countQueries(entry, stats) {
+		const queries = entry.queries;
+		if (queries === void 0 || queries.length === 0) return;
+		const q = stats.queries;
+		q.total += queries.length;
+		if (queries.length > q.perRequestMax) q.perRequestMax = queries.length;
+		for (const one of queries) q.totalMs += one.durationMs;
+	}
+	function addQueries(entry, route) {
+		const queries = entry.queries;
+		if (queries === void 0 || queries.length === 0) return;
+		const perShape = /* @__PURE__ */ new Map();
+		for (const q of queries) {
+			const shape = sqlShape(q.sql);
+			const local = perShape.get(shape);
+			if (local === void 0) perShape.set(shape, {
+				n: 1,
+				ms: q.durationMs
+			});
+			else {
+				local.n += 1;
+				local.ms += q.durationMs;
+			}
+			let global = shapes.get(shape);
+			if (global === void 0) {
+				if (shapes.size >= 200) {
+					if (!droppedShapes.has(shape) && droppedShapes.size < 200) droppedShapes.add(shape);
+					continue;
+				}
+				global = {
+					shape,
+					connector: q.connector ?? null,
+					count: 0,
+					totalMs: 0,
+					maxMs: 0,
+					routes: /* @__PURE__ */ new Set()
+				};
+				shapes.set(shape, global);
+			}
+			global.count += 1;
+			global.totalMs += q.durationMs;
+			if (q.durationMs > global.maxMs) global.maxMs = q.durationMs;
+			if (global.routes.size < 5) global.routes.add(route);
+		}
+		for (const [shape, { n, ms }] of perShape) {
+			if (n < minRepeats) continue;
+			const key = `${route}\u0000${shape}`;
+			const found = nPlusOne.get(key);
+			if (found === void 0) nPlusOne.set(key, {
+				route,
+				controller: entry.controller,
+				action: entry.action,
+				shape,
+				maxRepeats: n,
+				requests: 1,
+				totalMs: ms,
+				sampleRequestId: entry.requestId
+			});
+			else {
+				found.requests += 1;
+				found.totalMs += ms;
+				if (n > found.maxRepeats) {
+					found.maxRepeats = n;
+					found.sampleRequestId = entry.requestId;
+				}
+			}
+		}
+	}
+	return {
+		add(entry) {
+			if (!includeTooling && isToolingUrl(entry.url)) {
+				filteredTooling += 1;
+				return false;
+			}
+			requests += 1;
+			if (entry.kind === "ws") ws += 1;
+			else http += 1;
+			const route = entry.route ?? "(aucune route)";
+			const acc = routeAcc(entry, route);
+			const stats = acc.stats;
+			stats.count += 1;
+			countStatus(stats.status, entry.status);
+			const failed = isFailedProfile(entry);
+			if (failed) {
+				stats.errors += 1;
+				if (errors.length < 10) errors.push({
+					route,
+					status: entry.status,
+					error: entry.error === null ? null : entry.error.slice(0, ERROR_MESSAGE_MAX),
+					requestId: entry.requestId
+				});
+			}
+			const served = !failed && (entry.status === null || entry.status < 400);
+			if (entry.durationMs === null) {
+				stats.untimed += 1;
+				untimed += 1;
+			} else if (served) {
+				stats.served += 1;
+				sample(acc, entry.durationMs);
+				if (stats.maxMs === null || entry.durationMs > stats.maxMs) stats.maxMs = entry.durationMs;
+				for (const p of entry.phases) if (p.durationMs !== null) addPhase(stats.phases, p.name, p.durationMs);
+				const self = actionSelfMs(entry);
+				if (self !== null) addPhase(stats.phases, ACTION_SELF_PHASE, self);
+				countQueries(entry, stats);
+			}
+			addQueries(entry, route);
+			sqlShapesDropped = droppedShapes.size;
+			return true;
+		},
+		result() {
+			const routeList = [];
+			for (const acc of routes.values()) {
+				const sorted = [...acc.samples].sort((a, b) => a - b);
+				const p50 = percentile(sorted, 50);
+				const p95 = percentile(sorted, 95);
+				const phases = {};
+				for (const [name, t] of Object.entries(acc.stats.phases)) phases[name] = {
+					totalMs: round(t.totalMs),
+					count: t.count
+				};
+				routeList.push({
+					...acc.stats,
+					p50Ms: p50 === null ? null : round(p50),
+					p95Ms: p95 === null ? null : round(p95),
+					maxMs: acc.stats.maxMs === null ? null : round(acc.stats.maxMs),
+					status: { ...acc.stats.status },
+					queries: {
+						...acc.stats.queries,
+						totalMs: round(acc.stats.queries.totalMs)
+					},
+					phases
+				});
+			}
+			routeList.sort((a, b) => (b.p95Ms ?? -1) - (a.p95Ms ?? -1));
+			const nPlusOneList = [...nPlusOne.values()].map((n) => ({
+				route: n.route,
+				controller: n.controller,
+				action: n.action,
+				shape: n.shape,
+				maxRepeats: n.maxRepeats,
+				requests: n.requests,
+				totalMs: round(n.totalMs),
+				sampleRequestId: n.sampleRequestId
+			})).sort((a, b) => b.totalMs - a.totalMs);
+			const slowQueries = [...shapes.values()].sort((a, b) => b.totalMs - a.totalMs).slice(0, 10).map((s) => ({
+				shape: s.shape,
+				connector: s.connector,
+				count: s.count,
+				totalMs: round(s.totalMs),
+				maxMs: round(s.maxMs),
+				routes: [...s.routes]
+			}));
+			return {
+				requests,
+				http,
+				ws,
+				filteredTooling,
+				untimed,
+				routes: routeList,
+				nPlusOne: nPlusOneList,
+				slowQueries,
+				sqlShapesDropped,
+				errors: errors.slice()
+			};
+		}
+	};
+}
+/**
+* Agrège une liste de profils en une fois.
+*
+* @param entries - les profils, dans n'importe quel ordre.
+* @param options - mêmes réglages que {@link createProfileAggregator}.
+* @returns le rapport.
+*/
+function aggregateProfiles(entries, options = {}) {
+	const aggregator = createProfileAggregator(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, isProfiledUrl, isToolingUrl, profileLane, sqlShape, urlPath };

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

@@ -1,6 +1,6 @@
 import http from "node:http";
 import https from "node:https";
-//#region nodefony/src/proxy/forward.ts
+// nodefony/src/proxy/forward.ts
 /**
 * En-têtes de CONNEXION (RFC 9110 §7.6.1) : ils décrivent un saut, jamais le
 * message — un intermédiaire ne les transmet pas. Les cinq premiers sont en
@@ -381,13 +381,38 @@ function rawHead(status, rawHeaders, skip = null, extra = []) {
 	for (const line of extra) head += `${line}\r\n`;
 	return `${head}\r\n`;
 }
-/** Réponse brute minimale sur un socket d'upgrade, puis fermeture. */
-function refuseUpgrade(socket, status, reason) {
+/**
+* Réponse brute minimale sur un socket d'upgrade, puis fermeture.
+*
+* Les en-têtes passent par la validation de `node:http` : un nom ou une valeur
+* invalide — un saut de ligne surtout, qui forgerait un en-tête de plus — est
+* OMIS, jamais écrit. `Connection` et `Content-Length` sont posés ici et ne se
+* remplacent pas.
+*
+* @param socket - socket du client, encore en attente de sa réponse
+* @param status - statut HTTP du refus
+* @param reason - phrase de raison
+* @param headers - en-têtes du refus (`WWW-Authenticate`, `Retry-After`…)
+*/
+function refuseUpgrade(socket, status, reason, headers) {
 	if (!socket.writable) {
 		socket.destroy();
 		return;
 	}
-	socket.end(`HTTP/1.1 ${status} ${reason}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`);
+	let extra = "";
+	if (headers) for (const name of Object.keys(headers)) {
+		const lower = name.toLowerCase();
+		if (lower === "connection" || lower === "content-length") continue;
+		const value = String(headers[name]);
+		try {
+			http.validateHeaderName(name);
+			http.validateHeaderValue(name, value);
+		} catch {
+			continue;
+		}
+		extra += `${name}: ${value}\r\n`;
+	}
+	socket.end(`HTTP/1.1 ${status} ${reason}\r\n${extra}Connection: close\r\nContent-Length: 0\r\n\r\n`);
 }
 /** En-têtes d'une réponse d'amont REFUSANT l'upgrade, à ne pas recopier tels quels. */
 const REFUSAL_SKIP = /* @__PURE__ */ new Set([
@@ -472,5 +497,4 @@ function forwardUpgrade(req, socket, head, mount, target, from, relay) {
 	});
 	upstream.end();
 }
-//#endregion
 export { MAX_VIA_HOPS, bodyFramingOf, forwardRequest, forwardUpgrade, rawHead, refuseUpgrade, requestHeadersFor, responseHeadersFor, rewriteLocation, upstreamPath, viaLoops };

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

@@ -1,16 +1,18 @@
-//#region nodefony/src/proxy/generateProxyConfig.ts
+// nodefony/src/proxy/generateProxyConfig.ts
 /** Valeurs par défaut d'un modèle d'introspection (complété par la commande). */
 const defaultIntrospection = {
 	domains: [],
 	backendHost: "127.0.0.1",
 	httpPort: 5151,
 	httpsPort: 5152,
+	h2cPort: null,
 	staticRoots: [],
 	mounts: [],
 	listen: 80,
 	reencrypt: false,
 	maxBodyBytes: 0,
 	keepaliveIntervalMs: 0,
+	readinessPath: "/readyz",
 	tls: null
 };
 /**
@@ -123,8 +125,16 @@ function nginxServerBlock(intro, scheme, idleSeconds, tls) {
 */
 function generateHaproxyConfig(intro) {
 	const backendPort = intro.reencrypt ? intro.httpsPort : intro.httpPort;
+	const h2cPort = intro.reencrypt ? null : intro.h2cPort ?? null;
 	const idleSeconds = idleTimeoutSeconds(intro);
 	const serverSsl = intro.reencrypt ? ` ssl ca-file /etc/haproxy/certs/ca.pem verify required verifyhost ${firstDomain(intro)} sni str(${firstDomain(intro)})` : "";
+	const readiness = intro.readinessPath ?? null;
+	const healthCheck = readiness === null ? "" : `  # Retire l'exemplaire dès que ${readiness} répond 503 (début de l'arrêt),
+  # pas seulement quand son port se ferme.
+  option httpchk GET ${readiness}
+  http-check expect status 200
+`;
+	const h2cCheck = readiness === null ? "check" : `check port ${intro.httpPort} check-proto h1`;
 	const staticNote = intro.staticRoots.length > 0 || intro.mounts.length > 0 ? "  # NB : haproxy ne sert pas de fichiers — les statiques sont proxifiés au\n  # backend. Pour les offloader, utiliser nginx (proxy:generate nginx) +\n  # `statics.enabled: false` côté Nodefony.\n" : "";
 	return `# Généré par \`nodefony proxy:generate haproxy\` — NE PAS éditer à la main.
 # Reverse-proxy dérivé de l'introspection Nodefony.
@@ -166,11 +176,10 @@ frontend fe_nodefony
   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 }
 
-  default_backend be_nodefony
-
+${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
-${staticNote}  server nodefony ${intro.backendHost}:${backendPort} check${serverSsl}
-`;
+${healthCheck}${staticNote}  server nodefony ${intro.backendHost}:${backendPort} check${serverSsl}
+${h2cPort === null ? "" : `\nbackend be_nodefony_h2c\n${healthCheck}  server nodefony_h2c ${intro.backendHost}:${h2cPort} ${h2cCheck} proto h2\n`}`;
 }
 /** Premier domaine non-IP (pour verifyhost/sni), défaut `localhost`. */
 function firstDomain(intro) {
@@ -180,5 +189,4 @@ function firstDomain(intro) {
 function ensureTrailingSlash(dir) {
 	return dir.endsWith("/") ? dir : `${dir}/`;
 }
-//#endregion
 export { defaultIntrospection, generateHaproxyConfig, generateNginxConfig };

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

@@ -1,5 +1,5 @@
 import { isLoopbackHostname } from "nodefony";
-//#region nodefony/src/proxy/rules.ts
+// nodefony/src/proxy/rules.ts
 /**
 * 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
@@ -157,12 +157,19 @@ function isAmbiguousPath(url) {
 	return false;
 }
 /** Clé de handshake : 16 octets en base64 (RFC 6455 §4.1, §4.2.1). */
-const WS_KEY = /^[A-Za-z0-9+/]{22}==$/;
+const WS_KEY = /^\s*[A-Za-z0-9+/]{22}==\s*$/;
+/** `Upgrade: websocket`, casse et blancs indifférents. */
+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;
 /**
 * 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.
 *
+* Appelé à CHAQUE handshake (proxy inverse et routes de Nodefony) : aucune
+* allocation — des expressions testées, jamais de découpe de chaîne.
+*
 * @param method - méthode de la requête
 * @param headers - en-têtes reçus
 * @returns la raison du refus, ou `null` si le handshake est conforme
@@ -170,13 +177,12 @@ const WS_KEY = /^[A-Za-z0-9+/]{22}==$/;
 function websocketHandshakeProblem(method, headers) {
 	if (method !== "GET") return "méthode autre que GET";
 	const upgrade = headers.upgrade;
-	if (typeof upgrade !== "string" || upgrade.trim().toLowerCase() !== "websocket") return "Upgrade autre que websocket";
+	if (typeof upgrade !== "string" || !UPGRADE_WEBSOCKET.test(upgrade)) return "Upgrade autre que websocket";
 	const connection = headers.connection;
-	if (!(Array.isArray(connection) ? connection.join(",") : connection ?? "").toLowerCase().split(",").map((t) => t.trim()).includes("upgrade")) return "Connection sans upgrade";
+	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";
 	const key = headers["sec-websocket-key"];
-	if (typeof key !== "string" || !WS_KEY.test(key.trim())) return "Sec-WebSocket-Key invalide";
+	if (typeof key !== "string" || !WS_KEY.test(key)) return "Sec-WebSocket-Key invalide";
 	return null;
 }
-//#endregion
 export { MODULE_PROXY_PREFIXES, RESERVED_PROXY_PREFIXES, isAmbiguousPath, normalizePrefix, parseProxyOrigin, proxyMountProblems, websocketHandshakeProblem };

package/dist/nodefony/src/rateLimit/MemoryRateLimitStore.js

@@ -1,5 +1,5 @@
 import { assertPageQuery } from "nodefony";
-//#region nodefony/src/rateLimit/MemoryRateLimitStore.ts
+// nodefony/src/rateLimit/MemoryRateLimitStore.ts
 /**
 * Store de rate-limit **en mémoire** — algorithme *fixed window* par clé (IP).
 *
@@ -142,5 +142,4 @@ var MemoryRateLimitStore = class {
 		}
 	}
 };
-//#endregion
 export { MemoryRateLimitStore };

package/dist/nodefony/src/rateLimit/WsConnectionCounter.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/rateLimit/WsConnectionCounter.ts
+// nodefony/src/rateLimit/WsConnectionCounter.ts
 /**
 * Compteur de connexions WebSocket CONCURRENTES par IP — backstop opt-in
 * (F6c, revue 0.6). Distinct du {@link MemoryRateLimitStore} : celui-ci compte un
@@ -60,5 +60,4 @@ var WsConnectionCounter = class {
 		return this.#rejectedTotal;
 	}
 };
-//#endregion
 export { WsConnectionCounter, WsConnectionCounter as default };

package/dist/nodefony/src/rateLimit/rateLimitFilters.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/rateLimit/rateLimitFilters.ts
+// nodefony/src/rateLimit/rateLimitFilters.ts
 /**
 * **Le vocabulaire de filtre du registre de rate-limit**, en noms PUBLICS —
 * celui que la console écrit dans l'URL (`?limited=true`).
@@ -16,5 +16,4 @@
 const RATE_LIMIT_FILTERS = { 
 /** `true` = seulement les clés au plafond, `false` = seulement les autres. */
 limited: "boolean" };
-//#endregion
 export { RATE_LIMIT_FILTERS };

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

@@ -0,0 +1,50 @@
+// nodefony/src/servers/http2Limits.ts
+/**
+* Limites anti-DoS d'un serveur HTTP/2, lues dans la section `http2` du module :
+* `maxSessionMemory` (amplification mémoire) et `maxConcurrentStreams` dans les
+* SETTINGS (CVE-2023-44487, Rapid Reset). Règle UNIQUE des serveurs HTTP/2 — TLS
+* (5152) comme h2c — : une limite oubliée sur l'un d'eux en ferait la porte de
+* l'attaque.
+*
+* Une limite absente garde le défaut de Node (aucune régression).
+*
+* @param limits - `module.options.http2`.
+* @returns les options à fusionner dans celles de `createServer`/`createSecureServer`.
+*/
+function http2ServerLimits(limits) {
+	const options = {};
+	if (limits?.maxSessionMemory) options.maxSessionMemory = limits.maxSessionMemory;
+	if (limits?.maxConcurrentStreams) options.settings = { maxConcurrentStreams: limits.maxConcurrentStreams };
+	return options;
+}
+/**
+* Borne l'inactivité des sessions d'un serveur HTTP/2 — TLS (5152) comme h2c —
+* et contourne un défaut de Node qui garde chaque session fermée en vie jusqu'à
+* l'échéance de ce délai.
+*
+* Le défaut (Node 24, 26) : `closeSession` (`internal/http2/core`) marque la
+* session détruite PUIS appelle `session.setTimeout(0)` ; or `setStreamTimeout`
+* sort aussitôt sur un objet détruit. Le minuteur n'est jamais désarmé et retient
+* la session (~2,4 Ko) pendant `timeoutMs` : sous un flux de connexions neuves,
+* connexions/s × délai × 2,4 Ko. Signalé à Node : https://github.com/nodejs/node/issues/66885
+*
+* Le contournement : désarmer à la réception du GOAWAY, AVANT la destruction —
+* c'est ainsi que ferment un proxy et un client Node, même par `destroy()`. Rien
+* n'est retiré à la protection : Node n'agit déjà plus à l'échéance sur une
+* session fermée (`sessionOnTimeout` sort sur `closed`). Une coupure TCP sans
+* GOAWAY garde la rétention, bornée au délai.
+*
+* @param server - le serveur HTTP/2.
+* @param timeoutMs - délai d'inactivité ; 0 ou absent le laisse désactivé.
+* @param onTimeout - appelé à l'échéance (événement `timeout` du serveur).
+*/
+function setHttp2SessionTimeout(server, timeoutMs, onTimeout) {
+	if (!timeoutMs) return;
+	server.setTimeout(timeoutMs, onTimeout);
+	server.on("session", (session) => {
+		session.once("goaway", () => {
+			session.setTimeout(0);
+		});
+	});
+}
+export { http2ServerLimits, setHttp2SessionTimeout };