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

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

@@ -1,8 +1,8 @@
 import HttpError from "../../errors/httpError.js";
-import { escapeRegExp, extend } from "nodefony";
+import { escapeRegExp } from "nodefony";
 import QS from "qs";
 import xml2js from "xml2js";
-//#region nodefony/src/context/http/parser.ts
+// nodefony/src/context/http/parser.ts
 var Parser = class {
 	request;
 	chunks;
@@ -73,6 +73,27 @@ var Parser = class {
 		return this;
 	}
 };
+/**
+* Corps d'un type que le framework ne décode pas : livré TEL QU'IL EST REÇU,
+* jamais remplacé par un objet vide qui mentirait.
+*
+* - `text/*` → une chaîne, décodée au `charset` du `Content-Type` (UTF-8 par
+*   défaut) — comme une trame texte RFC 6455 ;
+* - tout autre type, et un corps sans `Content-Type` (RFC 9110 §8.3 : supposé
+*   `application/octet-stream`) → les OCTETS : le `Buffer` déjà assemblé dans
+*   `request.data`, sans copie — donc un `Uint8Array`, le type d'octets que
+*   la socket livrera aussi (#618). Un même schéma passe par les deux portes.
+*
+* Un corps VIDE laisse `body` tel quel : une requête sans charge ne change pas.
+*/
+var ParserRaw = class extends Parser {
+	async parse() {
+		await super.parse();
+		const data = this.request.data;
+		if (data.length > 0) this.request.body = this.request.contentType?.startsWith("text/") ? data.toString(this.request.charset) : data;
+		return this;
+	}
+};
 var ParserQs = class extends Parser {
 	parserOptions;
 	charset = "utf8";
@@ -83,8 +104,7 @@ var ParserQs = class extends Parser {
 	}
 	async parse() {
 		await super.parse();
-		this.request.queryPost = QS.parse(this.request.data.toString(this.charset), this.parserOptions);
-		this.request.query = extend({}, this.request.query, this.request.queryPost);
+		this.request.body = QS.parse(this.request.data.toString(this.charset), this.parserOptions);
 		this.request.context.requestEnded = true;
 		return this;
 	}
@@ -102,7 +122,7 @@ var ParserXml = class extends Parser {
 		return new Promise((resolve, reject) => {
 			this.xmlParser.parseString(this.request.data.toString(this.charset), (err, result) => {
 				if (err) return reject(err);
-				this.request.queryPost = result;
+				this.request.body = result;
 				this.request.context.requestEnded = true;
 				return resolve(this);
 			});
@@ -110,7 +130,14 @@ var ParserXml = class extends Parser {
 	}
 };
 /**
-* Parse un corps `application/json` (ou `*+json`) en objet → `queryPost`
+* Vrai pour un objet ou un tableau JSON — ce que `body` peut porter.
+* Un tableau passe : `@Body()` le rend tel quel (envoi en lot).
+*/
+function isJsonContainer(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Parse un corps `application/json` (ou `*+json`) en objet → `body`
 * (source lue par le décorateur `@Body`). Reprend le rôle de l'ancien plugin
 * `json` de formidable, supprimé avec le passage à busboy (multipart seul).
 * Lenient : un corps JSON malformé est ignoré (pas de throw — `parse()` est
@@ -127,8 +154,8 @@ var ParserJson = class extends Parser {
 		await super.parse();
 		const text = this.request.data.toString(this.charset).trim();
 		if (text) try {
-			this.request.queryPost = JSON.parse(text);
-			this.request.query = extend({}, this.request.query, this.request.queryPost);
+			const parsed = JSON.parse(text);
+			if (isJsonContainer(parsed)) this.request.body = parsed;
 		} catch {}
 		this.request.context.requestEnded = true;
 		return this;
@@ -183,5 +210,4 @@ const acceptParser = function(acc) {
 		return ACCEPT_ANY;
 	}
 };
-//#endregion
-export { Parser, ParserJson, ParserQs, ParserXml, acceptParser };
+export { Parser, ParserJson, ParserQs, ParserRaw, ParserXml, acceptParser };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/context/http/urlFastPath.ts
+// nodefony/src/context/http/urlFastPath.ts
 const PATH_SAFE = /* @__PURE__ */ new Uint8Array(128);
 const SEARCH_SAFE = /* @__PURE__ */ new Uint8Array(128);
 const HOST_SAFE = /* @__PURE__ */ new Uint8Array(128);
@@ -123,5 +123,4 @@ function isDigitsFrom(s, from) {
 	}
 	return true;
 }
-//#endregion
 export { isCanonicalAuthority, splitTarget };

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

@@ -1,5 +1,6 @@
+import { requestAuthority } from "../transport.js";
 import HttpRequest from "../http/Request.js";
-//#region nodefony/src/context/http2/Request.ts
+// nodefony/src/context/http2/Request.ts
 var Http2Request = class extends HttpRequest {
 	request;
 	constructor(request, context) {
@@ -7,8 +8,9 @@ var Http2Request = class extends HttpRequest {
 		this.context = context;
 		this.request = request;
 	}
+	/** `:authority`, sinon `Host` — cf `requestAuthority` (RFC 9113 §8.3.1). */
 	getHost() {
-		return this.headers[":authority"];
+		return requestAuthority(this.request.headers);
 	}
 	getUserAgent() {
 		return this.headers["user-agent"];
@@ -19,11 +21,5 @@ var Http2Request = class extends HttpRequest {
 	getRawTarget() {
 		return this.headers[":path"];
 	}
-	resolveScheme() {
-		if (this.forwarded?.proto) return this.forwarded.proto;
-		if (this.headers[":scheme"] === "https") return "https";
-		return "http";
-	}
 };
-//#endregion
 export { Http2Request as default };

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

@@ -2,8 +2,13 @@ import HttpResponse from "../http/Response.js";
 import { thenMaybe } from "nodefony";
 import http from "node:http";
 import http2 from "node:http2";
-//#region nodefony/src/context/http2/Response.ts
+// nodefony/src/context/http2/Response.ts
 const HTTP2_HEADER_STATUS = http2.constants.HTTP2_HEADER_STATUS;
+/** Réponse Node déjà libérée : aucun en-tête posé à reprendre. */
+const emptyHeaders = {
+	getHeaderNames: () => [],
+	getHeader: () => void 0
+};
 /**
 * Compose les en-têtes d'une réponse HTTP/2 : ceux posés sur la réponse, puis
 * ceux passés à `writeHead`, qui gagnent.
@@ -14,14 +19,19 @@ const HTTP2_HEADER_STATUS = http2.constants.HTTP2_HEADER_STATUS;
 * (`ERR_HTTP2_HEADER_SINGLE_VALUE`), soit une 500 sur tout média servi en
 * HTTP/2. HTTP/2 n'a de toute façon que des noms en minuscules (RFC 9113 §8.2.1).
 *
+* Les en-têtes posés se lisent nom par nom (`getHeaderNames`, déjà en
+* minuscules) : `getHeaders()` les recopiait d'abord dans un objet sans
+* prototype, avant cette fusion — 3,8 µs par réponse pour 12 en-têtes,
+* contre 1,1 µs en une passe.
+*
 * @param statusMessage - message de statut, recopié en `x-status-message`
-* @param current - en-têtes déjà posés sur la réponse
+* @param current - la réponse Node qui porte les en-têtes déjà posés
 * @param extra - en-têtes passés à `writeHead` (objet, ou liste plate clé/valeur)
 * @returns les en-têtes à transmettre à `respond()`
 */
 function mergeResponseHeaders(statusMessage, current, extra) {
 	const merged = { "x-status-message": statusMessage };
-	for (const key in current) merged[key.toLowerCase()] = current[key];
+	for (const name of current.getHeaderNames()) merged[name] = current.getHeader(name);
 	if (Array.isArray(extra)) for (let i = 0; i + 1 < extra.length; i += 2) merged[String(extra[i]).toLowerCase()] = extra[i + 1];
 	else if (extra) for (const key in extra) {
 		const value = extra[key];
@@ -58,7 +68,7 @@ var Http2Response = class extends HttpResponse {
 				this.statusMessage = this.getStatusMessage();
 				this.setLength();
 				this.ensureContentTypeHeader();
-				this.headers = mergeResponseHeaders(this.statusMessage, this.getHeaders(), headers);
+				this.headers = mergeResponseHeaders(this.statusMessage, this.response ?? emptyHeaders, headers);
 				this.headers[HTTP2_HEADER_STATUS] = this.statusCode;
 				const requestId = this.context.requestId;
 				if (requestId) this.headers["x-request-id"] = requestId;
@@ -69,9 +79,9 @@ var Http2Response = class extends HttpResponse {
 		} else return super.writeHead(statusCode, headers);
 	}
 	/**
-	* Écrit le corps sur le flux HTTP/2. Synchrone pour une redirection, un flux
-	* fermé ou le repli HTTP/1 ; une promesse quand le corps est écrit sur le
-	* flux, réglée par le rappel d'écriture (#505).
+	* Écrit le corps sur le flux HTTP/2 et, pour une réponse unique, le termine
+	* d'un seul `end(corps)`. Synchrone, sauf en streaming (`flush()`) : une
+	* promesse réglée par le rappel d'écriture, la contre-pression (#505).
 	*
 	* @returns la réponse, ou sa promesse.
 	*/
@@ -87,6 +97,10 @@ var Http2Response = class extends HttpResponse {
 			return this;
 		}
 		if (chunk) this.setBody(chunk);
+		if (!_flush && !this.flushing) {
+			stream.end(this.payload, this.payloadEncoding);
+			return this;
+		}
 		return new Promise((resolve, reject) => {
 			stream.write(this.payload, this.payloadEncoding, (error) => {
 				if (error) return reject(error);
@@ -102,7 +116,7 @@ var Http2Response = class extends HttpResponse {
 	*/
 	end(chunk, encoding) {
 		if (this.stream) {
-			if (this.stream.destroyed || this.stream.closed) return this.stream;
+			if (this.stream.writableEnded || this.stream.destroyed || this.stream.closed) return this.stream;
 			return this.stream.end(chunk, encoding || this.encoding);
 		}
 		return super.end(chunk, encoding);
@@ -121,5 +135,4 @@ var Http2Response = class extends HttpResponse {
 		};
 	}
 };
-//#endregion
 export { Http2Response as default, mergeResponseHeaders };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/context/metaData.ts
+// nodefony/src/context/metaData.ts
 /**
 * Assemble l'enveloppe `metaData` d'une requête EN PLACE (builder monomorphe) :
 * met à jour les champs de `target.nodefony` dans un ordre fixe → V8 garde une
@@ -43,5 +43,4 @@ function buildMetaData(target, src, override) {
 	}
 	return target;
 }
-//#endregion
 export { buildMetaData };

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

@@ -1,4 +1,4 @@
-//#region nodefony/src/context/requestId.ts
+// nodefony/src/context/requestId.ts
 /**
 * Validation de l'identifiant de corrélation `X-Request-Id` fourni par le
 * client, avant qu'il ne soit adopté comme `Context.requestId`.
@@ -37,5 +37,4 @@ function sanitizeRequestId(raw) {
 	if (!raw || raw.length > 128) return null;
 	return SAFE_REQUEST_ID.test(raw) ? raw : null;
 }
-//#endregion
 export { MAX_REQUEST_ID_LENGTH, sanitizeRequestId };

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

@@ -0,0 +1,26 @@
+import http2 from "node:http2";
+// nodefony/src/context/responseEnded.ts
+/**
+* La réponse a-t-elle été TERMINÉE par le serveur ? Règle UNIQUE, pour HTTP/1.1
+* comme pour HTTP/2 — l'écouteur `close` du noyau (client parti → 499) et le
+* timeout par flux de `HttpContext` l'appellent tous deux.
+*
+* Sous HTTP/2, la réponse Nodefony écrit et termine le FLUX
+* (`stream.respond`/`stream.end`), jamais la réponse de compatibilité : son
+* `writableEnded` reste à `false` alors que le client a tout reçu. Mais le
+* flux seul ne suffit pas non plus : un flux ANNULÉ par le pair (RST_STREAM
+* avant la fin) a LUI AUSSI `writableEnded === true`, Node terminant le côté
+* écriture en le détruisant. `aborted` sépare la fin posée par le serveur de la
+* coupure du client — même sémantique que `writableEnded` en HTTP/1.1.
+*
+* @param response - la réponse Node de la requête
+* @returns `true` si le serveur a terminé la réponse (ou son flux HTTP/2) ;
+*   `false` s'il ne l'a pas terminée, client parti compris
+*/
+function responseEnded(response) {
+	if (response.writableEnded) return true;
+	if (!(response instanceof http2.Http2ServerResponse)) return false;
+	const stream = response.stream;
+	return stream.writableEnded && !stream.aborted;
+}
+export { responseEnded };

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

@@ -0,0 +1,45 @@
+// nodefony/src/context/transport.ts
+/**
+* Famille du protocole traité par un contexte, déduite du serveur qui l'a
+* reçu. Règle UNIQUE : `Context` la pose à la construction.
+*
+* @param serverType - identité du serveur (`http`, `https`, `ws`, `wss`)
+* @returns `"websocket"` pour `ws`/`wss`, `"http"` sinon
+*/
+function protocolNameOf(serverType) {
+	return serverType === "ws" || serverType === "wss" ? "websocket" : "http";
+}
+/**
+* Protocole du saut qui a porté cette requête jusqu'au processus, au sens du
+* registre IANA des identifiants ALPN. Règle UNIQUE : `HttpContext` la lit pour
+* choisir ses classes de requête et de réponse.
+*
+* La valeur se CONSTATE sur la requête, elle ne se déduit pas du serveur : un
+* même serveur TLS reçoit HTTP/1.1 et h2 (`allowHTTP1`). Pour h2, c'est la
+* session de Node qui tranche — `Http2Session.alpnProtocol` vaut `"h2c"` sur
+* une session en clair, l'ALPN négocié (`"h2"`) sur une session TLS.
+*
+* @param request - la requête Node reçue par le serveur
+* @returns `"http/1.1"`, `"h2"` ou `"h2c"`
+*/
+function alpnProtocolOf(request) {
+	if (request.httpVersionMajor !== 2) return "http/1.1";
+	return (request.stream?.session)?.alpnProtocol === "h2c" ? "h2c" : "h2";
+}
+/**
+* Autorité (hôte et port) d'une requête, HTTP/1.1 comme HTTP/2. Règle UNIQUE
+* des lecteurs du serveur.
+*
+* `:authority` d'abord, puis `Host` (RFC 9113 §8.3.1). Le repli n'est pas un
+* confort : un intermédiaire qui convertit une requête HTTP/1.1 de forme origine
+* (`GET /chemin`) en HTTP/2 ne DOIT PAS fabriquer `:authority` — il garde
+* `Host`. C'est ce que fait HAProxy `proto h2` vers un port h2c : sans ce repli,
+* l'hôte est introuvable et la requête part en 421.
+*
+* @param headers - en-têtes de la requête Node (`IncomingMessage` ou `Http2ServerRequest`).
+* @returns l'autorité, ou `undefined` si la requête n'en porte aucune.
+*/
+function requestAuthority(headers) {
+	return headers[":authority"] ?? headers.host;
+}
+export { alpnProtocolOf, protocolNameOf, requestAuthority };

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

@@ -1,5 +1,5 @@
 import { BlockList, isIPv4, isIPv6 } from "node:net";
-//#region nodefony/src/context/trustProxy.ts
+// nodefony/src/context/trustProxy.ts
 const PRESETS = {
 	loopback: [[
 		"127.0.0.0",
@@ -164,5 +164,4 @@ function extractClientIp(xff, socketAddress, checker) {
 	}
 	return resolveFromRight(s.split(",").map((part) => part.trim()).filter(Boolean), socketAddress, checker);
 }
-//#endregion
 export { buildTrustProxy, extractClientIp, resolveFromRight };

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

@@ -1,9 +1,10 @@
 import Cookie from "../../cookies/cookie.js";
 import { decideSend, readBackpressureOptions } from "./wsBackpressure.js";
 import { toWsCloseReason } from "./wsCloseReason.js";
+import { RequestContext } from "nodefony";
 import http from "node:http";
 import Ws from "ws";
-//#region nodefony/src/context/websocket/Response.ts
+// nodefony/src/context/websocket/Response.ts
 /**
 * Codes d'erreur d'écriture « le client est PARTI » : reload de page, onglet
 * fermé, HMR — la socket TCP est morte côté client pendant qu'une frame était
@@ -70,7 +71,11 @@ var WebsocketResponse = class {
 		const payload = data ?? this.body;
 		if (payload == null) throw new Error("no data");
 		return new Promise((resolve, reject) => {
-			if (!this.connection || this.connection.readyState !== Ws.OPEN) return reject(/* @__PURE__ */ new Error("WebSocket not open"));
+			if (!this.connection || this.connection.readyState === Ws.CONNECTING) return reject(/* @__PURE__ */ new Error("WebSocket not open"));
+			if (this.connection.readyState !== Ws.OPEN) {
+				this.log("WS send: client déjà déconnecté — frame perdue", "DEBUG");
+				return resolve(this);
+			}
 			const { max, policy, closeAfterDrops } = readBackpressureOptions(this.context.server);
 			const decision = decideSend(this.connection, max, policy, closeAfterDrops);
 			if (decision !== "send") {
@@ -121,7 +126,7 @@ var WebsocketResponse = class {
 	setBody(ele, encoding) {
 		if (typeof ele === "string") this.body = Buffer.from(ele, encoding ?? this.encoding);
 		else if (ele instanceof ArrayBuffer || ele instanceof SharedArrayBuffer) this.body = Buffer.from(ele);
-		else if ("buffer" in ele && ele.buffer instanceof ArrayBuffer) this.body = Buffer.from(ele.buffer);
+		else if (ArrayBuffer.isView(ele)) this.body = Buffer.from(ele.buffer, ele.byteOffset, ele.byteLength);
 		return this.body;
 	}
 	drop(reasonCode, description) {
@@ -156,6 +161,14 @@ var WebsocketResponse = class {
 			if (isNaN(status)) status = 500;
 		}
 		if (!status) status = 500;
+		const sink = RequestContext.get()?.renderSink;
+		if (sink) {
+			sink.status = status;
+			return {
+				code: status,
+				message: message ?? ""
+			};
+		}
 		this.statusCode = status;
 		if (!message) message = WS_CLOSE_DESCRIPTIONS[this.statusCode] ?? http.STATUS_CODES[this.statusCode];
 		this.statusMessage = message ?? "";
@@ -167,14 +180,38 @@ var WebsocketResponse = class {
 	clean() {
 		this.connection = null;
 		this.body = null;
+		this.handshakeHeaders = null;
 	}
 	setEncoding(encoding) {
 		return this.encoding = encoding;
 	}
-	setHeader() {
+	/**
+	* En-têtes de la réponse au handshake, retenus tant que la socket n'est pas
+	* acceptée : ils ne partent que dans un REFUS (`refuseHandshake`) — le `101`
+	* de `ws` ne les porte pas. `null` tant que personne n'en pose (le cas
+	* nominal : aucune allocation).
+	*/
+	handshakeHeaders = null;
+	/**
+	* Retient un en-tête du handshake (cf {@link handshakeHeaders}) ; sans effet
+	* une fois la socket ouverte, où il n'y a plus de réponse HTTP.
+	*
+	* @param name - nom de l'en-tête
+	* @param value - valeur
+	* @returns toujours `true`
+	*/
+	setHeader(name, value) {
+		if (this.connection !== null) return true;
+		this.handshakeHeaders ??= {};
+		this.handshakeHeaders[name] = typeof value === "object" ? value.join(", ") : value;
 		return true;
 	}
-	setHeaders() {
+	setHeaders(obj) {
+		if (this.connection !== null) return true;
+		for (const name of Object.keys(obj)) {
+			const value = obj[name];
+			if (value !== void 0) this.setHeader(name, value);
+		}
 		return true;
 	}
 	addCookie(cookie) {
@@ -184,5 +221,4 @@ var WebsocketResponse = class {
 	setCookies() {}
 	setCookie(_cookie) {}
 };
-//#endregion
 export { WebsocketResponse as default, isPeerGoneError };

package/dist/nodefony/src/context/websocket/WebsocketContext.js

@@ -5,11 +5,12 @@ import WebsocketResponse from "./Response.js";
 import { sanitizeRequestId } from "../requestId.js";
 import { FrameProfile } from "../../profiler/FrameProfile.js";
 import { formatWsLogContent } from "./wsLogContent.js";
+import { parseWebsocketUrl } from "./websocketUrl.js";
 import { RequestContext, logColor } from "nodefony";
-import Ws from "ws";
 import { AsyncResource } from "node:async_hooks";
 import url, { URL } from "node:url";
-//#region nodefony/src/context/websocket/WebsocketContext.ts
+import Ws from "ws";
+// nodefony/src/context/websocket/WebsocketContext.ts
 /**
 * Appelle l'action résolue et rend TOUJOURS une promesse.
 *
@@ -53,6 +54,51 @@ function toWsCloseCode(code) {
 	return 1011;
 }
 /**
+* Statut HTTP d'un handshake REFUSÉ avant le `101` (RFC 6455 §4.2.2) — la
+* réciproque de {@link toWsCloseCode} : une erreur levée pendant la décision
+* porte un code HTTP (pare-feu, garde) ou, par héritage, un code de fermeture
+* WS (origine `1008`, protocole `1002`, introuvable `4004`) ; le client qui
+* lit le statut doit y reconnaître le même sens.
+*
+* @param code - code porté par l'erreur
+* @returns un statut HTTP 4xx/5xx
+*/
+function toHandshakeStatus(code) {
+	if (typeof code !== "number" || !Number.isInteger(code)) return 500;
+	if (code >= 400 && code <= 599) return code;
+	switch (code) {
+		case 1002:
+		case 1003:
+		case 1007: return 400;
+		case 1008:
+		case 4003: return 403;
+		case 4001: return 401;
+		case 1009: return 413;
+		case 1013: return 503;
+		case 4004: return 404;
+		default: return 500;
+	}
+}
+/**
+* Statut HTTP que reçoit le client d'un handshake refusé — ou `null` si la
+* connexion était déjà acceptée.
+*
+* La ligne de journal d'un refus s'écrit AVANT `refuseHandshake` : sans ce
+* calcul, elle affichait le code de fermeture par défaut (`1000`) en ERROR,
+* pour un `400` que le client reçoit. Même conversion que le refus
+* ({@link toHandshakeStatus}), donc même chiffre. Chemin d'ERREUR seulement :
+* 1 comparaison et 1 `typeof`, aucune allocation.
+*
+* @param context - le contexte WS de la ligne
+* @param error - l'erreur qui a interrompu le handshake
+* @returns le statut HTTP du refus, ou `null` après l'acceptation
+*/
+function handshakeRefusalStatus(context, error) {
+	if (context.webSocketState !== "handshake") return null;
+	const code = error.code;
+	return toHandshakeStatus(typeof code === "number" ? code : void 0);
+}
+/**
 * Drapeau « logger le CONTENU des messages WS » — résolu **une seule fois** au
 * premier message (kernel présent). `true` hors production : le Suivi de requête
 * (Studio) affiche alors les frames RECEIVE/SEND/BROADCAST. En prod → `false` →
@@ -67,16 +113,21 @@ var WebsocketContext = class extends Context {
 	rejected = false;
 	teardownWired = false;
 	connection = null;
+	/**
+	* Le verdict du handshake encore à rendre : posé par le noyau tant que le
+	* pipeline décide (pare-feu, garde de l'action), `null` dès que la socket
+	* est acceptée ou refusée. Tant qu'il est là, AUCUN `101` n'est parti.
+	*/
+	admission = null;
 	origin;
 	proxy = null;
 	forwarded = null;
 	wsUrl = null;
-	queryGet = {};
-	queryRequest = {};
+	query = {};
 	wsPath = "";
 	#frameSeq = 0;
-	constructor(scope, req, ws, type) {
-		super(scope, type);
+	constructor(scope, req, ws, serverType) {
+		super(scope, serverType);
 		this.webSocketState = "handshake";
 		this.request = req;
 		this.connection = ws;
@@ -88,20 +139,16 @@ var WebsocketContext = class extends Context {
 		if (checker && checker.isTrusted(socketAddress) && hasForwardingHeaders(req.headers)) this.forwarded = resolveForwarded(req.headers, socketAddress, checker);
 		this.remoteAddress = this.getRemoteAddress();
 		this.acceptedProtocol = req.headers["sec-websocket-protocol"];
-		this.scheme = type === "websocket-secure" ? "wss" : "ws";
+		this.scheme = serverType === "wss" ? "wss" : "ws";
 		const incomingId = sanitizeRequestId(req.headers["x-request-id"]);
 		if (incomingId) this.requestId = incomingId;
-		const host = req.headers.host ?? "localhost";
-		const rawUrl = req.url ?? "/";
-		this.wsUrl = new URL(`${this.scheme}://${host}${rawUrl}`);
-		this.queryGet = Object.fromEntries(this.wsUrl.searchParams.entries());
-		this.queryRequest = { ...this.queryGet };
+		this.wsUrl = parseWebsocketUrl(this.scheme, req.headers.host, req.url);
+		this.query = Object.fromEntries(this.wsUrl.searchParams.entries());
 		this.wsPath = this.wsUrl.pathname + this.wsUrl.search;
 		this.url = url.format(this.wsUrl);
-		this.port = parseInt(this.wsUrl.port, 10) || (type === "websocket-secure" ? 443 : 80);
+		this.port = parseInt(this.wsUrl.port, 10) || (serverType === "wss" ? 443 : 80);
 		this.request.url = this.wsUrl;
-		this.request.queryGet = this.queryGet;
-		this.request.query = this.queryRequest;
+		this.request.query = this.query;
 		this.request.path = this.wsPath;
 		try {
 			this.originUrl = new URL(this.origin);
@@ -142,6 +189,34 @@ var WebsocketContext = class extends Context {
 			return;
 		}
 	}
+	/**
+	* Rattache la socket que le handshake vient d'ouvrir (`101` envoyé) : le
+	* contexte a été construit et jugé AVANT, sans elle.
+	*
+	* @param ws - la socket acceptée
+	*/
+	acceptConnection(ws) {
+		this.admission = null;
+		this.connection = ws;
+		this.response?.setConnection(ws);
+	}
+	/**
+	* Refuse le handshake par un statut HTTP, avant tout `101` (RFC 6455
+	* §4.2.2) — avec les en-têtes posés pendant la décision (`WWW-Authenticate`
+	* du pare-feu, `Retry-After`).
+	*
+	* @param status - statut HTTP du refus
+	* @returns `false` si le verdict était déjà rendu (rien n'est écrit)
+	*/
+	refuseHandshake(status) {
+		const admission = this.admission;
+		if (admission === null) return false;
+		this.admission = null;
+		this.rejected = true;
+		this.webSocketState = "error";
+		admission.refuse(status, this.response?.handshakeHeaders ?? null);
+		return true;
+	}
 	async connect() {
 		if (!this.response || !this.request || !this.connection) throw new Error("Nodefony Websocket Bad request/response/connection");
 		if (this.rejected) throw new Error("Nodefony Websocket rejected");
@@ -338,12 +413,12 @@ var WebsocketContext = class extends Context {
 	}
 	onClose(code, reason) {
 		const description = reason.toString();
-		this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ORIGIN")} : ${this.originUrl?.host} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("Description")} : ${description}`, "INFO", `${this.type} ${logColor.magenta(code)} CLOSE ${this.method}`);
+		this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ORIGIN")} : ${this.originUrl?.host} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("Description")} : ${description}`, "INFO", `${this.serverType} ${logColor.magenta(code)} CLOSE ${this.method}`);
 		if (this.connection?.readyState !== Ws.CLOSED) {
 			try {
 				this.response?.drop(code, description);
 			} catch (e) {
-				this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ORIGIN")} : ${this.originUrl?.host} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("error")} : ${e.message}`, "ERROR", `${this.type} CLOSE ${logColor.red(this.method ?? "")}`);
+				this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ORIGIN")} : ${this.originUrl?.host} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("error")} : ${e.message}`, "ERROR", `${this.serverType} CLOSE ${logColor.red(this.method ?? "")}`);
 			}
 			this.fire("onClose", code, description, this.connection);
 		} else this.fire("onClose", code, description, this.connection);
@@ -360,7 +435,7 @@ var WebsocketContext = class extends Context {
 	*/
 	onConnectionError(error) {
 		this.webSocketState = "error";
-		this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("error")} : ${error.message}`, "ERROR", `${this.type} ${logColor.red("SOCKET ERROR")} ${this.method}`);
+		this.log(`${logColor.cyan("URL")} : ${this.url}  ${logColor.cyan("FROM")} : ${this.remoteAddress} ${logColor.cyan("ID")} : ${this.requestId} ${logColor.cyan("error")} : ${error.message}`, "ERROR", `${this.serverType} ${logColor.red("SOCKET ERROR")} ${this.method}`);
 		this.fire("onError", error, this);
 	}
 	setScheme() {
@@ -418,5 +493,4 @@ var WebsocketContext = class extends Context {
 		this.rejected = true;
 	}
 };
-//#endregion
-export { WebsocketContext as default, toWsCloseCode };
+export { WebsocketContext as default, handshakeRefusalStatus, toHandshakeStatus, toWsCloseCode };

package/dist/nodefony/src/context/websocket/isWebsocketContext.js

@@ -0,0 +1,17 @@
+// nodefony/src/context/websocket/isWebsocketContext.ts
+/**
+* Dit si un contexte sert une connexion WebSocket — la garde qui rétrécit
+* `ContextType` à `WebsocketContext` sans conversion.
+*
+* Elle lit la famille (`type`) posée à la construction du contexte, jamais
+* `instanceof` : deux copies installées de `@nodefony/http` font échouer
+* `instanceof` en silence, quand ce champ dit vrai pour les deux. Deux
+* Une comparaison de chaînes, aucune allocation.
+*
+* @param context - le contexte à éprouver.
+* @returns `true` si le contexte traite une connexion WebSocket (`ws` ou `wss`).
+*/
+function isWebsocketContext(context) {
+	return context.type === "websocket";
+}
+export { isWebsocketContext };

package/dist/nodefony/src/context/websocket/websocketUrl.js

@@ -0,0 +1,20 @@
+// nodefony/src/context/websocket/websocketUrl.ts
+/**
+* URL d'une requête d'upgrade WebSocket, telle que le pipeline la lit.
+*
+* Seule construction : le contexte WebSocket en tire son chemin et sa requête,
+* et le contrôle d'avant `101` en tire le chemin qu'il confronte aux routes.
+* Deux constructions divergeraient — `//a/b` lu comme un chemin d'un côté, comme
+* un hôte de l'autre — et une route acceptée par l'une serait refusée par
+* l'autre.
+*
+* @param scheme - `ws` ou `wss`
+* @param host - en-tête `Host` de la requête (`localhost` s'il manque)
+* @param rawUrl - cible brute de la requête (`/` si elle manque)
+* @returns l'URL analysée
+* @throws TypeError si l'hôte ou la cible ne forment pas une URL
+*/
+function parseWebsocketUrl(scheme, host, rawUrl) {
+	return new URL(`${scheme}://${host ?? "localhost"}${rawUrl ?? "/"}`);
+}
+export { parseWebsocketUrl };

package/dist/nodefony/src/context/websocket/wsBackpressure.js

@@ -1,4 +1,4 @@
-//#region nodefony/src/context/websocket/wsBackpressure.ts
+// nodefony/src/context/websocket/wsBackpressure.ts
 /**
 * Relit le seuil + la politique depuis les options du `WebSocketServer`.
 *
@@ -52,5 +52,4 @@ const decideSend = (ws, max, policy, closeAfterDrops = 0) => {
 	}
 	return "drop";
 };
-//#endregion
 export { decideSend, readBackpressureOptions };