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

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

@@ -1,5 +1,7 @@
-import { isLoopbackHostname } from "nodefony";
+import { isLoopbackHostname, parseBareOrigin } from "nodefony";
 // nodefony/src/proxy/rules.ts
+/** Schémas d’amont d’un relais : un proxy inverse ne parle que HTTP. */
+const PROXY_ORIGIN_PROTOCOLS = ["http:", "https:"];
 /**
 * 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
@@ -49,17 +51,7 @@ function normalizePrefix(prefix) {
 * @returns l'URL analysée, ou `null` si ce n'est pas une origine http(s) nue
 */
 function parseProxyOrigin(origin) {
-	let url;
-	try {
-		url = new URL(origin);
-	} catch {
-		return null;
-	}
-	if (url.protocol !== "http:" && url.protocol !== "https:") return null;
-	if (!/^https?:\/\/[^/?#]+\/?$/i.test(origin.trim())) return null;
-	if (url.search !== "" || url.hash !== "") return null;
-	if (url.username !== "" || url.password !== "") return null;
-	return url;
+	return parseBareOrigin(origin, PROXY_ORIGIN_PROTOCOLS);
 }
 /**
 * Examine un montage. Rend TOUS les refus, pas le premier : une configuration
@@ -163,6 +155,29 @@ 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;
 /**
+* Le corps reçu porte-t-il un codage de transfert que le serveur ne sait pas
+* défaire ? Seul `chunked` est compris : Node le retire, mais laisse en place
+* tout codage qui le précède (`gzip, chunked`) — le corps livré serait encore
+* compressé. RFC 9112 §6.1 : un tel message reçoit 501. Un `chunked` qui n'est
+* pas le DERNIER codage est déjà refusé par Node en 400 (§6.3).
+*
+* Seule règle, pour le serveur d'origine et pour le proxy inverse. Chemin de
+* chaque requête : une lecture d'en-tête, rien d'autre sans `Transfer-Encoding`.
+*
+* @param coding - valeur de l'en-tête `Transfer-Encoding`, absente le plus souvent
+* @returns `true` quand le corps ne peut pas être lu tel qu'annoncé
+*/
+function isUnsupportedTransferCoding(coding) {
+	if (coding === void 0 || coding === "chunked") return false;
+	return coding.trim().toLowerCase() !== "chunked";
+}
+/**
+* Raison rendue par {@link websocketHandshakeProblem} quand le client parle une
+* autre version du protocole : la seule qui appelle une réponse distincte —
+* le client doit apprendre vers quelle version se rabattre (RFC 6455 §4.4).
+*/
+const WS_UNSUPPORTED_VERSION = "Sec-WebSocket-Version ≠ 13";
+/**
 * 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.
@@ -180,9 +195,9 @@ function websocketHandshakeProblem(method, headers) {
 	if (typeof upgrade !== "string" || !UPGRADE_WEBSOCKET.test(upgrade)) return "Upgrade autre que websocket";
 	const connection = headers.connection;
 	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";
+	if (headers["sec-websocket-version"] !== "13") return WS_UNSUPPORTED_VERSION;
 	const key = headers["sec-websocket-key"];
 	if (typeof key !== "string" || !WS_KEY.test(key)) return "Sec-WebSocket-Key invalide";
 	return null;
 }
-export { MODULE_PROXY_PREFIXES, RESERVED_PROXY_PREFIXES, isAmbiguousPath, normalizePrefix, parseProxyOrigin, proxyMountProblems, websocketHandshakeProblem };
+export { MODULE_PROXY_PREFIXES, RESERVED_PROXY_PREFIXES, WS_UNSUPPORTED_VERSION, isAmbiguousPath, isUnsupportedTransferCoding, normalizePrefix, parseProxyOrigin, proxyMountProblems, websocketHandshakeProblem };

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

@@ -0,0 +1,76 @@
+import { constants } from "node:http2";
+// nodefony/src/servers/http2Goaway.ts
+/** Plus long délai d'annonce (ms) : un pair qui ne répond pas au PING ne retient pas la fermeture. */
+const ANNOUNCE_CAP_MS = 1e3;
+/** Dernier identifiant de flux possible (RFC 9113 §6.8) : « aucun flux n'est encore écarté ». */
+const LAST_POSSIBLE_STREAM = 2 ** 31 - 1;
+/**
+* Annonce à UNE session HTTP/2 qu'elle va fermer, SANS écarter un flux déjà en route.
+*
+* Un PING mesure l'aller-retour, puis GOAWAY à `2^31-1`, puis l'attente de cet
+* aller-retour : après elle, tout flux ouvert par le client avant l'annonce est
+* arrivé, et le GOAWAY définitif (`session.close()`, dernier flux traité) peut
+* suivre. RFC 9113 §6.8 : « SHOULD send an initial GOAWAY frame with the last
+* stream identifier set to 2^31-1 […] After allowing time for any in-flight
+* stream creation (at least one round-trip time) ». Sans annonce, un flux croisé
+* avec le GOAWAY est refusé alors qu'il aurait pu être servi.
+*
+* L'aller-retour se MESURE avant l'annonce : après un GOAWAY, un client Node ne
+* répond plus aux PING (constaté sur Node 26.13).
+*
+* @param session - la session à annoncer, ni fermée ni détruite
+* @param settle - appelé UNE fois : après l'attente, à la fermeture de la
+*   session, ou aussitôt si le PING ne part pas. Un pair muet ne l'appelle
+*   jamais — le délai maximal appartient à l'appelant.
+*/
+function announceSessionClose(session, settle) {
+	let settled = false;
+	let wait = null;
+	const done = () => {
+		if (settled) return;
+		settled = true;
+		if (wait !== null) clearTimeout(wait);
+		session.removeListener("close", done);
+		settle();
+	};
+	session.once("close", done);
+	if (!session.ping((error, rttMs) => {
+		if (error !== null || settled || session.closed) return done();
+		session.goaway(constants.NGHTTP2_NO_ERROR, LAST_POSSIBLE_STREAM);
+		wait = setTimeout(done, Math.max(1, Math.ceil(rttMs)));
+	})) {
+		session.goaway(constants.NGHTTP2_NO_ERROR, LAST_POSSIBLE_STREAM);
+		done();
+	}
+}
+/**
+* Ferme EN DOUCEUR une session HTTP/2 restée inactive au-delà du délai du serveur.
+*
+* RFC 9113 §9.1 : un serveur est « permitted to terminate idle connections »,
+* et « SHOULD first send a GOAWAY ». La fermeture suit l'annonce en deux temps
+* ({@link announceSessionClose}), puis `session.close()` : aucun nouveau flux,
+* mais les flux en cours vont à leur terme — un flux long et muet (abonnement
+* gRPC) n'est pas coupé, seuls les NOUVEAUX flux repartent sur une autre
+* connexion, ce que tout client HTTP/2 fait sur GOAWAY.
+*
+* Le délai de la session est désarmé d'abord : Node (26.13) marque une session
+* détruite AVANT de désarmer son minuteur, qui la retiendrait alors jusqu'à son
+* échéance (nodejs/node#66885).
+*
+* @param session - la session inactive
+* @param capMs - délai maximal d'attente de l'écho du PING (ms)
+*/
+function closeIdleSession(session, capMs = ANNOUNCE_CAP_MS) {
+	if (session.closed || session.destroyed) return;
+	session.setTimeout(0);
+	let finished = false;
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		clearTimeout(timer);
+		if (!session.closed && !session.destroyed) session.close();
+	};
+	const timer = setTimeout(finish, capMs);
+	announceSessionClose(session, finish);
+}
+export { ANNOUNCE_CAP_MS, announceSessionClose, closeIdleSession };

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

@@ -1,3 +1,4 @@
+import { closeIdleSession } from "./http2Goaway.js";
 // nodefony/src/servers/http2Limits.ts
 /**
 * Limites anti-DoS d'un serveur HTTP/2, lues dans la section `http2` du module :
@@ -18,29 +19,54 @@ function http2ServerLimits(limits) {
 	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.
+* Une session HTTP/2, et non une socket HTTP/1.1 : sur 5152 (`allowHTTP1`),
+* l'événement `timeout` du serveur reçoit les deux. `node:http2` n'exporte pas
+* la classe de session — elle se reconnaît à sa capacité (`goaway`).
+*/
+function isHttp2Session(target) {
+	return typeof target === "object" && target !== null && "goaway" in target;
+}
+/**
+* Ferme les sessions d'un serveur HTTP/2 — TLS (5152) comme h2c — restées
+* inactives au-delà de `timeoutMs`, 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
+* **La fermeture est À NOUS.** Node arme chaque session par
+* `session.setTimeout(server.timeout, sessionOnTimeout)` — un écouteur `once` —
+* et `sessionOnTimeout` ne détruit la session que si le serveur n'a AUCUN
+* écouteur `timeout` ; s'il en a un, il lui passe la main, UNE fois par session
+* (`internal/http2/core`, Node 26.13). Le serveur 5152 en a toujours un
+* (`routeSocketTimeout`, pour ses sockets HTTP/1.1), et ce délai doit prévenir
+* l'application (`onTimeout`) : sans fermeture ici, une session inactive vivait
+* jusqu'à ce que le CLIENT la ferme (#763). À l'échéance, la session est fermée
+* en douceur — GOAWAY annoncé puis définitif, les flux en cours vont à leur
+* terme ({@link closeIdleSession}, RFC 9113 §9.1 et §6.8).
 *
-* 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.
+* **Le contournement** (Node 24, 26) : `closeSession` marque la session détruite
+* PUIS appelle `session.setTimeout(0)`, qui sort aussitôt sur un objet détruit ;
+* le minuteur retient alors la session (~2,4 Ko) pendant `timeoutMs`. Il est
+* désarmé à la réception du GOAWAY, AVANT la destruction — c'est ainsi que
+* ferment un proxy et un client Node, même par `destroy()` ; et
+* `closeIdleSession` le désarme avant de fermer. Signalé à Node :
+* https://github.com/nodejs/node/issues/66885 (corrigé par nodejs/node#66886,
+* absent de la 26.13). Une coupure TCP sans GOAWAY garde la rétention, bornée
+* au délai.
+*
+* Coût par requête : nul — un écouteur par serveur, et la fermeture n'agit qu'à
+* l'échéance.
 *
 * @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).
+* @param onTimeout - appelé à l'échéance d'une session (événement `timeout` du
+*   serveur), après le début de sa fermeture.
 */
 function setHttp2SessionTimeout(server, timeoutMs, onTimeout) {
 	if (!timeoutMs) return;
-	server.setTimeout(timeoutMs, onTimeout);
+	server.setTimeout(timeoutMs, (target) => {
+		if (!isHttp2Session(target)) return;
+		closeIdleSession(target);
+		onTimeout();
+	});
 	server.on("session", (session) => {
 		session.once("goaway", () => {
 			session.setTimeout(0);

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

@@ -0,0 +1,100 @@
+import http2 from "node:http2";
+// nodefony/src/servers/http2StreamGrace.ts
+/**
+* Délai avant de retenter un `PING` que Node a refusé (plafond de `PING` en vol
+* atteint par d'autres émetteurs de la session) : ceux-là reviennent en un
+* aller-retour, une boucle `setImmediate` brûlerait le processeur pendant ce
+* temps sur un lien lent.
+*/
+const PING_RETRY_MS = 10;
+/**
+* Les flux d'une session qui attendent leur grâce. `inFlight` : couverts par le
+* `PING` en vol ; `next` : arrivés après son envoi, donc couverts par le
+* suivant — un `PING` envoyé AVANT leurs en-têtes ne prouve rien pour eux.
+*/
+var SessionGrace = class {
+	inFlight = null;
+	next = null;
+};
+/** Chemin d'erreur seulement : aucune session n'a d'entrée hors refus en cours. */
+const graces = /* @__PURE__ */ new WeakMap();
+/** Coupe le flux en `NO_ERROR` s'il est encore ouvert et que le client émet encore. */
+function decide(stream) {
+	if (stream.closed || stream.destroyed || stream.state.remoteClose) return;
+	stream.close(http2.constants.NGHTTP2_NO_ERROR);
+}
+function sendPing(session, grace) {
+	if (session.destroyed) {
+		graces.delete(session);
+		return;
+	}
+	if (session.closed) {
+		const pending = grace.inFlight;
+		const later = grace.next;
+		grace.inFlight = null;
+		grace.next = null;
+		graces.delete(session);
+		setImmediate(() => {
+			if (pending !== null) for (const stream of pending) decide(stream);
+			if (later !== null) for (const stream of later) decide(stream);
+		});
+		return;
+	}
+	if (!session.ping(() => settle(session, grace))) setTimeout(() => sendPing(session, grace), PING_RETRY_MS).unref();
+}
+function settle(session, grace) {
+	const batch = grace.inFlight;
+	grace.inFlight = grace.next;
+	grace.next = null;
+	if (batch !== null) for (const stream of batch) decide(stream);
+	if (grace.inFlight !== null) sendPing(session, grace);
+	else graces.delete(session);
+}
+/**
+* Ferme en `NO_ERROR` un flux HTTP/2 dont la réponse est partie mais dont le
+* client émet encore, après la grâce d'un aller-retour (`PING`, RFC 9113 §6.7).
+*
+* RFC 9113 §8.1 : après une réponse complète, le serveur PEUT demander au
+* client d'arrêter d'émettre par un `RST_STREAM` `NO_ERROR`. La coupe ne doit
+* jamais précéder l'envoi de la réponse : un `RST_STREAM` soumis pendant que
+* les en-têtes attendent encore dans la file de nghttp2 les fait JETER, et le
+* client reçoit une fin de flux sans statut (un client gRPC la lit INTERNAL).
+* Le `PING` part derrière la réponse ; son écho prouve qu'elle est arrivée.
+*
+* **Un seul `PING` par session** couvre tous les flux qui attendent : un flux
+* arrivé pendant qu'un `PING` est en vol attend le suivant. Le plafond de
+* `PING` en vol de Node (10 par session) n'est donc jamais atteint par ce
+* chemin, et aucun flux n'est coupé sans grâce — ce que faisait la coupe
+* immédiate quand `ping()` rendait `false`, au-delà de 10 refus simultanés.
+*
+* Session en fermeture GRACIEUSE (délai d'inactivité, arrêt) : Node n'envoie
+* plus de `PING`, et la session attend la fin de ses flux — un client muet la
+* retiendrait. La coupe part alors au tour de boucle suivant, le temps que les
+* réponses déjà soumises quittent la file de nghttp2.
+*
+* Après la grâce : client qui a fini d'émettre → rien (le flux se ferme seul,
+* sans `RST_STREAM`) ; sinon → coupé. L'écho d'un `PING` passe avant les autres
+* trames (§6.7) : une trame DATA encore en route peut arriver après lui, la
+* coupe reste conforme (§8.1).
+*
+* Coût : chemin d'erreur seulement — une entrée de `WeakMap` par session tant
+* que des flux attendent, un `PING` par aller-retour et par session.
+*
+* @param stream - flux dont la réponse est ÉCRITE (`finish` passé).
+*/
+function closeStreamAfterGrace(stream) {
+	if (stream.closed || stream.destroyed || stream.state.remoteClose) return;
+	const session = stream.session;
+	if (session === void 0) return;
+	let grace = graces.get(session);
+	if (grace === void 0) {
+		grace = new SessionGrace();
+		graces.set(session, grace);
+	}
+	if (grace.inFlight === null) {
+		grace.inFlight = [stream];
+		sendPing(session, grace);
+	} else if (grace.next === null) grace.next = [stream];
+	else grace.next.push(stream);
+}
+export { closeStreamAfterGrace };

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

@@ -0,0 +1,177 @@
+// nodefony/src/servers/receiveDeadline.ts
+/** Capacité de départ de l'anneau, et celle où il revient une fois vide. */
+const INITIAL_CAPACITY = 64;
+/**
+* Une échéance ABSOLUE pour des réceptions en cours, sans un minuteur par
+* réception : un seul balayage périodique pour toutes.
+*
+* ## Pourquoi
+*
+* `node:http2` ne borne pas la réception d'une requête : il n'a que des délais
+* d'INACTIVITÉ (`http2stream.setTimeout`, `http2session.setTimeout`), qu'un
+* client tient en vie avec un octet avant chaque échéance. `requestTimeout`,
+* la borne absolue anti « slow-loris », n'existe que pour HTTP/1.1.
+*
+* ## Le coût, et pourquoi cette forme
+*
+* C'est la forme que Node donne lui-même à `requestTimeout` : aucun minuteur
+* par requête, un contrôle périodique (`connectionsCheckingInterval`). Les
+* réceptions suivies vivent dans un ANNEAU — un tableau des éléments et un
+* `Int32Array` des tours d'entrée, indexés par un numéro de séquence :
+* - suivre = deux écritures ; libérer = une comparaison et une écriture. Ni
+*   minuteur, ni fermeture, ni lecture d'horloge (le temps se compte en TOURS),
+*   ni champ ajouté à l'élément suivi ;
+* - mesuré contre une `Map` (hachage d'identité de la clé) : ~26–32 ns par
+*   réception contre ~90–150 ns, de 1 à 10 000 réceptions simultanées.
+*
+* Toutes les entrées ont le même délai : l'ordre d'insertion EST l'ordre
+* d'échéance. Un tour avance la tête et s'arrête à la première entrée vivante
+* non échue — il ne coûte que ce qu'il expire ou saute.
+*
+* Contrepartie, bornée : une case libérée DERRIÈRE une entrée vivante attend
+* que la tête la dépasse, soit au plus un délai de réception — 12 octets par
+* réception commencée dans cette fenêtre. Sous charge, l'anneau garde sa
+* capacité d'un tour à l'autre (jamais rétréci puis recrû) ; il la rend au
+* premier tour sans réception nouvelle. Le minuteur unique est `unref`, et s'arrête au
+* même moment.
+*
+* ## Précision
+*
+* Une entrée expire entre `timeoutMs` et `timeoutMs + periodMs` après son
+* suivi — jamais AVANT le délai configuré.
+*
+* @typeParam T - l'élément suivi (un contexte de requête)
+*/
+var ReceiveDeadline = class {
+	#items = new Array(INITIAL_CAPACITY).fill(null);
+	#ticks = new Int32Array(INITIAL_CAPACITY);
+	#mask = 63;
+	/** Numéro de séquence de la plus ancienne case non balayée. */
+	#head = 0;
+	/** Numéro de séquence de la prochaine entrée. */
+	#tail = 0;
+	#tick = 0;
+	#timer = null;
+	#onExpire;
+	#periodMs;
+	/** Tours pleins qu'une entrée doit voir passer avant d'expirer. */
+	#ttl;
+	/**
+	* @param timeoutMs - le délai de réception (> 0)
+	* @param onExpire - appelé une fois par entrée échue, déjà retirée
+	* @param periodMs - la période du balayage, bornée par le délai (défaut 1 s)
+	* @throws RangeError si `timeoutMs` ou `periodMs` n'est pas un entier > 0
+	*/
+	constructor(timeoutMs, onExpire, periodMs = 1e3) {
+		if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) throw new RangeError(`délai de réception invalide : ${timeoutMs}`);
+		if (!Number.isInteger(periodMs) || periodMs <= 0) throw new RangeError(`période de balayage invalide : ${periodMs}`);
+		this.#onExpire = onExpire;
+		this.#periodMs = Math.min(periodMs, timeoutMs);
+		this.#ttl = Math.ceil(timeoutMs / this.#periodMs);
+	}
+	/** Cases occupées, libérées ou non, entre la tête et la queue. */
+	get size() {
+		return this.#tail - this.#head;
+	}
+	/** Capacité courante de l'anneau. */
+	get capacity() {
+		return this.#mask + 1;
+	}
+	/** Vrai tant que le balayage tourne. */
+	get running() {
+		return this.#timer !== null;
+	}
+	/**
+	* Suit une réception qui commence ; démarre le balayage s'il dormait.
+	*
+	* @param item - la réception
+	* @returns le numéro à rendre à {@link ReceiveDeadline.release}
+	*/
+	track(item) {
+		if (this.#tail - this.#head > this.#mask) this.#grow();
+		const seq = this.#tail++;
+		const index = seq & this.#mask;
+		this.#items[index] = item;
+		this.#ticks[index] = this.#tick;
+		if (this.#timer === null) {
+			this.#timer = setInterval(() => this.#sweep(), this.#periodMs);
+			this.#timer.unref();
+		}
+		return seq;
+	}
+	/**
+	* Cesse de suivre une réception terminée (reçue, refusée ou échue). Sans
+	* effet si la case a déjà été balayée ou réattribuée : l'identité de
+	* l'élément est vérifiée. Le balayage ne s'arrête pas ici mais au tour
+	* suivant s'il ne reste rien — jamais un minuteur armé puis désarmé par
+	* requête.
+	*
+	* @param seq - le numéro rendu par {@link ReceiveDeadline.track}
+	* @param item - la réception suivie
+	*/
+	release(seq, item) {
+		const index = seq & this.#mask;
+		if (this.#items[index] === item) this.#items[index] = null;
+	}
+	/** Arrête le balayage et oublie toutes les réceptions (arrêt du serveur). */
+	close() {
+		if (this.#timer !== null) {
+			clearInterval(this.#timer);
+			this.#timer = null;
+		}
+		this.#reset();
+	}
+	#sweep() {
+		const tick = ++this.#tick;
+		const items = this.#items;
+		const carried = this.#tail - this.#head;
+		while (this.#head < this.#tail) {
+			const index = this.#head & this.#mask;
+			const item = items[index] ?? null;
+			if (item !== null && tick - (this.#ticks[index] ?? 0) <= this.#ttl) break;
+			items[index] = null;
+			this.#head++;
+			if (item !== null) this.#onExpire(item);
+		}
+		if (this.#head !== this.#tail) return;
+		if (carried > 0) {
+			this.#head = 0;
+			this.#tail = 0;
+			return;
+		}
+		if (this.#timer !== null) {
+			clearInterval(this.#timer);
+			this.#timer = null;
+		}
+		this.#reset();
+	}
+	/**
+	* Anneau au repos ou fermé : numéros remis à zéro et capacité de départ
+	* rendue. Un numéro encore détenu par un appelant ne désigne plus son
+	* élément : `release` le reconnaît à l'identité.
+	*/
+	#reset() {
+		this.#head = 0;
+		this.#tail = 0;
+		if (this.#mask + 1 !== INITIAL_CAPACITY) {
+			this.#items = new Array(INITIAL_CAPACITY).fill(null);
+			this.#ticks = new Int32Array(INITIAL_CAPACITY);
+			this.#mask = 63;
+		} else this.#items.fill(null);
+	}
+	/** Double la capacité, les entrées gardant leur numéro de séquence. */
+	#grow() {
+		const capacity = (this.#mask + 1) * 2;
+		const mask = capacity - 1;
+		const items = new Array(capacity).fill(null);
+		const ticks = new Int32Array(capacity);
+		for (let seq = this.#head; seq < this.#tail; seq++) {
+			items[seq & mask] = this.#items[seq & this.#mask] ?? null;
+			ticks[seq & mask] = this.#ticks[seq & this.#mask] ?? 0;
+		}
+		this.#items = items;
+		this.#ticks = ticks;
+		this.#mask = mask;
+	}
+};
+export { ReceiveDeadline };

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

@@ -1,7 +1,60 @@
+import { refuseMalformedHandshake, refuseUpgrade } from "../proxy/forward.js";
 import { websocketHandshakeProblem } from "../proxy/rules.js";
-import { refuseUpgrade } from "../proxy/forward.js";
 import { STATUS_CODES } from "node:http";
+import { WebSocketServer } from "ws";
 // nodefony/src/servers/upgradeDispatch.ts
+/**
+* Sous-protocole choisi par handshake, entre {@link IUpgradeAdmission.selectSubprotocol}
+* et le rappel `handleProtocols` de `ws` — qui ne reçoit que la requête. Une
+* table faible plutôt qu'une variable « en cours » : un `verifyClient`
+* asynchrone sépare les deux instants, et deux handshakes s'y croiseraient.
+* Une entrée n'existe que pour un handshake qui a choisi.
+*/
+const chosenSubprotocols = /* @__PURE__ */ new WeakMap();
+/**
+* Fabrique l'option `handleProtocols` du serveur `ws` de Nodefony : le choix
+* retenu par l'admission ({@link IUpgradeAdmission.selectSubprotocol}) s'il y
+* en a un, sinon `fallback` (celle de la configuration), sinon le premier
+* offert — le défaut de `ws` 8, conservé pour tout contrôleur qui ne choisit
+* pas.
+*
+* @param fallback - l'option `handleProtocols` de la configuration, s'il y en a une
+* @returns le rappel à passer à `new WebSocketServer({ handleProtocols })`
+*/
+function createSubprotocolHandler(fallback) {
+	return (protocols, request) => {
+		const chosen = chosenSubprotocols.get(request);
+		if (chosen !== void 0) {
+			chosenSubprotocols.delete(request);
+			return chosen !== false && protocols.has(chosen) ? chosen : false;
+		}
+		if (fallback !== void 0) return fallback(protocols, request);
+		const first = protocols.values().next();
+		return first.done === true ? false : first.value;
+	};
+}
+/**
+* Construit le serveur `ws` de Nodefony à partir des options de la
+* configuration, en forçant ce que Nodefony gère — seul endroit où ces
+* options sont posées, pour le serveur clair comme pour le sécurisé :
+*
+* - `noServer` : l'upgrade passe d'abord par le proxy inverse, puis par
+*   {@link attachUpgradeDispatch} ;
+* - `clientTracking` : requis par `broadcast()` et le heartbeat ;
+* - `handleProtocols` : le sous-protocole CHOISI par le contrôleur
+*   ({@link createSubprotocolHandler}), celui de la configuration à défaut.
+*
+* @param options - options `ws` issues de la configuration du serveur WebSocket
+* @returns le serveur, sans écoute propre
+*/
+function createNodefonyWebSocketServer(options) {
+	return new WebSocketServer({
+		...options,
+		noServer: true,
+		clientTracking: true,
+		handleProtocols: createSubprotocolHandler(options.handleProtocols)
+	});
+}
 /** Défaut sans noyau : tout upgrade conforme est accepté puis émis en `connection`. */
 function acceptAll(wss) {
 	return (req, admission) => {
@@ -38,6 +91,9 @@ var UpgradeAdmission = class {
 		this.#onPendingError = () => socket.destroy();
 		socket.on("error", this.#onPendingError);
 	}
+	selectSubprotocol(protocol) {
+		if (!this.#settled) chosenSubprotocols.set(this.req, protocol);
+	}
 	#settle() {
 		if (this.#settled) return false;
 		this.#settled = true;
@@ -71,6 +127,7 @@ var UpgradeAdmission = class {
 	}
 	refuse(status, headers) {
 		if (!this.#settle()) return;
+		chosenSubprotocols.delete(this.req);
 		refuseUpgrade(this.socket, status, STATUS_CODES[status] ?? "Refused", headers);
 	}
 };
@@ -114,8 +171,9 @@ function attachUpgradeDispatch(server, wss, relay, refusal, admit = acceptAll(ws
 			refuseUpgrade(socket, status, STATUS_CODES[status] ?? "Refused");
 			return;
 		}
-		if (websocketHandshakeProblem(req.method, req.headers) !== null) {
-			refuseUpgrade(socket, 400, STATUS_CODES[400] ?? "Bad Request");
+		const problem = websocketHandshakeProblem(req.method, req.headers);
+		if (problem !== null) {
+			refuseMalformedHandshake(socket, problem);
 			return;
 		}
 		admit(req, new UpgradeAdmission(wss, req, socket, head));
@@ -125,4 +183,4 @@ function attachUpgradeDispatch(server, wss, relay, refusal, admit = acceptAll(ws
 		server.removeListener("upgrade", onUpgrade);
 	};
 }
-export { attachUpgradeDispatch };
+export { attachUpgradeDispatch, createNodefonyWebSocketServer, createSubprotocolHandler };

package/dist/types/index.d.ts

@@ -68,12 +68,19 @@ declare class Http extends Module<IHttpConfig> {
 }
 export default Http;
 export { defineHttpConfig, httpConfigJsonSchema, } from "./nodefony/config/defineModuleConfig.js";
+export { parseRequestTarget } from "./nodefony/src/context/http/urlFastPath.js";
+export { isContentlessStatus } from "./nodefony/src/context/http/Response.js";
+export type { ISplitTarget } from "./nodefony/src/context/http/urlFastPath.js";
 export { httpConfigSchema } from "./nodefony/config/config.js";
 export type { IHttpConfig, IHttpConfigInput, } from "./nodefony/interfaces/IHttpConfig.js";
 export { decideSend, readBackpressureOptions, type WsBackpressurePolicy, type WsSendDecision, type IWsBackpressureOptions, type IBackpressureSocket, type IBackpressureTarget, } from "./nodefony/src/context/websocket/wsBackpressure.js";
+export { admitFrame, frameRateRejectedTotal, readFrameRateBound, readFrameRateCloseAfter, FRAME_RATE_WINDOW_MS, type IFrameRateWindow, type IWsFrameRateOptions, } from "./nodefony/src/context/websocket/wsFrameRate.js";
 export { isWebsocketContext } from "./nodefony/src/context/websocket/isWebsocketContext.js";
 export { REQUEST_TRACE_CHANNEL } from "./nodefony/src/context/requestTrace.js";
+export { rpcCorsLists } from "./nodefony/src/grpc/cors.js";
+export type { IRpcCorsLists } from "./nodefony/src/grpc/cors.js";
 export type { IRequestTrace, RequestTraceProtocol, } from "./nodefony/interfaces/IRequestTrace.js";
+export type { IRpcCall, IRpcOutcome, RpcSystem, } from "./nodefony/interfaces/IRpcCall.js";
 export { compileDomainPattern, compileDomainPatterns, compileTrustedHosts, isDomainAllowed, } from "./nodefony/src/context/domainMatcher.js";
 export type { DomainPattern, ITrustedHostsConfig, } from "./nodefony/src/context/domainMatcher.js";
 export { MemoryRateLimitStore } from "./nodefony/src/rateLimit/MemoryRateLimitStore.js";
@@ -81,6 +88,8 @@ export type { IRateLimitStore, IRateLimitOptions, RateLimitVerdict, } from "./no
 export { Context, Session, SessionsService, HttpError, HttpKernel, Response, Http2Response, Response as HttpResponse, wsResponse, wsResponse as WebsocketResponse, Cookie, HttpContext, WebsocketContext, HttpRequest, Http2Request, DefaultErrorRenderer, DefaultRequestLogger, JsonAuditLogger, PrettyRequestLogger, Profiler, };
 export { SseStream, openSseStream, acceptsEventStream, SSE_HEARTBEAT_MS, } from "./nodefony/src/context/http/SseStream.js";
 export type { ISseStreamOptions, ISseSendOptions, } from "./nodefony/src/context/http/SseStream.js";
+export { openByteStream } from "./nodefony/src/context/http/ByteStream.js";
+export type { ByteStreamEndReason, ByteStreamSource, IByteStreamOptions, IByteStreamResult, } from "./nodefony/src/context/http/ByteStream.js";
 export { schemaMismatchOf, type SchemaMismatchConfidence, } from "./nodefony/service/error-renderer.js";
 export { toValidationFields, type IValidationField, } from "./nodefony/service/error-renderer.js";
 export type { ProfileEntry, ProfileSummary, ProfilePhase, ProfileQuery, ProfileSecurity, IProfileBatch, IProfilerReader, } from "./nodefony/src/profiler/Profiler.js";
@@ -102,8 +111,8 @@ export type { IHttpResponse, IWebsocketResponse, } from "./nodefony/interfaces/I
 export type { IHttpKernel } from "./nodefony/interfaces/IHttpKernel.js";
 export type { IResolvedRoute, IRouteResolver, IRequestRouter, } from "./nodefony/interfaces/IRouting.js";
 export type { ISecurityZone, IFirewallGate, } from "./nodefony/interfaces/ISecurity.js";
-export type { IUploadedFile, IUploadService, IParsedUploadFile, IUploadOptions, } from "./nodefony/interfaces/IUpload.js";
-export type { IErrorRenderer, IErrorHttpResult, IErrorWebsocketResult, } from "./nodefony/interfaces/IErrorRenderer.js";
+export type { IUploadedFile, IUploadService, IParsedUploadFile, IUploadOptions, IRouteUploadOptions, } from "./nodefony/interfaces/IUpload.js";
+export type { IErrorRenderer, IErrorHttpResult, IErrorWebsocketResult, IErrorDescription, } from "./nodefony/interfaces/IErrorRenderer.js";
 export type { IRequestLogger, IRequestLogEntry, } from "./nodefony/interfaces/IRequestLogger.js";
 export type { AuditLogEntry, AuditErrorEntry, JsonAuditLoggerOptions, } from "./nodefony/service/audit-logger.js";
 export type { ContextType, httpRequest, httpResponse, ProtocolType, } from "./nodefony/service/http-kernel.js";