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

package/dist/nodefony/service/x509.js

@@ -0,0 +1,324 @@
+import { isIPv4, isIPv6 } from "node:net";
+import { createHash, sign } from "node:crypto";
+//#region nodefony/service/x509.ts
+/**
+* Fabrique et lecture de certificats X.509 par `node:crypto` seul — aucune
+* dépendance tierce.
+*
+* `node:crypto` sait LIRE un certificat (`X509Certificate`) et SIGNER, pas
+* en FABRIQUER un : ce module encode le `TBSCertificate` en DER (RFC 5280
+* §4.1), le signe avec `crypto.sign`, puis l'assemble. Seul le sous-ensemble
+* nécessaire à un certificat serveur auto-signé est couvert. Les fonctions
+* sont PURES (aucun disque, aucun kernel) : elles s'éprouvent sans décor.
+*
+* Pourquoi pas node-forge : sa vérification de signature RSA PKCS#1 v1.5
+* accepte des signatures forgées (GHSA-86w9-cpqp-85rv), sans aucune version
+* corrigée. Nous ne vérifions aucune signature, mais `npm audit` signale le
+* paquet pour tous ceux qui installent `@nodefony/http`.
+*/
+const SIGNATURE_OIDS = {
+	sha1: "1.2.840.113549.1.1.5",
+	sha256: "1.2.840.113549.1.1.11",
+	sha384: "1.2.840.113549.1.1.12",
+	sha512: "1.2.840.113549.1.1.13"
+};
+/** OID de la signature RSA-SHA1, que le service régénère. */
+const SHA1_WITH_RSA_OID = SIGNATURE_OIDS.sha1;
+/** Noms lisibles des algorithmes de signature courants (rendu de `describe`). */
+const SIGNATURE_NAMES = Object.assign(Object.create(null), {
+	[SIGNATURE_OIDS.sha1]: "sha1WithRSAEncryption",
+	[SIGNATURE_OIDS.sha256]: "sha256WithRSAEncryption",
+	[SIGNATURE_OIDS.sha384]: "sha384WithRSAEncryption",
+	[SIGNATURE_OIDS.sha512]: "sha512WithRSAEncryption",
+	"1.2.840.113549.1.1.10": "RSASSA-PSS",
+	"1.2.840.10045.4.3.2": "ecdsa-with-SHA256",
+	"1.2.840.10045.4.3.3": "ecdsa-with-SHA384",
+	"1.2.840.10045.4.3.4": "ecdsa-with-SHA512",
+	"1.3.101.112": "Ed25519"
+});
+const ATTRIBUTE_OIDS = Object.assign(Object.create(null), {
+	commonName: "2.5.4.3",
+	CN: "2.5.4.3",
+	surname: "2.5.4.4",
+	SN: "2.5.4.4",
+	serialNumber: "2.5.4.5",
+	countryName: "2.5.4.6",
+	C: "2.5.4.6",
+	localityName: "2.5.4.7",
+	L: "2.5.4.7",
+	stateOrProvinceName: "2.5.4.8",
+	ST: "2.5.4.8",
+	streetAddress: "2.5.4.9",
+	street: "2.5.4.9",
+	organizationName: "2.5.4.10",
+	O: "2.5.4.10",
+	organizationalUnitName: "2.5.4.11",
+	OU: "2.5.4.11",
+	title: "2.5.4.12",
+	givenName: "2.5.4.42",
+	emailAddress: "1.2.840.113549.1.9.1",
+	E: "1.2.840.113549.1.9.1"
+});
+const OID_COUNTRY = "2.5.4.6";
+const OID_EMAIL = "1.2.840.113549.1.9.1";
+const OID_BASIC_CONSTRAINTS = "2.5.29.19";
+const OID_KEY_USAGE = "2.5.29.15";
+const OID_EXT_KEY_USAGE = "2.5.29.37";
+const OID_SUBJECT_ALT_NAME = "2.5.29.17";
+const OID_SUBJECT_KEY_ID = "2.5.29.14";
+const OID_SERVER_AUTH = "1.3.6.1.5.5.7.3.1";
+const OID_CLIENT_AUTH = "1.3.6.1.5.5.7.3.2";
+function derLength(length) {
+	if (length < 128) return Buffer.from([length]);
+	const bytes = [];
+	for (let rest = length; rest > 0; rest = Math.floor(rest / 256)) bytes.unshift(rest & 255);
+	return Buffer.from([128 | bytes.length, ...bytes]);
+}
+function tlv(tag, content) {
+	return Buffer.concat([
+		Buffer.from([tag]),
+		derLength(content.length),
+		content
+	]);
+}
+const sequence = (...items) => tlv(48, Buffer.concat(items));
+const set = (...items) => tlv(49, Buffer.concat(items));
+const explicit = (n, content) => tlv(160 | n, content);
+const octetString = (content) => tlv(4, content);
+const bitString = (content) => tlv(3, Buffer.concat([Buffer.from([0]), content]));
+const DER_NULL = Buffer.from([5, 0]);
+const DER_TRUE = tlv(1, Buffer.from([255]));
+function objectIdentifier(dotted) {
+	const [first = 0, second = 0, ...rest] = dotted.split(".").map(Number);
+	const bytes = [first * 40 + second];
+	for (const arc of rest) {
+		const chunk = [arc & 127];
+		for (let value = Math.floor(arc / 128); value > 0; value = Math.floor(value / 128)) chunk.unshift(value & 127 | 128);
+		bytes.push(...chunk);
+	}
+	return tlv(6, Buffer.from(bytes));
+}
+/** Entier positif depuis sa forme hexadécimale (octet 0x00 ajouté si besoin). */
+function positiveInteger(hex) {
+	let bytes = Buffer.from(hex.length % 2 === 0 ? hex : `0${hex}`, "hex");
+	let start = 0;
+	while (start < bytes.length - 1 && bytes[start] === 0) start++;
+	bytes = bytes.subarray(start);
+	if (bytes.length === 0) bytes = Buffer.from([0]);
+	if ((bytes[0] ?? 0) & 128) bytes = Buffer.concat([Buffer.from([0]), bytes]);
+	return tlv(2, bytes);
+}
+/** RFC 5280 §4.1.2.5 : UTCTime jusqu'en 2049, GeneralizedTime au-delà. */
+function time(date) {
+	const iso = date.toISOString();
+	const digits = `${iso.slice(0, 4)}${iso.slice(5, 7)}${iso.slice(8, 10)}${iso.slice(11, 13)}${iso.slice(14, 16)}${iso.slice(17, 19)}Z`;
+	const year = date.getUTCFullYear();
+	if (year >= 1950 && year < 2050) return tlv(23, Buffer.from(digits.slice(2), "ascii"));
+	return tlv(24, Buffer.from(digits, "ascii"));
+}
+function attributeOid(attribute) {
+	if (attribute.type && /^\d+(\.\d+)+$/.test(attribute.type)) return attribute.type;
+	const key = attribute.name ?? attribute.shortName ?? attribute.type ?? "";
+	const oid = ATTRIBUTE_OIDS[key];
+	if (!oid) throw new Error(`Attribut de certificat inconnu : '${key}'. Noms reconnus : ${Object.keys(ATTRIBUTE_OIDS).join(", ")}.`);
+	return oid;
+}
+/** Nom distinctif : un RDN par attribut (RFC 5280 §4.1.2.4). */
+function distinguishedName(attributes) {
+	const rdns = attributes.map((attribute) => {
+		const oid = attributeOid(attribute);
+		if (typeof attribute.value !== "string") throw new Error(`Attribut de certificat '${oid}' sans valeur.`);
+		const value = Buffer.from(attribute.value, "utf8");
+		const tag = oid === OID_COUNTRY ? 19 : oid === OID_EMAIL ? 22 : 12;
+		return set(sequence(objectIdentifier(oid), tlv(tag, value)));
+	});
+	return sequence(...rdns);
+}
+/** Octets d'une adresse IP pour un SAN `iPAddress` (4 ou 16 octets). */
+function ipAddressBytes(ip) {
+	if (isIPv4(ip)) return Buffer.from(ip.split(".").map(Number));
+	if (!isIPv6(ip) || ip.includes("%")) throw new Error(`Adresse IP invalide pour un SAN : '${ip}'.`);
+	const toGroups = (part) => {
+		if (part === "") return [];
+		const groups = [];
+		for (const piece of part.split(":")) if (piece.includes(".")) {
+			const [a = 0, b = 0, c = 0, d = 0] = piece.split(".").map(Number);
+			groups.push(a << 8 | b, c << 8 | d);
+		} else groups.push(parseInt(piece, 16));
+		return groups;
+	};
+	const [head = "", tail] = ip.split("::");
+	const left = toGroups(head);
+	const right = tail === void 0 ? [] : toGroups(tail);
+	const zeros = new Array(8 - left.length - right.length).fill(0);
+	const out = Buffer.alloc(16);
+	[
+		...left,
+		...zeros,
+		...right
+	].forEach((group, i) => out.writeUInt16BE(group, i * 2));
+	return out;
+}
+/**
+* Octets d'un SAN `dNSName` — IA5String (RFC 5280 §4.2.1.6).
+*
+* 🔴 Jamais `Buffer.from(nom, "ascii")` : Node y garde l'octet BAS de chaque
+* caractère, et `evil\u012Elocalhost` devient `evil.localhost` — un certificat
+* qui couvre un nom que personne n'a configuré. Hors ASCII imprimable, le nom
+* est REFUSÉ (un IDN s'écrit en punycode, `xn--…`).
+*/
+function dnsNameBytes(dns) {
+	if (!/^[\x20-\x7e]+$/u.test(dns)) throw new Error(`Nom DNS invalide pour un SAN : ${JSON.stringify(dns)} — ASCII imprimable seulement (un nom international s'écrit en punycode, xn--…).`);
+	return Buffer.from(dns, "ascii");
+}
+function extension(oid, critical, value) {
+	return critical ? sequence(objectIdentifier(oid), DER_TRUE, octetString(value)) : sequence(objectIdentifier(oid), octetString(value));
+}
+function readNode(der, offset) {
+	const tag = der[offset];
+	let length = der[offset + 1];
+	if (tag === void 0 || length === void 0) throw new Error("DER tronqué.");
+	let start = offset + 2;
+	if (length & 128) {
+		const count = length & 127;
+		length = 0;
+		for (let i = 0; i < count; i++) length = length * 256 + (der[start + i] ?? 0);
+		start += count;
+	}
+	const end = start + length;
+	if (end > der.length) throw new Error("DER tronqué.");
+	return {
+		tag,
+		start,
+		end
+	};
+}
+function children(der, node) {
+	const out = [];
+	for (let offset = node.start; offset < node.end;) {
+		const child = readNode(der, offset);
+		out.push(child);
+		offset = child.end;
+	}
+	return out;
+}
+function decodeObjectIdentifier(bytes) {
+	const first = bytes[0] ?? 0;
+	const arcs = [Math.min(Math.floor(first / 40), 2), first - Math.min(Math.floor(first / 40), 2) * 40];
+	let value = 0;
+	for (let i = 1; i < bytes.length; i++) {
+		const byte = bytes[i] ?? 0;
+		value = value * 128 + (byte & 127);
+		if (!(byte & 128)) {
+			arcs.push(value);
+			value = 0;
+		}
+	}
+	return arcs.join(".");
+}
+/**
+* OID de l'algorithme de signature d'un certificat DER (champ
+* `signatureAlgorithm`, RFC 5280 §4.1.1.2). Lu dans le DER plutôt que par
+* `X509Certificate.signatureAlgorithmOid`, absent des Node du plancher.
+*
+* @param der - certificat encodé DER (`X509Certificate.raw`)
+* @throws Si le DER n'a pas la forme d'un certificat
+*/
+function signatureAlgorithmOid(der) {
+	const [, algorithm] = children(der, readNode(der, 0));
+	const oid = algorithm ? children(der, algorithm)[0] : void 0;
+	if (oid?.tag !== 6) throw new Error("Certificat DER sans algorithme de signature.");
+	return decodeObjectIdentifier(der.subarray(oid.start, oid.end));
+}
+/** Nom lisible d'un OID de signature (l'OID lui-même s'il est inconnu). */
+function signatureAlgorithmName(oid) {
+	return SIGNATURE_NAMES[oid] ?? oid;
+}
+/**
+* Entrées DNS et IP d'un `subjectAltName` tel que le rend
+* `X509Certificate.subjectAltName` (`DNS:a, IP Address:1.2.3.4`).
+*/
+function parseSubjectAltName(value) {
+	const dns = [];
+	const ip = [];
+	if (!value) return {
+		dns,
+		ip
+	};
+	for (const raw of value.split(/,\s*/)) {
+		const colon = raw.indexOf(":");
+		if (colon < 0) continue;
+		const kind = raw.slice(0, colon);
+		let entry = raw.slice(colon + 1);
+		if (entry.startsWith("\"")) try {
+			entry = String(JSON.parse(entry));
+		} catch {
+			continue;
+		}
+		if (kind === "DNS") dns.push(entry);
+		else if (kind === "IP Address") ip.push(entry);
+	}
+	return {
+		dns,
+		ip
+	};
+}
+/**
+* Valeur d'un champ d'un nom distinctif tel que le rend
+* `X509Certificate.subject` / `.issuer` (une ligne `CLÉ=valeur` par champ).
+*/
+function distinguishedNameField(dn, key) {
+	for (const line of dn.split("\n")) if (line.startsWith(`${key}=`)) return line.slice(key.length + 1);
+	return null;
+}
+/** Contenu de la BIT STRING `subjectPublicKey` d'une SPKI DER. */
+function subjectPublicKeyBits(spki) {
+	const [, key] = children(spki, readNode(spki, 0));
+	if (key?.tag !== 3) throw new Error("Clé publique SPKI sans subjectPublicKey.");
+	return spki.subarray(key.start + 1, key.end);
+}
+function signAsync(hash, data, key) {
+	return new Promise((resolve, reject) => {
+		sign(hash, data, key, (error, signature) => {
+			if (error) reject(error);
+			else resolve(signature);
+		});
+	});
+}
+function toPem(der) {
+	return `-----BEGIN CERTIFICATE-----\n${der.toString("base64").replace(/(.{64})/g, "$1\n").replace(/\n$/, "")}\n-----END CERTIFICATE-----\n`;
+}
+/**
+* Fabrique un certificat serveur auto-signé et le rend en PEM.
+*
+* Contenu : version 3, sujet = émetteur, `basicConstraints` cA=false,
+* `keyUsage` (digitalSignature, keyEncipherment — critique),
+* `extKeyUsage` (serverAuth, clientAuth), `subjectAltName` (critique si le
+* sujet est vide, RFC 5280 §4.2.1.6) et `subjectKeyIdentifier` (SHA-1 de la
+* clé publique, méthode 1 de RFC 5280 §4.2.1.2).
+*
+* @param spec - clés, série, validité, noms et hachage
+* @returns le certificat encodé PEM
+* @throws Si un attribut ou une adresse IP est invalide
+*/
+async function createSelfSignedCertificate(spec) {
+	const spki = spec.publicKey.export({
+		type: "spki",
+		format: "der"
+	});
+	const algorithm = sequence(objectIdentifier(SIGNATURE_OIDS[spec.hash]), DER_NULL);
+	const name = distinguishedName(spec.attributes);
+	const altNames = [...spec.dns.map((dns) => tlv(130, dnsNameBytes(dns))), ...spec.ip.map((ip) => tlv(135, ipAddressBytes(ip)))];
+	const extensions = [
+		extension(OID_BASIC_CONSTRAINTS, false, sequence()),
+		extension(OID_KEY_USAGE, true, tlv(3, Buffer.from([5, 160]))),
+		extension(OID_EXT_KEY_USAGE, false, sequence(objectIdentifier(OID_SERVER_AUTH), objectIdentifier(OID_CLIENT_AUTH)))
+	];
+	if (altNames.length > 0) extensions.push(extension(OID_SUBJECT_ALT_NAME, spec.attributes.length === 0, sequence(...altNames)));
+	extensions.push(extension(OID_SUBJECT_KEY_ID, false, octetString(createHash("sha1").update(subjectPublicKeyBits(spki)).digest())));
+	const tbs = sequence(explicit(0, tlv(2, Buffer.from([2]))), positiveInteger(spec.serialHex), algorithm, name, sequence(time(spec.notBefore), time(spec.notAfter)), name, spki, explicit(3, sequence(...extensions)));
+	const signature = await signAsync(spec.hash, tbs, spec.privateKey);
+	return toPem(sequence(tbs, algorithm, bitString(signature)));
+}
+//#endregion
+export { SHA1_WITH_RSA_OID, createSelfSignedCertificate, distinguishedNameField, ipAddressBytes, parseSubjectAltName, signatureAlgorithmName, signatureAlgorithmOid };

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";
@@ -56,6 +57,8 @@ var HttpRequest = class {
 	context;
 	request;
 	#url = null;
+	#rawHostname;
+	#rawHostSource;
 	headers = {};
 	host = "";
 	method;
@@ -162,7 +165,9 @@ var HttpRequest = class {
 		if (PERF_PROBE_SUB) perfMark("reqProxyNs");
 		this.method = this.getMethod();
 		this.host = this.getHost();
-		this.hostname = this.getHostName(this.host);
+		this.#rawHostSource = this.host;
+		this.#rawHostname = hostnameOf(this.host);
+		this.hostname = this.#rawHostname;
 		this.sUrl = this.getFullUrl(request);
 		const fast = (this.scheme === "http" || this.scheme === "https") && isCanonicalAuthority(this.host, this.scheme) ? splitTarget(this.getRawTarget()) : null;
 		if (fast !== null) {
@@ -534,9 +539,9 @@ var HttpRequest = class {
 	}
 	getHostName(host) {
 		if (this.#url?.hostname) return this.#url.hostname;
-		if (host) return host.split(":")[0] ?? "";
-		if (host = this.getHost()) return host.split(":")[0] ?? "";
-		return "";
+		if (host) return hostnameOf(host);
+		host = this.getHost();
+		return host === this.#rawHostSource ? this.#rawHostname : hostnameOf(host);
 	}
 	getHost() {
 		return this.request.headers.host;