@nodefony/http 10.0.0-alpha.9 → 10.0.0-beta.2

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

@@ -1,5 +1,5 @@
 import Cookie from "../../cookies/cookie.js";
-import { typeOf } from "nodefony";
+import { thenMaybe, typeOf } from "nodefony";
 import http from "node:http";
 import mime from "mime-types";
 //#region nodefony/src/context/http/Response.ts
@@ -14,12 +14,30 @@ const REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
 	307,
 	308
 ]);
-const NO_CONTENT_LENGTH_METHODS = /* @__PURE__ */ new Set([
-	"HEAD",
-	"OPTIONS",
-	"TRACE"
-]);
 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;
@@ -27,7 +45,9 @@ var HttpResponse = class {
 	statusMessage = "";
 	flushing = false;
 	encoding = "utf-8";
-	body = null;
+	#text = null;
+	#textEncoding = "utf-8";
+	#buffer = null;
 	contentType = "application/octet-stream";
 	headers = {};
 	timeout;
@@ -35,7 +55,7 @@ var HttpResponse = class {
 	constructor(response, context) {
 		this.context = context;
 		this.response = response;
-		this.timeout = this.context?.httpKernel?.responseTimeout[this.context.type];
+		this.timeout = this.context.httpKernel?.responseTimeout[this.context.type];
 	}
 	/**
 	* Filet posé juste avant l'émission des en-têtes : si aucun `Content-Type`
@@ -46,6 +66,33 @@ var HttpResponse = class {
 	ensureContentTypeHeader() {
 		if (this.response && !this.response.hasHeader("content-type")) this.response.setHeader("content-type", this.contentType);
 	}
+	/**
+	* Corps de la réponse en octets. Un corps posé en texte n'est encodé qu'à la
+	* première lecture de cette propriété — l'envoi, lui, écrit le texte tel quel.
+	*/
+	get body() {
+		if (this.#text !== null) {
+			this.#buffer = Buffer.from(this.#text, this.#textEncoding);
+			this.#text = null;
+		}
+		return this.#buffer;
+	}
+	set body(value) {
+		this.#text = null;
+		this.#buffer = value;
+	}
+	/**
+	* Corps tel qu'il part sur le fil : le texte s'il n'a jamais été encodé, sinon
+	* les octets — vide légal si rien n'a été posé (`write(null)` jetterait
+	* ERR_STREAM_NULL_VALUES).
+	*/
+	get payload() {
+		return this.#text ?? this.#buffer ?? "";
+	}
+	/** Encodage à passer avec {@link payload} (ignoré par Node pour des octets). */
+	get payloadEncoding() {
+		return this.#text !== null ? this.#textEncoding : this.encoding;
+	}
 	clean() {
 		this.response = null;
 		this.body = null;
@@ -68,7 +115,7 @@ var HttpResponse = class {
 	}
 	deleteCookie(cookie) {
 		if (cookie instanceof Cookie) {
-			if (this.cookies[cookie.name]) {
+			if (Object.hasOwn(this.cookies, cookie.name)) {
 				delete this.cookies[cookie.name];
 				return true;
 			}
@@ -77,19 +124,20 @@ var HttpResponse = class {
 		throw new Error("Response delCookie not valid cookies");
 	}
 	deleteCookieByName(name) {
-		if (this.cookies[name]) {
+		if (Object.hasOwn(this.cookies, name)) {
 			delete this.cookies[name];
 			return true;
 		}
 		return false;
 	}
 	setCookies() {
-		const names = Object.keys(this.cookies);
-		if (names.length === 0) return;
-		if (names.length === 1) return this.setCookie(this.cookies[names[0]]);
+		const cookies = Object.values(this.cookies);
+		const first = cookies.at(0);
+		if (first === void 0) return;
+		if (cookies.length === 1) return this.setCookie(first);
 		const serialized = [];
-		for (const name of names) {
-			const s = this.cookies[name].serialize();
+		for (const cookie of cookies) {
+			const s = cookie.serialize();
 			this.log(`ADD COOKIE ==> ${s}`, "DEBUG");
 			serialized.push(s);
 		}
@@ -105,7 +153,8 @@ var HttpResponse = class {
 			if (this.flushing) {
 				const obj = {};
 				obj[name] = value;
-				return this.addTrailers(obj);
+				this.addTrailers(obj);
+				return;
 			}
 			if (!this.response.headersSent) {
 				const lower = name.toLowerCase();
@@ -125,7 +174,7 @@ var HttpResponse = class {
 	*/
 	#mergeVary(value) {
 		const incoming = (Array.isArray(value) ? value.join(",") : String(value)).split(",").map((t) => t.trim()).filter(Boolean);
-		const current = this.response?.getHeader?.("vary");
+		const current = this.response?.getHeader("vary");
 		const all = [...(Array.isArray(current) ? current.join(",") : String(current ?? "")).split(",").map((t) => t.trim()).filter(Boolean), ...incoming];
 		if (all.some((t) => t === "*")) return "*";
 		const seen = /* @__PURE__ */ new Set();
@@ -151,9 +200,9 @@ var HttpResponse = class {
 	}
 	setContentType(type, encoding) {
 		if (type && encoding) {
-			let mytype = mime.contentType(type);
-			if (mytype) {
-				mytype = mytype.split(";")[0];
+			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);
@@ -161,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);
 			}
@@ -230,30 +280,45 @@ var HttpResponse = class {
 		if (this.response) return this.statusMessage || this.response.statusMessage || http.STATUS_CODES[this.statusCode];
 		return this.statusMessage || http.STATUS_CODES[this.statusCode];
 	}
+	/**
+	* Pose le corps de la réponse : texte gardé tel quel, octets copiés sur leur
+	* seule fenêtre, tout autre valeur sérialisée en JSON.
+	*
+	* @param ele - corps à envoyer.
+	* @param encoding - encodage d'un corps texte (défaut : `this.encoding`).
+	*/
 	setBody(ele, encoding) {
-		if (typeof ele === "string") this.body = Buffer.from(ele, encoding || this.encoding);
+		if (typeof ele === "string") this.#setText(ele, encoding || this.encoding);
 		else if (ele instanceof ArrayBuffer || ele instanceof SharedArrayBuffer) this.body = Buffer.from(ele);
 		else if (ArrayBuffer.isView(ele) && ele.buffer instanceof ArrayBuffer) this.body = Buffer.from(ele.buffer, ele.byteOffset, ele.byteLength);
-		else try {
-			this.body = Buffer.from(JSON.stringify(ele));
-		} catch (e) {
-			this.body = Buffer.from(String(ele));
+		else {
+			let text;
+			try {
+				text = JSON.stringify(ele);
+			} catch {
+				text = String(ele);
+			}
+			this.#setText(text, "utf-8");
 		}
-		return this.body;
+	}
+	#setText(text, encoding) {
+		this.#buffer = null;
+		this.#text = text;
+		this.#textEncoding = encoding;
 	}
 	setLength(body) {
 		if (this.response?.headersSent) throw new Error("Headers already sended");
-		const actualBody = body || this.body;
-		const isChunked = this.getHeader("Transfer-Encoding") === "chunked";
-		if (!NO_CONTENT_LENGTH_METHODS.has(this.context?.method) && !NO_CONTENT_LENGTH_STATUS.has(this.statusCode) && !isChunked) {
-			if (actualBody) {
-				const length = Buffer.byteLength(actualBody);
-				this.setHeader("Content-Length", String(length));
-				return length;
-			}
+		if (this.getHeader("Transfer-Encoding") === "chunked") {
+			this.response?.removeHeader("Content-Length");
 			return 0;
 		}
-		if (!NO_CONTENT_LENGTH_STATUS.has(this.statusCode)) this.setHeader("Content-Length", "0");
+		if (NO_CONTENT_LENGTH_STATUS.has(this.statusCode)) return 0;
+		const actualBody = body || this.#text || this.#buffer;
+		if (actualBody) {
+			const length = typeof actualBody === "string" && actualBody === this.#text ? Buffer.byteLength(actualBody, this.#textEncoding) : Buffer.byteLength(actualBody);
+			this.setHeader("Content-Length", String(length));
+			return length;
+		}
 		return 0;
 	}
 	writeHead(statusCode, headers) {
@@ -264,8 +329,8 @@ var HttpResponse = class {
 				if (this.statusCode > 599) this.statusCode = 500;
 			}
 			this.statusMessage = this.getStatusMessage();
-			if (this.context.requestId && !this.response.headersSent) this.response.setHeader("x-request-id", this.context.requestId);
-			if (this.context.traceparent && !this.response.headersSent) this.response.setHeader("traceparent", this.context.traceparent);
+			if (this.context.requestId) this.response.setHeader("x-request-id", this.context.requestId);
+			if (this.context.traceparent) this.response.setHeader("traceparent", this.context.traceparent);
 			this.setLength();
 			this.ensureContentTypeHeader();
 			const std = http.STATUS_CODES[this.statusCode];
@@ -287,18 +352,29 @@ var HttpResponse = class {
 		this.setHeader("Transfer-Encoding", "chunked");
 		return this.send(chunk, encoding, true);
 	}
-	async send(chunk, encoding, _flush = false) {
+	/**
+	* Écrit le corps sur le flux et, pour une réponse unique, la termine.
+	*
+	* Synchrone pour une réponse unique ou une redirection : `end(corps)` est un
+	* appel synchrone de Node, rien n'y est à attendre (#505). Une promesse
+	* seulement en streaming chunké (`flush()`), réglée quand le flux accepte
+	* l'écriture suivante (`drain`) — c'est la contre-pression.
+	*
+	* @param chunk - le corps (posé par `setBody`) ; absent, le corps déjà posé.
+	* @param encoding - l'encodage d'un corps texte.
+	* @returns la réponse, ou sa promesse en streaming chunké.
+	* @throws de façon SYNCHRONE quand la réponse Node n'existe plus.
+	*/
+	send(chunk, encoding, _flush = false) {
 		if (this.context.isRedirect) {
 			if (!this.response?.headersSent) this.writeHead();
-			await this.end();
-			return this;
+			return thenMaybe(this.end(), () => this);
 		}
-		if (chunk) this.setBody(chunk);
+		if (chunk) this.setBody(chunk, encoding);
 		if (!this.response) throw new Error(`Http Response not found`);
-		if (this.body === null) this.body = Buffer.alloc(0);
 		const res = this.response;
 		if (!_flush && !this.flushing && !res.writableEnded) {
-			res.end(this.body, encoding || this.encoding);
+			res.end(this.payload, this.payloadEncoding);
 			return this;
 		}
 		return new Promise((resolve) => {
@@ -310,7 +386,7 @@ var HttpResponse = class {
 				}
 			};
 			const onDrain = () => done();
-			if (res.write(this.body, encoding || this.encoding, (error) => {
+			if (res.write(this.payload, this.payloadEncoding, (error) => {
 				if (error) {
 					this.log(error, "ERROR");
 					res.removeListener("drain", onDrain);
@@ -320,17 +396,21 @@ var HttpResponse = class {
 			else res.once("drain", onDrain);
 		});
 	}
-	async write(chunk, encoding) {
-		return await this.send(chunk, encoding || this.encoding);
+	write(chunk, encoding) {
+		return this.send(chunk, encoding || this.encoding);
 	}
 	writeContinue() {
 		return this.response?.writeContinue();
 	}
-	async end(chunk, encoding) {
-		return new Promise((resolve, reject) => {
-			if (this.response) return resolve(this.response.end(chunk, encoding || this.encoding));
-			return reject(/* @__PURE__ */ new Error(`response not found`));
-		});
+	/**
+	* Termine la réponse Node — un appel synchrone, rien n'y est à attendre (#505).
+	*
+	* @returns le flux terminé (valeur de `ServerResponse.end`).
+	* @throws de façon SYNCHRONE quand la réponse Node n'existe plus.
+	*/
+	end(chunk, encoding) {
+		if (!this.response) throw new Error(`response not found`);
+		return this.response.end(chunk, encoding || this.encoding);
 	}
 	getHeader(name) {
 		return this.response?.getHeader(name);

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

@@ -19,7 +19,7 @@ var Parser = class {
 	}
 	write(buffer) {
 		if (this.aborted) return buffer;
-		const max = this.request.maxBodySize ?? 0;
+		const max = this.request.maxBodySize;
 		this.received += buffer.length;
 		if (max > 0 && this.received > max) {
 			this.aborted = true;
@@ -78,7 +78,7 @@ var ParserQs = class extends Parser {
 	charset = "utf8";
 	constructor(request) {
 		super(request);
-		this.parserOptions = this.request.queryStringOptions || {};
+		this.parserOptions = this.request.queryStringOptions ?? {};
 		this.charset = this.request.charset;
 	}
 	async parse() {
@@ -151,13 +151,15 @@ const ACCEPT_ANY = [{
 * corrige aussi la négociation (match du token ENTIER, pas d'une sous-chaîne).
 */
 const acceptMatcher = (token) => !token || token === "*" ? /.*/ : new RegExp(`^${escapeRegExp(token)}$`);
+/** Qualité `q` d'une entrée `Accept` : sa valeur si c'est un nombre fini, 1 sinon. */
+const qualityOf = (entry) => typeof entry.q === "number" && Number.isFinite(entry.q) ? entry.q : 1;
 const acceptParser = function(acc) {
 	if (!acc) return ACCEPT_ANY;
 	const arr = [];
 	try {
 		const types = acc.split(",");
-		for (let i = 0; i < types.length; i++) {
-			const type = types[i].split(";");
+		for (const segment of types) {
+			const type = segment.split(";");
 			const mine = type.shift();
 			if (!mine) continue;
 			const dec = mine.trim().split("/");
@@ -167,8 +169,8 @@ const acceptParser = function(acc) {
 				type: acceptMatcher(ele1),
 				subtype: acceptMatcher(ele2)
 			};
-			for (let j = 0; j < type.length; j++) {
-				const params = type[j].split("=");
+			for (const param of type) {
+				const params = param.split("=");
 				const name = params.shift();
 				const value = params.shift();
 				obj[name] = name === "q" ? parseFloat(value) : value;
@@ -176,10 +178,7 @@ const acceptParser = function(acc) {
 			arr.push(obj);
 		}
 		if (arr.length === 0) return ACCEPT_ANY;
-		return arr.sort((a, b) => {
-			const qA = a.q || 1;
-			return (b.q || 1) - qA;
-		});
+		return arr.sort((a, b) => qualityOf(b) - qualityOf(a));
 	} catch {
 		return ACCEPT_ANY;
 	}

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

@@ -79,21 +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;
-	const last = labels[labels.length - 1];
-	if (isDigits(last)) {
-		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/context/http2/Response.js

@@ -1,20 +1,43 @@
 import HttpResponse from "../http/Response.js";
-import { extend } from "nodefony";
+import { thenMaybe } from "nodefony";
 import http from "node:http";
 import http2 from "node:http2";
 //#region nodefony/src/context/http2/Response.ts
 const HTTP2_HEADER_STATUS = http2.constants.HTTP2_HEADER_STATUS;
+/**
+* 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.
+*
+* Les clés sont ramenées en MINUSCULES : `getHeaders()` rend `content-type`,
+* un contrôleur passe `Content-Type` — fusionnées telles quelles, les deux
+* clés partaient ensemble et `stream.respond()` refusait la réponse
+* (`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).
+*
+* @param statusMessage - message de statut, recopié en `x-status-message`
+* @param current - en-têtes déjà posés sur la réponse
+* @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];
+	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];
+		if (value !== void 0) merged[key.toLowerCase()] = value;
+	}
+	return merged;
+}
 var Http2Response = class extends HttpResponse {
 	statusCode = 200;
 	stream = null;
 	streamId;
 	constructor(response, context) {
 		super(response, context);
-		if (response) {
-			this.stream = response.stream;
-			this.streamId = this.stream.id;
-		}
-		if (this.stream && this.stream.pushAllowed) this.context.pushAllowed = true;
+		this.stream = response.stream;
+		this.streamId = this.stream.id;
+		if (this.stream.pushAllowed) this.context.pushAllowed = true;
 	}
 	isHeaderSent() {
 		if (this.stream) return this.stream.headersSent;
@@ -35,7 +58,7 @@ var Http2Response = class extends HttpResponse {
 				this.statusMessage = this.getStatusMessage();
 				this.setLength();
 				this.ensureContentTypeHeader();
-				this.headers = extend(true, { "X-Status-Message": this.statusMessage }, this.getHeaders(), headers);
+				this.headers = mergeResponseHeaders(this.statusMessage, this.getHeaders(), headers);
 				this.headers[HTTP2_HEADER_STATUS] = this.statusCode;
 				const requestId = this.context.requestId;
 				if (requestId) this.headers["x-request-id"] = requestId;
@@ -45,39 +68,44 @@ var Http2Response = class extends HttpResponse {
 			} else this.log("Headers already sent !!", "WARNING");
 		} else return super.writeHead(statusCode, headers);
 	}
-	async send(chunk, encoding, _flush = false) {
+	/**
+	* É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).
+	*
+	* @returns la réponse, ou sa promesse.
+	*/
+	send(chunk, encoding, _flush = false) {
 		if (this.context.isRedirect) {
 			if (this.stream && !this.stream.headersSent) this.writeHead();
-			await this.end();
-			return this;
+			return thenMaybe(this.end(), () => this);
 		}
 		const stream = this.stream;
-		if (!stream) return await super.send(chunk, encoding);
+		if (!stream) return super.send(chunk, encoding);
 		if (stream.destroyed || !stream.writable) {
 			this.log("HTTP/2 stream not writable before send — skip", "DEBUG");
 			return this;
 		}
 		if (chunk) this.setBody(chunk);
-		if (this.body === null) this.body = Buffer.alloc(0);
 		return new Promise((resolve, reject) => {
-			stream.write(this.body, encoding || this.encoding, (error) => {
+			stream.write(this.payload, this.payloadEncoding, (error) => {
 				if (error) return reject(error);
 				return resolve(this);
 			});
 		});
 	}
+	/**
+	* Termine le flux HTTP/2 (ou la réponse de repli) — synchrone (#505).
+	*
+	* @returns le flux terminé.
+	* @throws de façon SYNCHRONE ce que lève la fin du flux.
+	*/
 	end(chunk, encoding) {
-		return new Promise((resolve, reject) => {
-			try {
-				if (this.stream) {
-					if (this.stream.destroyed || this.stream.closed) return resolve(this.stream);
-					return resolve(this.stream.end(chunk, encoding || this.encoding));
-				}
-				return resolve(super.end(chunk, encoding));
-			} catch (e) {
-				return reject(e);
-			}
-		});
+		if (this.stream) {
+			if (this.stream.destroyed || this.stream.closed) return this.stream;
+			return this.stream.end(chunk, encoding || this.encoding);
+		}
+		return super.end(chunk, encoding);
 	}
 	getStatusMessage(code) {
 		if (code) {
@@ -94,4 +122,4 @@ var Http2Response = class extends HttpResponse {
 	}
 };
 //#endregion
-export { Http2Response as default };
+export { Http2Response as default, mergeResponseHeaders };

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

@@ -31,7 +31,7 @@ function buildMetaData(target, src, override) {
 	nf.scheme = src.scheme;
 	nf.requestId = src.requestId;
 	const r = src.resolver;
-	nf.route = r && r.route ? {
+	nf.route = r?.route ? {
 		name: r.route.name,
 		path: r.route.path,
 		variablesMap: r.getMatchedParams()

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

@@ -54,7 +54,8 @@ const TRUST_NONE = { isTrusted: () => false };
 function addEntry(list, raw) {
 	const entry = raw.trim();
 	if (!entry) return;
-	const preset = PRESETS[entry.toLowerCase()];
+	const key = entry.toLowerCase();
+	const preset = Object.hasOwn(PRESETS, key) ? PRESETS[key] : void 0;
 	if (preset) {
 		for (const [net, prefix, family] of preset) list.addSubnet(net, prefix, family);
 		return;
@@ -124,7 +125,7 @@ function resolveFromRight(chain, socketAddress, checker) {
 	let candidate = socketAddress;
 	for (let i = chain.length - 1; i >= 0; i -= 1) {
 		if (!checker.isTrusted(candidate)) return candidate;
-		const next = chain[i];
+		const next = chain[i] ?? null;
 		if (next === null) return candidate;
 		candidate = next;
 	}
@@ -156,7 +157,7 @@ function extractClientIp(xff, socketAddress, checker) {
 	if (!socketAddress) return null;
 	if (!xff) return socketAddress;
 	const s = Array.isArray(xff) ? xff.join(",") : xff;
-	if (s.indexOf(",") === -1) {
+	if (!s.includes(",")) {
 		const ip = s.trim();
 		if (!ip) return socketAddress;
 		return checker.isTrusted(socketAddress) ? ip : socketAddress;

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

@@ -1,7 +1,8 @@
 import Cookie from "../../cookies/cookie.js";
 import { decideSend, readBackpressureOptions } from "./wsBackpressure.js";
-import Ws from "ws";
+import { toWsCloseReason } from "./wsCloseReason.js";
 import http from "node:http";
+import Ws from "ws";
 //#region nodefony/src/context/websocket/Response.ts
 /**
 * Codes d'erreur d'écriture « le client est PARTI » : reload de page, onglet
@@ -57,7 +58,7 @@ var WebsocketResponse = class {
 		this.connection = connection;
 	}
 	log(pci, severity, msgid, msg) {
-		const syslog = this.context?.container?.get("syslog");
+		const syslog = this.context.container?.get("syslog");
 		if (!msgid) msgid = "WEBSOCKET RESPONSE";
 		return syslog?.log(pci, severity, msgid, msg);
 	}
@@ -70,7 +71,7 @@ var WebsocketResponse = class {
 		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"));
-			const { max, policy, closeAfterDrops } = readBackpressureOptions(this.context?.server);
+			const { max, policy, closeAfterDrops } = readBackpressureOptions(this.context.server);
 			const decision = decideSend(this.connection, max, policy, closeAfterDrops);
 			if (decision !== "send") {
 				this.logFirstDrop(this.connection, decision, max);
@@ -93,7 +94,7 @@ var WebsocketResponse = class {
 	broadcast(data, type) {
 		const payload = data ?? this.body;
 		if (!payload) return;
-		const wss = this.context?.server;
+		const wss = this.context.server;
 		if (!wss) return;
 		const sendData = type === "binary" && Buffer.isBuffer(payload) ? payload : payload instanceof Buffer ? payload.toString(this.encoding) : payload;
 		const { max, policy, closeAfterDrops } = readBackpressureOptions(wss);
@@ -124,11 +125,17 @@ var WebsocketResponse = class {
 		return this.body;
 	}
 	drop(reasonCode, description) {
-		if (this.connection && this.connection.readyState === Ws.OPEN) return this.connection.close(reasonCode ?? this.statusCode, description);
+		if (this.connection && this.connection.readyState === Ws.OPEN) {
+			this.connection.close(reasonCode ?? this.statusCode, toWsCloseReason(description));
+			return;
+		}
 		throw new Error("Connection already closed");
 	}
 	close(reasonCode, description) {
-		if (this.connection && this.connection.readyState === Ws.OPEN) return this.connection.close(reasonCode ?? this.statusCode, description ?? "closed");
+		if (this.connection && this.connection.readyState === Ws.OPEN) {
+			this.connection.close(reasonCode ?? this.statusCode, toWsCloseReason(description ?? "closed"));
+			return;
+		}
 		throw new Error("Connection already closed");
 	}
 	getStatus() {