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

package/dist/nodefony/src/assets/collectAssets.js

@@ -1,6 +1,6 @@
 import { stripTrailingSlashes } from "nodefony";
 import { join } from "node:path";
-//#region nodefony/src/assets/collectAssets.ts
+// nodefony/src/assets/collectAssets.ts
 /** Normalise un préfixe en segment de chemin (`/_assets/x/` → `_assets/x`). */
 const prefixToSegment = (prefix) => stripTrailingSlashes(prefix.replace(/^\/+/, ""));
 /**
@@ -30,5 +30,4 @@ function planAssetPublish(sources, outDir) {
 	}
 	return plan;
 }
-//#endregion
 export { planAssetPublish };

package/dist/nodefony/src/assets/prebuiltUi.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-//#region nodefony/src/assets/prebuiltUi.ts
+// nodefony/src/assets/prebuiltUi.ts
 /**
 * Résout le mode de livraison de l'UI embarquée d'un module.
 *
@@ -121,5 +121,4 @@ var PrebuiltUi = class {
 		return this.template.replaceAll("<script", `<script nonce="${nonce}"`);
 	}
 };
-//#endregion
 export { PrebuiltUi, resolveUiDelivery };

package/dist/nodefony/src/context/Context.js

@@ -1,18 +1,13 @@
 import { buildMetaData } from "./metaData.js";
+import { protocolNameOf } from "./transport.js";
 import Cookie, { cookiesParser } from "../cookies/cookie.js";
 import { RequestContext, Service, logColor } from "nodefony";
 import { randomFillSync, randomUUID } from "node:crypto";
 import { performance } from "node:perf_hooks";
 import { AsyncResource } from "node:async_hooks";
-//#region nodefony/src/context/Context.ts
+// nodefony/src/context/Context.ts
 const colorLogEvent = () => logColor.cyanBgBlack("EVENT CONTEXT");
 const PERF_PROBE_SUB = process.env.NF_PERF_PROBE === "1";
-const EVENT_SEVERITY = {
-	onRequest: "INFO",
-	onSend: "INFO",
-	onConnect: "INFO",
-	onClose: "INFO"
-};
 let lifecycleEventLogging = null;
 /**
 * Bascule runtime du gate des logs d'events lifecycle. Réservé HORS hot path :
@@ -47,7 +42,6 @@ var Context = class extends Service {
 	secure = false;
 	security = null;
 	cleaned = false;
-	isControlledAccess = false;
 	validDomain = false;
 	finished = false;
 	pushAllowed = false;
@@ -55,7 +49,15 @@ var Context = class extends Service {
 	requested = false;
 	sessionStarting = false;
 	domain = "";
+	/** Famille traitée (`network.protocol.name` d'OpenTelemetry) — union ouverte. */
 	type;
+	/** Serveur qui a reçu la requête — choisit la configuration par serveur. */
+	serverType;
+	/**
+	* Protocole du saut local (registre IANA ALPN) — union ouverte. Une connexion
+	* WebSocket naît d'un upgrade HTTP/1.1 ; `HttpContext` le constate sur la requête.
+	*/
+	alpnProtocol = "http/1.1";
 	server;
 	httpKernel;
 	request = null;
