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

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

@@ -47,7 +47,6 @@ var Context = class extends Service {
 	secure = false;
 	security = null;
 	cleaned = false;
-	isControlledAccess = false;
 	validDomain = false;
 	finished = false;
 	pushAllowed = false;
@@ -76,6 +75,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 +140,7 @@ var Context = class extends Service {
 	_phaseIndex = null;
 	_afterResponseFns = null;
 	_afterResponseFired = false;
+	requestStore = null;
 	_abortController = null;
 	metaData = {
 		nodefony: {},
@@ -300,9 +308,28 @@ var Context = class extends Service {
 		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();
 	}
 	/**

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

@@ -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",
@@ -118,4 +136,4 @@ function isDomainAllowed(regAlias, domain) {
 	return false;
 }
 //#endregion
-export { compileDomainPattern, compileDomainPatterns, compileTrustedHosts, isDomainAllowed, resolveTrustedHostNames };
+export { compileDomainPattern, compileDomainPatterns, compileTrustedHosts, hostnameOf, isDomainAllowed, resolveTrustedHostNames };

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

@@ -3,7 +3,7 @@ import { isIPv4 } from "node:net";
 //#region 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");

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

@@ -1,4 +1,5 @@
 import HttpError from "../../errors/httpError.js";
+import { responseEnded } from "../responseEnded.js";
 import Cookie from "../../cookies/cookie.js";
 import Context from "../Context.js";
 import { sanitizeRequestId } from "../requestId.js";
@@ -7,14 +8,51 @@ 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
+/**
+* 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;
@@ -126,24 +164,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 +282,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 +318,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 +353,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();
@@ -364,4 +415,4 @@ var HttpContext = class extends Context {
 	}
 };
 //#endregion
-export { HttpContext as default };
+export { HttpContext as default, switchUrlScheme };

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

@@ -1,5 +1,6 @@
 import HttpError from "../../errors/httpError.js";
 import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
+import { hostnameOf } from "../domainMatcher.js";
 import { Parser, ParserJson, ParserQs, ParserXml, acceptParser } from "./parser.js";
 import { isCanonicalAuthority, splitTarget } from "./urlFastPath.js";
 import { RequestContext, extend, useConfig } from "nodefony";
@@ -52,15 +53,6 @@ function perfMark(field) {
 	const p = globalThis.__nfPerfProbe;
 	if (p && p.t0 !== 0n) p[field] += Number(process.hrtime.bigint() - p.t0);
 }
-/**
-* Nom d'hôte d'une autorité brute (`host[:port]`) : tout ce qui précède le
-* premier `:`. Même résultat que `host.split(":")[0]`, sans tableau (#508).
-*/
-function hostnameOf(host) {
-	if (!host) return "";
-	const colon = host.indexOf(":");
-	return colon === -1 ? host : host.slice(0, colon);
-}
 var HttpRequest = class {
 	context;
 	request;

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

@@ -62,9 +62,24 @@ var HttpResponse = class {
 	* n'a été choisi (ni négociation, ni `render`, ni controller), émet le défaut
 	* `this.contentType` (application/octet-stream) — comportement identique à
 	* l'ancienne pose au constructeur, sans le ping-pong set/remove/re-set.
+	*
+	* Une réponse SANS corps n'annonce aucun type : `Content-Type` décrit le
+	* contenu (RFC 9110 §8.3), et il n'y en a pas.
 	*/
 	ensureContentTypeHeader() {
-		if (this.response && !this.response.hasHeader("content-type")) this.response.setHeader("content-type", this.contentType);
+		if (this.response && !this.response.hasHeader("content-type") && !this.#isBodyless()) this.response.setHeader("content-type", this.contentType);
+	}
+	/**
+	* Vrai quand la réponse n'a pas de corps : 204 et 304 n'en ont jamais
+	* (RFC 9110 §15.3.5, §15.4.5) ; ailleurs, un corps posé et VIDE. Un corps
+	* jamais posé ne dit rien — un flux peut suivre l'en-tête — et `HEAD` rend
+	* les en-têtes du `GET` (§9.3.2) : tous deux gardent le défaut.
+	*/
+	#isBodyless() {
+		if (NO_CONTENT_LENGTH_STATUS.has(this.statusCode)) return true;
+		if (this.context.method === "HEAD") return false;
+		if (this.#text !== null) return this.#text === "" && !this.flushing;
+		return this.#buffer?.length === 0 && !this.flushing;
 	}
 	/**
 	* Corps de la réponse en octets. Un corps posé en texte n'est encodé qu'à la