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

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

@@ -7,7 +7,7 @@ import HttpResponse from "./Response.js";
 import Http2Request from "../http2/Request.js";
 import Http2Response from "../http2/Response.js";
 import { describeSessionStoreFailure } from "../../session/sessionStoreFailure.js";
-import { extend, typeOf } from "nodefony";
+import { extend, finallyMaybe, isPromise, thenMaybe, typeOf } from "nodefony";
 import url, { URL } from "node:url";
 //#region nodefony/src/context/http/HttpContext.ts
 const socketActiveContext = /* @__PURE__ */ new WeakMap();
@@ -20,7 +20,6 @@ var HttpContext = class extends Context {
 	request;
 	response;
 	uploadService;
-	csrf;
 	constructor(container, request, response, type) {
 		super(container, type);
 		this.uploadService = this.get("upload");
@@ -97,18 +96,28 @@ var HttpContext = class extends Context {
 		if (req.hasParsedUrl) return req.url.protocol.replace(":", "");
 		return req.scheme;
 	}
-	async handle() {
+	/**
+	* Sert la requête : délai de réponse, hooks `onRequest`, puis l'action
+	* résolue et son rendu (`resolver.callController()`).
+	*
+	* Pas `async` : synchrone quand l'action et son rendu le sont, rien n'y est
+	* alors attendu (#505).
+	*
+	* @returns ce que rend `callController()` — le résultat du rendu, pas le
+	*   contexte (comportement historique, conservé) —, ou sa promesse. Sur une
+	*   redirection déjà posée : le contexte, une fois l'envoi fait.
+	* @throws HttpError 404, de façon SYNCHRONE, quand aucune route ne résout.
+	*/
+	handle() {
 		this.setTimeout();
-		if (this.isRedirect) {
-			await this.send();
-			return this;
-		}
+		if (this.isRedirect) return thenMaybe(this.send(), () => this);
 		this.fire("onRequest", this);
-		this.kernel?.fire("onRequest", this);
+		const kernel = this.kernel;
+		if (kernel && (kernel.debug || kernel.listenerCount("onRequest") > 0)) kernel.fire("onRequest", this);
 		if (!this.resolver && this.router) this.resolver = this.router.resolve(this);
-		if (this.resolver && this.resolver.resolve) {
+		if (this.resolver?.resolve) {
 			this.setMetaData();
-			return await this.resolver.callController();
+			return this.resolver.callController();
 		}
 		throw new HttpError("", 404, this);
 	}
@@ -117,7 +126,7 @@ var HttpContext = class extends Context {
 		if (!res) return;
 		if (this.response.stream) {
 			res.setTimeout(this.response.timeout, () => {
-				if (!this.response?.response?.writableEnded) this._onTimeout();
+				if (!this.response.response?.writableEnded) this._onTimeout();
 			});
 			return;
 		}
@@ -130,27 +139,28 @@ var HttpContext = class extends Context {
 			socketTimeoutArmed.add(socket);
 			socket.on("timeout", () => {
 				const ctx = socketActiveContext.get(socket);
-				if (ctx && !ctx.response?.response?.writableEnded) ctx._onTimeout();
+				if (ctx && !ctx.response.response?.writableEnded) ctx._onTimeout();
 			});
 		}
 	}
-	async render(chunk, encoding, status, headers) {
+	/**
+	* Sérialise la donnée selon son type (JSON, HTML, texte), pose statut et
+	* en-têtes, puis l'envoie ({@link send}). Synchrone quand l'envoi l'est (#505).
+	*
+	* @returns la réponse, ou sa promesse.
+	* @throws de façon SYNCHRONE ce que lèvent la sérialisation ou l'envoi.
+	*/
+	render(chunk, encoding, status, headers) {
 		let data = chunk;
-		switch (true) {
-			case this.isJson:
+		if (this.isJson) data = JSON.stringify(chunk);
+		else {
+			const type = typeOf(chunk);
+			if (type === "object") {
+				this.setContextJson();
 				data = JSON.stringify(chunk);
-				break;
-			case this.isHtml:
-			default: switch (typeOf(chunk)) {
-				case "object":
-					this.setContextJson();
-					data = JSON.stringify(chunk);
-					break;
-				case "string":
-					if (this.response.contentType === "application/octet-stream") this.setContextHtml();
-					break;
-				default: if (this.response.contentType === "application/octet-stream") this.response.setContentType("text");
-			}
+			} else if (type === "string") {
+				if (this.response.contentType === "application/octet-stream") this.setContextHtml();
+			} else if (this.response.contentType === "application/octet-stream") this.response.setContentType("text");
 		}
 		if (headers) this.response.setHeaders(headers);
 		if (status) this.response.setStatusCode(status);
@@ -161,83 +171,118 @@ var HttpContext = class extends Context {
 			this.log(describeSessionStoreFailure(e).message, "CRITIC", "SESSION-STORE");
 			return null;
 		}).then(async (_session) => {
-			return this.close().catch((e) => {
-				throw e;
-			});
+			return this.close();
 		});
 	}
-	async send(chunk, encoding) {
+	/**
+	* Envoie la réponse : session sauvée, hook `onSend`, en-têtes, corps, puis
+	* fin de la réponse.
+	*
+	* Synchrone dans le cas nominal — aucune session ouverte, aucun écouteur
+	* `onSend`, réponse unique : rien n'y est à attendre (#505). Une promesse
+	* seulement quand une étape attend réellement (écriture du store de session,
+	* hook asynchrone, streaming chunké, flux HTTP/2).
+	*
+	* @param chunk - le corps ; absent, le corps déjà posé sur la réponse.
+	* @param encoding - l'encodage d'un corps texte.
+	* @returns la réponse, ou sa promesse.
+	* @throws de façon SYNCHRONE `Response Already sended` quand la réponse est
+	*   déjà partie, et ce que lève une étape synchrone de l'envoi.
+	*/
+	send(chunk, encoding) {
 		if (this.finished && !this.sended) {
 			this.log("send() on finished context — client disconnected", "DEBUG");
 			return this.response;
 		}
-		if (this.sended || this.finished || this.response.isHeaderSent()) return new Promise((_resolve, reject) => {
-			return reject(/* @__PURE__ */ new Error("Response Already sended"));
-		});
-		if (!this.timingEnabled) return this.#doSend(chunk, encoding);
+		if (this.sended || this.finished || this.response.isHeaderSent()) throw new Error("Response Already sended");
+		if (!this.timingEnabled) return this.doSend(chunk, encoding);
 		this.phaseStart("send");
-		try {
-			return await this.#doSend(chunk, encoding);
-		} finally {
-			this.phaseEnd("send");
-		}
+		return finallyMaybe(() => this.doSend(chunk, encoding), () => this.phaseEnd("send"));
 	}
-	async #doSend(chunk, encoding) {
+	/**
+	* Le travail de {@link send}, journalisé en ERROR quand il échoue — de façon
+	* synchrone ou par rejet, selon l'étape qui échoue.
+	*/
+	doSend(chunk, encoding) {
+		let sent;
 		try {
-			let body = chunk;
-			if (this.session != null) try {
-				await this.saveSession();
-			} catch (e) {
-				const failure = describeSessionStoreFailure(e);
-				this.log(failure.message, "CRITIC", "SESSION-STORE");
-				this.response.statusCode = failure.statusCode;
-				body = failure.body;
-			}
-			if (body) this.response?.setBody(body);
-			if (this.listenerCount("onSend") > 0) await this.fireAsync("onSend", this.response, this);
-			try {
-				this.writeHead();
-			} catch (e) {
-				this.log(e, "WARNING");
-			}
-			if (this.isRedirect) return await this.close();
-			return await this.write(body, encoding);
+			sent = this.sendSteps(chunk, encoding);
 		} catch (error) {
 			this.log(error, "ERROR");
 			throw error;
 		}
+		if (!isPromise(sent)) return sent;
+		return sent.catch((error) => {
+			this.log(error, "ERROR");
+			throw error;
+		});
+	}
+	/** Session, puis hook `onSend`, puis en-têtes et corps — chacun attendu seulement s'il attend. */
+	sendSteps(chunk, encoding) {
+		if (this.session != null) return this.saveSession().then(() => this.emitAndWrite(chunk, encoding), (e) => {
+			const failure = describeSessionStoreFailure(e);
+			this.log(failure.message, "CRITIC", "SESSION-STORE");
+			this.response.statusCode = failure.statusCode;
+			return this.emitAndWrite(failure.body, encoding);
+		});
+		return this.emitAndWrite(chunk, encoding);
+	}
+	/** Hook `onSend` (attendu seulement s'il a un écouteur), puis en-têtes et corps. */
+	emitAndWrite(body, encoding) {
+		if (body) this.response.setBody(body);
+		if (this.listenerCount("onSend") > 0) return this.fireAsync("onSend", this.response, this).then(() => this.writeHeadAndBody(body, encoding));
+		return this.writeHeadAndBody(body, encoding);
+	}
+	/** En-têtes, puis corps — ou la seule fin de réponse pour une redirection. */
+	writeHeadAndBody(body, encoding) {
+		try {
+			this.writeHead();
+		} catch (e) {
+			this.log(e, "WARNING");
+		}
+		if (this.isRedirect) return this.close();
+		return this.write(body, encoding);
 	}
 	writeHead(statusCode, headers) {
-		if (this.response) {
-			if (this.csrfToken) this.setCookie(new Cookie("csrf-token", this.csrfToken, {
-				httpOnly: false,
-				sameSite: "Strict",
-				secure: this.scheme === "https",
-				path: "/"
-			}));
-			this.response.setCookies();
-			this.response.writeHead(statusCode, headers);
-		}
+		if (this.csrfToken) this.setCookie(new Cookie("csrf-token", this.csrfToken, {
+			httpOnly: false,
+			sameSite: "Strict",
+			secure: this.scheme === "https",
+			path: "/"
+		}));
+		this.response.setCookies();
+		this.response.writeHead(statusCode, headers);
 	}
-	async write(chunk, encoding, _flush = false) {
-		await this.response.send(chunk, encoding || this.response.encoding).then(() => {
+	/**
+	* Écrit le corps, puis termine la requête ({@link close}). Synchrone pour une
+	* réponse unique (#505).
+	*
+	* @returns la réponse, ou sa promesse quand l'écriture attend.
+	*/
+	write(chunk, encoding, _flush = false) {
+		return thenMaybe(this.response.send(chunk, encoding || this.response.encoding), () => {
 			this.sended = true;
-		}).catch((e) => {
-			throw e;
-		});
-		return this.close().catch((e) => {
-			throw e;
+			return this.close();
 		});
 	}
 	flush(chunk, encoding) {
 		return this.response.flush(chunk, encoding);
 	}
-	async close() {
-		if (this.listenerCount("onClose") > 0) await this.fireAsync("onClose", this);
-		if (this.response?.response?.writableEnded) return this.response;
-		return this.response.end().then(() => this.response).catch((e) => {
-			throw e;
-		});
+	/**
+	* Termine la requête : hook `onClose`, puis fin de la réponse si l'envoi ne
+	* l'a pas déjà faite. Synchrone sans écouteur `onClose` (#505).
+	*
+	* @returns la réponse, ou sa promesse quand le hook attend.
+	*/
+	close() {
+		if (this.finished) return this.response;
+		if (this.listenerCount("onClose") > 0) return this.fireAsync("onClose", this).then(() => this.endResponse());
+		return this.endResponse();
+	}
+	/** Fin de la réponse, sauf si l'envoi l'a déjà terminée. */
+	endResponse() {
+		if (this.response.response?.writableEnded) return this.response;
+		return thenMaybe(this.response.end(), () => this.response);
 	}
 	redirect(Url, status, headers) {
 		if (typeof Url === "object") return this.response.redirect(url.format(Url), status, headers);
@@ -280,25 +325,25 @@ var HttpContext = class extends Context {
 		return this.redirect(newUrl, status, headers);
 	}
 	getHostName() {
-		return this.request?.getHostName();
+		return this.request.getHostName();
 	}
 	getRemoteAddress() {
-		return this.request?.getRemoteAddress();
+		return this.request.getRemoteAddress();
 	}
 	getHost() {
-		return this.request?.getHost();
+		return this.request.getHost();
 	}
 	getUserAgent() {
-		return this.request?.getUserAgent();
+		return this.request.getUserAgent();
 	}
 	getMethod() {
-		return this.request?.getMethod();
+		return this.request.getMethod();
 	}
 	setContentType(type, encoding) {
 		return this.response.setContentType(type, encoding);
 	}
 	resolveIsHtml() {
-		return this.request?.acceptHtml ?? false;
+		return this.request.acceptHtml;
 	}
 	setDefaultContentType() {
 		if (this.isHtml) this.response.setContentType("html", "utf-8");

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

@@ -2,7 +2,7 @@ import HttpError from "../../errors/httpError.js";
 import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
 import { Parser, ParserJson, ParserQs, ParserXml, acceptParser } from "./parser.js";
 import { isCanonicalAuthority, splitTarget } from "./urlFastPath.js";
-import { extend } from "nodefony";
+import { RequestContext, extend, useConfig } from "nodefony";
 import { createHash, randomUUID } from "node:crypto";
 import { URL } from "node:url";
 import fs from "node:fs";
@@ -39,15 +39,34 @@ const parse = {
 	PATCH: true,
 	DELETE: true
 };
+/**
+* La méthode porte-t-elle un corps à lire ? La règle a UNE implémentation : le
+* choix « lire le corps » (`parseRequest`) et le choix « rien à attendre »
+* (`initialize`) la lisent tous deux ici.
+*/
+function hasRequestBody(method) {
+	return method in parse;
+}
 const PERF_PROBE_SUB = process.env.NF_PERF_PROBE === "1";
 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;
@@ -129,12 +148,12 @@ var HttpRequest = class {
 	#acceptHtml = null;
 	/** Media-ranges de l'en-tête `Accept`, parsés au premier accès (mémoïsé). */
 	get accept() {
-		if (this.#accept === null) this.#accept = acceptParser(this.headers?.accept);
+		this.#accept ??= acceptParser(this.headers.accept);
 		return this.#accept;
 	}
 	/** `true` si le client accepte `text/html` — résolu au premier accès (mémoïsé). */
 	get acceptHtml() {
-		if (this.#acceptHtml === null) this.#acceptHtml = this.accepts("html");
+		this.#acceptHtml ??= this.accepts("html");
 		return this.#acceptHtml;
 	}
 	origin;
@@ -147,14 +166,16 @@ var HttpRequest = class {
 		this.request.body = null;
 		this.headers = request.headers;
 		this.origin = this.headers.origin;
-		const checker = this.context?.httpKernel?.getTrustProxyChecker();
-		const socketAddress = this.request.socket?.remoteAddress;
+		const checker = this.context.httpKernel?.getTrustProxyChecker();
+		const socketAddress = this.request.socket.remoteAddress;
 		this.trustedProxy = !!checker?.isTrusted(socketAddress);
 		if (this.trustedProxy && checker && hasForwardingHeaders(this.headers)) this.forwarded = resolveForwarded(this.headers, socketAddress, checker);
 		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) {
@@ -167,11 +188,9 @@ var HttpRequest = class {
 			this.search = u.search;
 		}
 		if (PERF_PROBE_SUB) perfMark("reqUrlNs");
-		this.queryStringOptions = this.context?.httpKernel?.module.options.queryString || {};
-		this.uploadOption = this.context?.httpKernel?.module.options.upload || {};
-		this.maxBodySize = this.context?.httpKernel?.module.options.maxBodySize ?? 0;
+		this.queryStringOptions = this.context.httpKernel?.module.options.queryString || {};
 		let query;
-		if (this.search) query = QS.parse(this.search.slice(1), this.queryStringOptions || {});
+		if (this.search) query = QS.parse(this.search.slice(1), this.queryStringOptions ?? {});
 		else query = {};
 		if (this.#url !== null) this.#url.query = query;
 		this.queryGet = query;
@@ -198,32 +217,64 @@ var HttpRequest = class {
 		if (this.context.listenerCount("onRequestEnd") === 0) return false;
 		return this.context.fireAsync("onRequestEnd", this);
 	}
-	async initialize() {
+	/**
+	* Lit le corps de la requête, s'il y en a un, puis émet `onRequestEnd`.
+	*
+	* Le contrat de retour dit ce qui reste à ATTENDRE :
+	* - `undefined` — la méthode ne porte pas de corps (GET, HEAD, OPTIONS…) et
+	*   aucun écouteur `onRequestEnd` ne rend de promesse : tout est fait, de
+	*   façon SYNCHRONE ;
+	* - une `Promise` — le corps arrive du socket (POST, PUT, PATCH, DELETE), ou
+	*   un écouteur `onRequestEnd` est à attendre. Sa valeur n'est consommée par
+	*   personne : elle ne sert qu'au séquençage.
+	*
+	* L'appelant n'attend donc que ce qui attend vraiment
+	* (`const pending = request.initialize(); if (pending) await pending;`) : un
+	* `await` inconditionnel reportait le pipeline d'une micro-tâche, et la
+	* chaîne de promesses coûtait ~6 évènements asynchrones à un GET qui n'avait
+	* rien à lire (#505).
+	*
+	* Ne lève jamais de façon synchrone : un corps refusé (413) ou illisible rompt
+	* la promesse rendue, comme avant.
+	*
+	* @returns `undefined` quand tout est fait, sinon la promesse à attendre.
+	*/
+	initialize() {
+		if (!hasRequestBody(this.method)) return this.endWithoutBody();
 		return this.parseRequest().then(async (parser) => {
-			switch (true) {
-				case parser instanceof ParserXml:
-				case parser instanceof ParserQs:
-				case parser instanceof Parser: try {
+			if (parser instanceof ParserXml || parser instanceof ParserQs || parser instanceof Parser) {
+				let requestEnd;
+				try {
 					if (this.context.finished) return;
 					await parser.parse();
-					return this.fireRequestEnd();
-				} catch (error) {
-					return this.context?.httpKernel?.onError(error, this.context);
-				}
-				default: if (!parser) try {
-					if (this.context.finished) return;
-					this.context.requestEnded = true;
-					return this.fireRequestEnd();
+					requestEnd = this.fireRequestEnd();
 				} catch (error) {
 					return this.context.httpKernel?.onError(error, this.context);
 				}
+				return requestEnd;
 			}
+			if (!parser) return this.endWithoutBody();
 			return parser;
-		}).catch((e) => {
-			throw e;
 		});
 	}
 	/**
+	* Fin d'une requête SANS corps à lire : la marque terminée et émet
+	* `onRequestEnd`. Synchrone — ne rend une promesse que lorsqu'un écouteur
+	* `onRequestEnd` est à attendre, ou quand l'émission lève (celle d'`onError`).
+	*
+	* @returns `undefined` quand tout est fait, sinon la promesse à attendre.
+	*/
+	endWithoutBody() {
+		if (this.context.finished) return;
+		try {
+			this.context.requestEnded = true;
+			const requestEnd = this.fireRequestEnd();
+			return requestEnd === false ? void 0 : requestEnd;
+		} catch (error) {
+			return this.context.httpKernel?.onError(error, this.context);
+		}
+	}
+	/**
 	* B1 — Pré-contrôle de taille du corps via l'en-tête `Content-Length` :
 	* rejette en 413 (RFC 9110 §15.5.14 « Content Too Large ») AVANT toute lecture
 	* quand le client annonce une taille supérieure à `maxBodySize`. Rideau de
@@ -232,16 +283,28 @@ var HttpRequest = class {
 	*
 	* @throws {HttpError} 413 si `Content-Length` dépasse `maxBodySize`.
 	*/
+	/**
+	* Lit le plafond du corps et les limites d'envoi tels que les voit CETTE
+	* requête : la configuration http, surchargée par le calque que la requête a
+	* pu poser avant la lecture du corps (`overlayConfig`, #494). Hors pipeline
+	* (aucun scope ouvert), la configuration du module telle quelle.
+	*/
+	readBodyLimits() {
+		const options = RequestContext.getScope() !== void 0 ? useConfig("@nodefony/http") : this.context.httpKernel?.module.options;
+		this.uploadOption = options?.upload ?? {};
+		this.maxBodySize = options?.maxBodySize ?? 0;
+	}
 	enforceBodyLimit() {
 		const max = this.maxBodySize;
 		if (max <= 0) return;
 		const cl = this.headers["content-length"];
 		if (cl === void 0) return;
-		const declared = parseInt(Array.isArray(cl) ? cl[0] : cl, 10);
+		const declared = parseInt(typeof cl === "string" ? cl : cl[0], 10);
 		if (Number.isFinite(declared) && declared > max) throw new HttpError(`Request body too large: ${declared} bytes > maxBodySize ${max}`, 413, this.context);
 	}
 	async parseRequest() {
-		if (!(this.method in parse)) return this.parser;
+		if (!hasRequestBody(this.method)) return this.parser;
+		this.readBodyLimits();
 		if (this.contentType !== "multipart/form-data") this.enforceBodyLimit();
 		switch (this.contentType) {
 			case "application/xml":
@@ -349,8 +412,7 @@ var HttpRequest = class {
 					stream.resume();
 					return;
 				}
-				const match = reg.exec(fieldname);
-				const field = match ? match[1] : fieldname;
+				const field = reg.exec(fieldname)?.[1] ?? fieldname;
 				const ext = filename ? path.extname(filename) : "";
 				const newFilename = `${randomUUID()}${ext}`;
 				const filepath = path.join(dir, newFilename);
@@ -415,7 +477,7 @@ var HttpRequest = class {
 	*/
 	assignField(fields, name, value) {
 		const match = reg.exec(name);
-		const key = match ? match[1] : name;
+		const key = match?.[1] ?? name;
 		if (key in fields) {
 			const cur = fields[key];
 			if (Array.isArray(cur)) cur.push(value);
@@ -427,7 +489,7 @@ var HttpRequest = class {
 		let subtype = "*";
 		let type = "*";
 		if (Type) parts = Type.split("/");
-		if (parts) switch (parts.length) {
+		switch (parts.length) {
 			case 1:
 				subtype = parts.shift();
 				break;
@@ -437,10 +499,7 @@ var HttpRequest = class {
 				break;
 			default: throw new Error("request accepts method bad type format");
 		}
-		for (let i = 0; i < this.accept.length; i++) {
-			const line = this.accept[i];
-			if ((type === "*" || line.type.test(type)) && (subtype === "*" || line.subtype.test(subtype))) return true;
-		}
+		for (const line of this.accept) if ((type === "*" || line.type.test(type)) && (subtype === "*" || line.subtype.test(subtype))) return true;
 		return false;
 	}
 	async createFileUpload(name, file) {
@@ -454,12 +513,15 @@ var HttpRequest = class {
 	getContentType(request) {
 		if (request.headers["content-type"]) {
 			const tab = request.headers["content-type"].split(";");
-			if (tab.length > 1) for (let i = 1; i < tab.length; i++) if (typeof tab[i] === "string") {
-				const ele = tab[i].split("=");
-				const key = ele[0].replace(/\s+/g, "").toLowerCase();
-				this.rawContentType[key] = ele[1];
-			} else continue;
-			return tab[0];
+			if (tab.length > 1) for (let i = 1; i < tab.length; i++) {
+				const part = tab[i];
+				if (typeof part === "string") {
+					const [rawKey = "", value] = part.split("=");
+					const key = rawKey.replace(/\s+/g, "").toLowerCase();
+					this.rawContentType[key] = value;
+				} else continue;
+			}
+			return tab[0] ?? null;
 		}
 		return null;
 	}
@@ -485,16 +547,16 @@ 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;
 	}
 	getRemoteAddress() {
 		if (this.forwarded) return this.forwarded.clientIp;
-		return this.request.socket?.remoteAddress ?? null;
+		return this.request.socket.remoteAddress ?? null;
 	}
 	/**
 	* Request-target brut (origin-form) tel que reçu du transport — SOURCE
@@ -511,7 +573,7 @@ var HttpRequest = class {
 	*/
 	resolveScheme(request) {
 		if (this.forwarded?.proto) return this.forwarded.proto;
-		if ("encrypted" in request.socket && request.socket.encrypted) return "https";
+		if (request.socket.encrypted) return "https";
 		return "http";
 	}
 	getFullUrl(request = this.request) {