@@ -76,6 +78,14 @@ var Context = class extends Service {
 	session = null;
 	cookieSession = null;
 	user = null;
+	/**
+	* Identifiant de l'appelant AUTHENTIFIÉ, posé par le pare-feu ; `null` hors
+	* zone ou pour un anonyme. Lisible au démontage, hors de la bulle ALS : c'est
+	* ce que lisent le journal d'audit et le profileur. Distinct de `user`, qui
+	* lie la session à son principal de SESSION — y écrire l'identité d'un jeton
+	* rattacherait la session d'un autre compte.
+	*/
+	userIdentifier = null;
 	waitAsync = false;
 	isJson = false;
 	_isHtml = null;
@@ -133,6 +143,7 @@ var Context = class extends Service {
 	_phaseIndex = null;
 	_afterResponseFns = null;
 	_afterResponseFired = false;
+	requestStore = null;
 	_abortController = null;
 	metaData = {
 		nodefony: {},
@@ -140,13 +151,14 @@ var Context = class extends Service {
 	};
 	scheme;
 	webSocketState = null;
-	constructor(container, type) {
-		super(type, container);
+	constructor(container, serverType) {
+		super(serverType, container);
 		if (PERF_PROBE_SUB) {
 			const p = globalThis.__nfPerfProbe;
 			if (p && p.t0 !== 0n) p.svcNs += Number(process.hrtime.bigint() - p.t0);
 		}
-		this.type = type;
+		this.serverType = serverType;
+		this.type = protocolNameOf(serverType);
 		this.set("context", this);
 		this.httpKernel = this.get("HttpKernel");
 		this.sessionService = this.get("sessions");
@@ -159,35 +171,24 @@ var Context = class extends Service {
 			const verbose = (this.kernel?.options)?.timing?.verbose;
 			this._timingVerbose = verbose === true;
 		}
-		this.scheme = "https";
-		switch (this.type) {
+		this.scheme = serverType;
+		switch (serverType) {
 			case "http": {
-				this.scheme = "http";
 				const server = this.get("server-http");
 				this.server = server?.server;
 				break;
 			}
-			case "http2":
 			case "https": {
-				this.scheme = "https";
 				const server = this.get("server-https");
 				this.server = server?.server;
 				break;
 			}
-			case "http3": {
-				this.scheme = "https";
-				const server = this.get("server-http3");
-				this.server = server?.server ?? null;
-				break;
-			}
-			case "websocket": {
-				this.scheme = "ws";
+			case "ws": {
 				const server = this.get("server-websocket");
 				this.server = server?.server;
 				break;
 			}
-			case "websocket-secure": {
-				this.scheme = "wss";
+			case "wss": {
 				const server = this.get("server-websocket-secure");
 				this.server = server?.server;
 				break;
@@ -296,24 +297,43 @@ var Context = class extends Service {
 		if (this._abortController && !this._abortController.signal.aborted) this._abortController.abort(new Error(reason ?? "Context aborted"));
 	}
 	log(pci, severity, msgid, msg) {
-		if (!msgid) msgid = this.type;
+		if (!msgid) msgid = this.serverType;
 		if (this.requestId && RequestContext.getRequestId() === void 0) return RequestContext.run({ requestId: this.requestId }, () => super.log(pci, severity, msgid, msg));
 		return super.log(pci, severity, msgid, msg);
 	}
+	/**
+	* Confie au contexte le magasin `RequestContext` de son unité de travail
+	* (requête HTTP, connexion WebSocket), pour qu'il le VIDE à son nettoyage.
+	*
+	* Un minuteur ou une promesse armé pendant l'unité de travail capture ce
+	* magasin et le garde au-delà de la réponse — avec le contexte, l'identité
+	* et le jeton du pare-feu. Le vidage ({@link RequestContext.release}) n'y
+	* laisse que la corrélation et le scope refermé.
+	*
+	* @param store - le magasin passé à `RequestContext.run`
+	*/
+	holdRequestStore(store) {
+		this.requestStore = store;
+	}
 	clean() {
 		this.cleaned = true;
 		this.httpKernel = null;
+		const store = this.requestStore;
+		if (store) {
+			RequestContext.release(store);
+			this.requestStore = null;
+		}
 		return super.clean();
 	}
 	/**
 	* Log d'un event du cycle de vie — gate boot-time (V2.1) : en production le
-	* Pdu n'est PAS construit (return avant toute allocation). Hors prod, jalon
-	* notable → INFO (EVENT_SEVERITY), event technique → DEBUG.
+	* Pdu n'est PAS construit (return avant toute allocation). Hors prod : DEBUG,
+	* pour le Suivi de requête de Studio — la ligne `req` porte le bilan.
 	*/
 	logEvent(event) {
 		lifecycleEventLogging ??= this.kernel?.environment !== "production";
 		if (!lifecycleEventLogging) return;
-		this.log(`${colorLogEvent()} ${event}`, EVENT_SEVERITY[event] || "DEBUG");
+		this.log(`${colorLogEvent()} ${event}`, "DEBUG");
 	}
 	fire(event, ...args) {
 		this.logEvent(event);
@@ -367,7 +387,7 @@ var Context = class extends Service {
 			} else line += `${p.name}=…`;
 			i++;
 		}
-		this.log(`TRACE phases [Σ ${total.toFixed(2)}ms] ${line}`, "DEBUG", `${this.type} TIMING`);
+		this.log(`TRACE phases [Σ ${total.toFixed(2)}ms] ${line}`, "DEBUG", `${this.serverType} TIMING`);
 	}
 	addRequestCookie(cookie) {
 		if (cookie instanceof Cookie) return this.cookies[cookie.name] = cookie;
@@ -426,5 +446,4 @@ var Context = class extends Service {
 	setContextJson(_encoding = "utf-8") {}
 	setContextHtml(_encoding = "utf-8") {}
 };
-//#endregion
 export { Context as default, nextCspNonce, setLifecycleEventLogging };

package/dist/nodefony/src/context/domainMatcher.js

@@ -1,5 +1,5 @@
 import { escapeRegExp } from "nodefony";
-//#region nodefony/src/context/domainMatcher.ts
+// nodefony/src/context/domainMatcher.ts
 /**
 * Matching de domaine (`Host`) — fonctions PURES, politique UNIQUE partagée par
 * les deux étages de Nodefony :
@@ -15,12 +15,30 @@ import { escapeRegExp } from "nodefony";
 * Politique de compilation (sûre, ancrée, ReDoS-free) :
 * - string sans `*` → match EXACT ancré (`^...$`, le `.` est littéral).
 * - string avec `*` → wildcard UN label (`*.example.com` → `^[^.]+\.example\.com$`,
-*   RFC 6125 TLS-wildcard : matche `img.example.com`, pas `a.b.example.com` ni `example.com`).
+*   RFC 9525 TLS-wildcard : matche `img.example.com`, pas `a.b.example.com` ni `example.com`).
 * - `RegExp` → reprise telle quelle (l'auteur assume l'ancrage).
 *
 * Compilation faite UNE fois (boot / enregistrement de route) ; le test par
 * requête est un simple `RegExp.test` sur une liste pré-compilée (zéro alloc hot-path).
 */
+/**
+* Nom d'hôte d'une autorité brute (`host[:port]`), sans port — la valeur que
+* rendrait `URL.hostname` pour une autorité déjà canonique, sans en payer le
+* parse (`indexOf` + `slice`, #508). Un littéral IPv6 garde ses crochets
+* (`[::1]:5151` → `[::1]`) : couper au premier `:` le réduirait à `[`.
+*
+* @param host - autorité brute (`Host`), éventuellement absente
+* @returns le nom d'hôte, `""` si l'autorité est absente
+*/
+function hostnameOf(host) {
+	if (!host) return "";
+	if (host.charCodeAt(0) === 91) {
+		const end = host.indexOf("]");
+		return end === -1 ? host : host.slice(0, end + 1);
+	}
+	const colon = host.indexOf(":");
+	return colon === -1 ? host : host.slice(0, colon);
+}
 const DEV_LOOPBACK = [
 	"localhost",
 	"127.0.0.1",
@@ -117,5 +135,4 @@ function isDomainAllowed(regAlias, domain) {
 	for (const reg of regAlias) if (reg.test(domain)) return true;
 	return false;
 }
-//#endregion
-export { compileDomainPattern, compileDomainPatterns, compileTrustedHosts, isDomainAllowed, resolveTrustedHostNames };
+export { compileDomainPattern, compileDomainPatterns, compileTrustedHosts, hostnameOf, isDomainAllowed, resolveTrustedHostNames };

package/dist/nodefony/src/context/forwarded.js

@@ -1,9 +1,9 @@
 import { extractClientIp, resolveFromRight } from "./trustProxy.js";
 import { isIPv4 } from "node:net";
-//#region nodefony/src/context/forwarded.ts
+// nodefony/src/context/forwarded.ts
 /**
 * Découpe une chaîne sur `sep` au **niveau supérieur uniquement**, en respectant
-* les `quoted-string` RFC 7230 (`value = token / quoted-string`, §4) : un
+* les `quoted-string` RFC 9110 §5.6.4 (`value = token / quoted-string`, RFC 7239 §4) : un
 * séparateur à l'intérieur de guillemets (ex. un host quoté, un IPv6) n'est PAS
 * un point de coupe. Les `\"` échappés à l'intérieur des guillemets sont préservés.
 */
@@ -40,7 +40,7 @@ function splitTopLevel(input, sep) {
 	out.push(buf);
 	return out;
 }
-/** Retire les guillemets d'une `quoted-string` et déséchappe `\x` (RFC 7230 §3.2.6). */
+/** Retire les guillemets d'une `quoted-string` et déséchappe `\x` (RFC 9110 §5.6.4). */
 function unquote(value) {
 	const v = value.trim();
 	if (v.length >= 2 && v.startsWith("\"") && v.endsWith("\"")) return v.slice(1, -1).replace(/\\(.)/gu, "$1");
@@ -181,5 +181,4 @@ function resolveForwarded(headers, socketAddress, checker) {
 function hasForwardingHeaders(headers) {
 	return Boolean(headers.forwarded || headers["x-forwarded-for"] || headers["x-forwarded-proto"] || headers["x-forwarded-scheme"] || headers["x-forwarded-host"]);
 }
-//#endregion
 export { forwardedNodeIp, hasForwardingHeaders, parseForwarded, resolveForwarded };

package/dist/nodefony/src/context/http/HttpContext.js

@@ -1,4 +1,6 @@
 import HttpError from "../../errors/httpError.js";
+import { responseEnded } from "../responseEnded.js";
+import { alpnProtocolOf } from "../transport.js";
 import Cookie from "../../cookies/cookie.js";
 import Context from "../Context.js";
 import { sanitizeRequestId } from "../requestId.js";
@@ -7,25 +9,63 @@ import HttpResponse from "./Response.js";
 import Http2Request from "../http2/Request.js";
 import Http2Response from "../http2/Response.js";
 import { describeSessionStoreFailure } from "../../session/sessionStoreFailure.js";
-import { extend, finallyMaybe, isPromise, thenMaybe, typeOf } from "nodefony";
+import { openSseStream } from "./SseStream.js";
+import { finallyMaybe, isPromise, thenMaybe, typeOf } from "nodefony";
 import url, { URL } from "node:url";
-//#region nodefony/src/context/http/HttpContext.ts
+// nodefony/src/context/http/HttpContext.ts
+/**
+* Même URL (chemin, requête, hôte) sous un autre schéma et un autre port.
+* `port` absent → port par défaut du schéma (omis de l'URL).
+*
+* @param from - URL de la requête.
+* @param scheme - schéma cible.
+* @param port - port du serveur cible, s'il est connu.
+* @returns l'URL absolue de redirection.
+*/
+function switchUrlScheme(from, scheme, port) {
+	const target = new URL(from.href);
+	target.protocol = `${scheme}:`;
+	target.port = port === void 0 ? "" : String(port);
+	return target.href;
+}
 const socketActiveContext = /* @__PURE__ */ new WeakMap();
 const socketTimeoutArmed = /* @__PURE__ */ new WeakSet();
+/**
+* Gestionnaire `timeout` PERMANENT d'une socket h1, fabriqué hors de toute
+* méthode : une fermeture créée dans `HttpContext.setTimeout()` partageait
+* l'environnement d'une autre qui lit `this`, et retenait ainsi le contexte de
+* la PREMIÈRE requête de la connexion tant que celle-ci vivait (#561).
+*
+* @param socket - la socket h1 dont on route le délai d'inactivité
+* @returns l'écouteur à attacher une fois par socket
+*/
+function idleSocketTimeoutHandler(socket) {
+	return () => {
+		const ctx = socketActiveContext.get(socket);
+		if (ctx !== void 0 && !ctx.cleaned && !ctx.response.response?.writableEnded) {
+			ctx._onTimeout();
+			return;
+		}
+		socket.destroy();
+	};
+}
 const PERF_PROBE_SUB = process.env.NF_PERF_PROBE === "1";
 var HttpContext = class extends Context {
 	proxy = null;
+	/** Socket h1 inscrite dans `socketActiveContext` — retirée par `clean()`. */
+	activeSocket = null;
 	isRedirect = false;
 	sended = false;
 	request;
 	response;
 	uploadService;
-	constructor(container, request, response, type) {
-		super(container, type);
+	constructor(container, request, response, serverType) {
+		super(container, serverType);
+		this.alpnProtocol = alpnProtocolOf(request);
 		this.uploadService = this.get("upload");
 		const perfSub = PERF_PROBE_SUB ? globalThis.__nfPerfProbe : void 0;
 		if (perfSub && perfSub.t0 !== 0n) perfSub.uploadNs += Number(process.hrtime.bigint() - perfSub.t0);
-		if (this.type === "http2") {
+		if (this.alpnProtocol === "h2" || this.alpnProtocol === "h2c") {
 			this.request = new Http2Request(request, this);
 			this.response = new Http2Response(response, this);
 		} else {
@@ -86,7 +126,7 @@ var HttpContext = class extends Context {
 	_onTimeout() {
 		if (this.listenerCount("onTimeout")) this.fire("onTimeout", this);
 		this._abortIfPending("Request timeout");
-		let error = null;
+		let error;
 		if (this.response.stream) error = new HttpError("Gateway Timeout", 504, this);
 		else error = new HttpError("Request Timeout", 408, this);
 		this.httpKernel?.onError(error, this);
@@ -126,24 +166,39 @@ var HttpContext = class extends Context {
 		if (!res) return;
 		if (this.response.stream) {
 			res.setTimeout(this.response.timeout, () => {
-				if (!this.response.response?.writableEnded) this._onTimeout();
+				if (!responseEnded(res)) this._onTimeout();
 			});
 			return;
 		}
 		const socket = res.socket;
 		if (!socket) return;
 		socketActiveContext.set(socket, this);
+		this.activeSocket = socket;
 		const ms = this.response.timeout;
 		if (socket.timeout !== ms) socket.setTimeout(ms);
 		if (!socketTimeoutArmed.has(socket)) {
 			socketTimeoutArmed.add(socket);
-			socket.on("timeout", () => {
-				const ctx = socketActiveContext.get(socket);
-				if (ctx && !ctx.response.response?.writableEnded) ctx._onTimeout();
-			});
+			socket.on("timeout", idleSocketTimeoutHandler(socket));
 		}
 	}
 	/**
+	* Nettoie le contexte, et le DÉTACHE de sa socket h1 : la connexion
+	* persistante survit à la requête, et l'entrée de `socketActiveContext`
+	* retiendrait sinon tout le contexte jusqu'à sa fermeture. Seule l'entrée qui
+	* pointe encore sur CE contexte est retirée — une requête suivante sur la
+	* même socket a pu la réécrire. Le gestionnaire `timeout` de la socket ne
+	* trouve alors rien et prend le chemin « socket inactive → `destroy()` »,
+	* celui qu'il prenait déjà pour un contexte nettoyé.
+	*/
+	clean() {
+		const socket = this.activeSocket;
+		if (socket) {
+			if (socketActiveContext.get(socket) === this) socketActiveContext.delete(socket);
+			this.activeSocket = null;
+		}
+		super.clean();
+	}
+	/**
 	* Sérialise la donnée selon son type (JSON, HTML, texte), pose statut et
 	* en-têtes, puis l'envoie ({@link send}). Synchrone quand l'envoi l'est (#505).
 	*
@@ -229,7 +284,7 @@ var HttpContext = class extends Context {
 	}
 	/** Hook `onSend` (attendu seulement s'il a un écouteur), puis en-têtes et corps. */
 	emitAndWrite(body, encoding) {
-		if (body) this.response.setBody(body);
+		if (body || body === "") this.response.setBody(body);
 		if (this.listenerCount("onSend") > 0) return this.fireAsync("onSend", this.response, this).then(() => this.writeHeadAndBody(body, encoding));
 		return this.writeHeadAndBody(body, encoding);
 	}
@@ -265,6 +320,18 @@ var HttpContext = class extends Context {
 			return this.close();
 		});
 	}
+	/**
+	* Répond par un flux d'événements serveur (`text/event-stream`).
+	*
+	* La requête ne se termine qu'à `close()` du flux, ou au départ du client.
+	*
+	* @param options - battement de cœur, délai `retry:` initial.
+	* @returns le flux, ou sa promesse quand une session est à sauver d'abord.
+	* @throws HttpError 500 quand la réponse est déjà partie.
+	*/
+	openSse(options) {
+		return openSseStream(this, options);
+	}
 	flush(chunk, encoding) {
 		return this.response.flush(chunk, encoding);
 	}
@@ -288,41 +355,27 @@ var HttpContext = class extends Context {
 		if (typeof Url === "object") return this.response.redirect(url.format(Url), status, headers);
 		return this.response.redirect(Url, status, headers);
 	}
+	/**
+	* Redirige vers la même URL en HTTPS, sur le port du serveur HTTPS lié —
+	* ou le port par défaut derrière un proxy, dont le port public est inconnu.
+	*
+	* @param status - code de redirection (défaut de `redirect`).
+	* @param headers - en-têtes ajoutés à la réponse.
+	*/
 	redirectHttps(status, headers) {
-		if (this.session) {}
-		let urlExtend = null;
-		if (this.proxy) urlExtend = {
-			protocol: "https",
-			href: "",
-			host: ""
-		};
-		else urlExtend = {
-			protocol: "https",
-			port: this.httpKernel?.httpsPort || 443,
-			href: "",
-			host: ""
-		};
-		const urlChange = extend({}, this.request.url, urlExtend);
-		const newUrl = url.format(urlChange);
-		return this.redirect(newUrl, status, headers);
+		const port = this.proxy ? void 0 : this.httpKernel?.httpsPort;
+		return this.redirect(switchUrlScheme(this.request.url, "https", port), status, headers);
 	}
+	/**
+	* Redirige vers la même URL en HTTP, sur le port du serveur HTTP lié — ou
+	* le port par défaut derrière un proxy.
+	*
+	* @param status - code de redirection (défaut de `redirect`).
+	* @param headers - en-têtes ajoutés à la réponse.
+	*/
 	redirectHttp(status, headers) {
-		if (this.session) {}
-		let urlExtend = null;
-		if (this.proxy) urlExtend = {
-			protocol: "http",
-			href: "",
-			host: ""
-		};
-		else urlExtend = {
-			protocol: "http",
-			port: this.httpKernel?.httpPort || 80,
-			href: "",
-			host: ""
-		};
-		const urlChange = extend({}, this.request.url, urlExtend);
-		const newUrl = url.format(urlChange);
-		return this.redirect(newUrl, status, headers);
+		const port = this.proxy ? void 0 : this.httpKernel?.httpPort;
+		return this.redirect(switchUrlScheme(this.request.url, "http", port), status, headers);
 	}
 	getHostName() {
 		return this.request.getHostName();
@@ -363,5 +416,4 @@ var HttpContext = class extends Context {
 		this.response.setContentType("html", encoding);
 	}
 };
-//#endregion
-export { HttpContext as default };
+export { HttpContext as default, switchUrlScheme };