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

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/http/Request.js

@@ -52,10 +52,21 @@ 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;
 	#url = null;
+	#rawHostname;
+	#rawHostSource;
 	headers = {};
 	host = "";
 	method;
@@ -162,7 +173,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 +547,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;

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

@@ -15,6 +15,29 @@ const REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
 	308
 ]);
 const NO_CONTENT_LENGTH_STATUS = /* @__PURE__ */ new Set([204, 304]);
+const CONTENT_TYPE_CACHE_MAX = 64;
+const contentTypeCache = /* @__PURE__ */ new Map();
+/**
+* Résout `type` (extension ou type MIME) comme `mime.contentType`, avec
+* mémorisation bornée des résolutions positives.
+*
+* @param type - extension (`json`) ou type MIME (`text/html`).
+* @returns la résolution, ou `null` si `mime-types` ne connaît pas le type.
+*/
+function resolveContentType(type) {
+	const hit = contentTypeCache.get(type);
+	if (hit !== void 0) return hit;
+	const full = mime.contentType(type);
+	if (!full) return null;
+	const semi = full.indexOf(";");
+	const resolved = {
+		full,
+		bare: semi === -1 ? full : full.slice(0, semi),
+		charset: mime.charset(full)
+	};
+	if (contentTypeCache.size < CONTENT_TYPE_CACHE_MAX) contentTypeCache.set(type, resolved);
+	return resolved;
+}
 var HttpResponse = class {
 	context;
 	response;
@@ -177,9 +200,9 @@ var HttpResponse = class {
 	}
 	setContentType(type, encoding) {
 		if (type && encoding) {
-			const full = mime.contentType(type);
-			if (full) {
-				const mytype = full.split(";")[0] ?? full;
+			const resolved = resolveContentType(type);
+			if (resolved) {
+				const mytype = resolved.bare;
 				this.contentType = mytype;
 				this.encoding = encoding;
 				if (mytype === "application/json" || mytype.endsWith("+json")) return this.setHeader("Content-Type", mytype);
@@ -187,10 +210,11 @@ var HttpResponse = class {
 			}
 		}
 		if (type && !encoding) {
-			const mytype = mime.contentType(type);
-			if (mytype) {
+			const resolved = resolveContentType(type);
+			if (resolved) {
+				const mytype = resolved.full;
 				this.contentType = mytype;
-				let charset = mime.charset(this.contentType);
+				const charset = resolved.charset;
 				if (charset) this.encoding = charset;
 				return this.setHeader("Content-Type", mytype);
 			}

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

@@ -79,20 +79,45 @@ function isCanonicalAuthority(host, scheme) {
 		if (port.length === 0 || port.charCodeAt(0) === 48) return false;
 		if (scheme === "https" && port === "443" || scheme === "http" && port === "80") return false;
 	}
-	const labels = name.split(".");
-	for (const label of labels) if (label.length === 0) return false;
-	if (isDigits(labels.at(-1) ?? "")) {
-		if (labels.length !== 4) return false;
-		for (const label of labels) {
-			if (!isDigits(label) || label.length > 3) return false;
-			if (label.length > 1 && label.charCodeAt(0) === 48) return false;
-			if (Number(label) > 255) return false;
+	let labels = 1;
+	let start = 0;
+	for (let i = 0; i < name.length; i++) if (name.charCodeAt(i) === DOT) {
+		if (i === start) return false;
+		labels++;
+		start = i + 1;
+	}
+	if (start === name.length) return false;
+	if (isDigitsFrom(name, start)) {
+		if (labels !== 4) return false;
+		return isCanonicalDottedQuad(name);
+	}
+	return true;
+}
+/**
+* Les quatre labels (non vides, déjà comptés) forment-ils une dotted-quad
+* canonique ? Chacun : chiffres seuls, 3 au plus, sans zéro de tête, ≤ 255.
+*/
+function isCanonicalDottedQuad(name) {
+	let start = 0;
+	for (let i = 0; i <= name.length; i++) {
+		if (i < name.length && name.charCodeAt(i) !== DOT) continue;
+		const len = i - start;
+		if (len > 3) return false;
+		if (len > 1 && name.charCodeAt(start) === 48) return false;
+		let value = 0;
+		for (let k = start; k < i; k++) {
+			const c = name.charCodeAt(k);
+			if (c < 48 || c > 57) return false;
+			value = value * 10 + (c - 48);
 		}
+		if (value > 255) return false;
+		start = i + 1;
 	}
 	return true;
 }
-function isDigits(s) {
-	for (let i = 0; i < s.length; i++) {
+/** `s` ne contient-elle que des chiffres ASCII à partir de `from` ? */
+function isDigitsFrom(s, from) {
+	for (let i = from; i < s.length; i++) {
 		const c = s.charCodeAt(i);
 		if (c < 48 || c > 57) return false;
 	}

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

@@ -1,5 +1,51 @@
 import { isPortListening, resolvePortPolicy } from "nodefony";
+import cluster from "node:cluster";
 //#region nodefony/src/servers/portBinder.ts
+/**
+* **portBinder** — écoute sur le port désiré, ou sur le prochain port libre.
+*
+* Pourquoi ce fichier existe : lancer deux apps Nodefony côte à côte (le repo et
+* une app générée, deux projets, un banc et une démo…) faisait mourir la seconde
+* en `EADDRINUSE`. Le port désiré est une PRÉFÉRENCE en développement ; il reste
+* un CONTRAT en production.
+*
+* ## Pourquoi retenter au `listen()` plutôt que sonder d'abord
+*
+* La tentation est d'appeler « le port 5151 est-il libre ? » puis de binder. C'est
+* une **course** (TOCTOU) : entre la réponse et le bind, un autre process peut
+* prendre le port — et on échoue quand même, après avoir cru le contraire. Le
+* `listen()` est, lui, **atomique** : soit il réussit, soit le noyau dit
+* `EADDRINUSE`. On retente donc sur l'échec réel, jamais sur une prédiction.
+*
+* ## Pourquoi une SONDE malgré cela
+*
+* Le `listen()` est atomique, mais il ne dit pas tout : un port peut être **déjà
+* servi** et le noyau l'accorder quand même. Lier `0.0.0.0:P` alors qu'un autre
+* processus tient `127.0.0.1:P` **réussit** sur macOS et les BSD — ce sont deux
+* liaisons distinctes, et les connexions locales partent à la PLUS SPÉCIFIQUE.
+* Entre familles d'adresses (`::1` tenu, `0.0.0.0` demandé), même linux
+* l'accorde. L'application annonce alors `READY`, publie ses ports… et ne reçoit
+* rien : une panne muette, et un banc qui interroge le serveur du VOISIN.
+*
+* On constate donc, AVANT de binder, qu'aucun serveur ne répond déjà là où notre
+* liaison va recevoir (`isPortListening` — une connexion en boucle locale, aucun
+* outil système, même verdict sur les trois plateformes). Ce n'est pas la sonde
+* « ce port est-il libre ? » écartée plus haut : elle ne remplace pas le repli
+* atomique, qui reste le seul à trancher la course — elle ajoute le seul conflit
+* que le noyau n'exprime JAMAIS. La course résiduelle (un tiers prend le port
+* entre la sonde et le bind) retombe donc sur `EADDRINUSE`, inchangé.
+*
+* ## Pourquoi sauter les ports réservés
+*
+* HTTP veut 5151, HTTPS veut 5152. Si 5151 est pris, incrémenter naïvement ferait
+* voler 5152 à HTTPS — qui se décalerait à son tour, en cascade. Les ports que les
+* AUTRES serveurs convoitent sont donc sautés d'emblée.
+*
+* ## Fail-loud
+*
+* Un décalage est TOUJOURS annoncé (`onShift`) : une app qui écoute ailleurs que
+* là où on l'attend sans le dire est une dégradation silencieuse.
+*/
 /** Nombre de ports essayés après le désiré, en `auto`. */
 const DEFAULT_PORT_RETRY_ATTEMPTS = 20;
 /** Port configuré d'un serveur, ou `0` (désactivé / non précisé → choix noyau). */
@@ -127,12 +173,21 @@ function isPortUnavailable(code, port) {
 * handler d'erreur durable s'installe APRÈS, sur le serveur qui écoute — sinon il
 * verrait passer les `EADDRINUSE` de repli et croirait à une panne).
 *
+* @param server - serveur à mettre en écoute.
+* @param host - hôte passé à `listen`.
+* @param plan - port désiré et nombre de replis permis.
+* @param probe - sonde de présence (injectée par le banc).
+* @param sharedListener - vrai dans un worker `node:cluster` : le port y est
+*   PARTAGÉ par le maître, et un voisin qui y répond est un frère, pas un
+*   conflit. Sans cette exception, `nodefony cluster -w N` ne gardait qu'un
+*   worker en vie — les autres mouraient sur « port déjà servi » et
+*   bouclaient en relance.
 * @returns l'adresse obtenue + le port désiré si un décalage a eu lieu.
 * @throws l'erreur de `listen` : soit un code qui ne dit pas « ce port est pris »
 *   (`ENOTFOUND`, `EACCES` sous 1024 — cf `isPortUnavailable`), soit un port
 *   indisponible après épuisement des essais (le fallback n'est PAS infini).
 */
-async function bindWithFallback(server, host, plan, probe = isPortListening) {
+async function bindWithFallback(server, host, plan, probe = isPortListening, sharedListener = cluster.isWorker) {
 	let candidate = plan.desired;
 	let used = 0;
 	/**
@@ -154,7 +209,7 @@ async function bindWithFallback(server, host, plan, probe = isPortListening) {
 		server.listen(port, host);
 	});
 	for (;;) {
-		const conflict = plan.desired === 0 || candidate !== plan.desired ? null : await detectPortConflict(candidate, host, probe);
+		const conflict = sharedListener || plan.desired === 0 || candidate !== plan.desired ? null : await detectPortConflict(candidate, host, probe);
 		const failure = conflict ? portConflictError(candidate, conflict) : await listenOnce(candidate);
 		if (failure === null) return {
 			address: server.address(),

package/dist/types/nodefony/config/config.d.ts

@@ -87,6 +87,7 @@ export declare const httpConfigSchema: z.ZodObject<{
                 name: z.ZodOptional<z.ZodString>;
                 value: z.ZodOptional<z.ZodString>;
                 shortName: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
             }, z.core.$loose>>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;