@nodefony/http 10.0.0-alpha.1

package/dist/nodefony/service/pretty-request-logger.js

@@ -0,0 +1,72 @@
+import { severityFromStatus } from "./audit-logger.js";
+import { logColor } from "nodefony";
+import { performance } from "node:perf_hooks";
+//#region nodefony/service/pretty-request-logger.ts
+/**
+* Pretty single-line logger for dev (P3.2) — the biggest gain for humans.
+*
+* Format (no padding, ANSI-colored):
+*   `GET 200 /api/test 12.3ms 127.0.0.1 [a1b2c3d4]`
+*
+* - method     : cyan
+* - status     : green (2xx) / yellow (3xx) / yellow-bold (4xx) / red (5xx)
+* - url        : default
+* - duration   : dim
+* - remote     : dim
+* - requestId  : magenta-dim, truncated to first 8 chars
+*
+* Activate with `httpKernel.setRequestLogger(new PrettyRequestLogger())`.
+*
+* Stateless singleton. Allocates a few strings per request (terminal log
+* path) — zero overhead when not activated.
+*/
+var PrettyRequestLogger = class {
+	renderHttp(context, error) {
+		const ctx = context;
+		const err = error ?? ctx.error ?? null;
+		const status = ctx.response?.statusCode ?? (err ? 500 : null);
+		const method = ctx.method ?? "?";
+		const duration = computeDurationMs(ctx.phases);
+		return {
+			text: `${logColor.cyan(method.padEnd(4))} ${colorizeStatus(status)} ${ctx.url} ${logColor.blackBright(formatDuration(duration))} ${logColor.blackBright(ctx.remoteAddress ?? "-")} ${logColor.magenta(`[${shortId(ctx.requestId)}]`)}` + (err ? ` ${logColor.red(err.message)}` : ""),
+			severity: severityFromStatus(status),
+			msgid: "req"
+		};
+	}
+	renderWebsocket(context, error, acceptedProtocol) {
+		const ctx = context;
+		const status = ctx.response?.statusCode ?? (error ? 500 : null);
+		const duration = computeDurationMs(ctx.phases);
+		const proto = acceptedProtocol ? `[${acceptedProtocol}]` : "";
+		return {
+			text: `${logColor.cyan("WS  ")} ${colorizeStatus(status)} ${ctx.url} ${logColor.blackBright(proto)} ${logColor.blackBright(formatDuration(duration))} ${logColor.blackBright(ctx.remoteAddress ?? "-")} ${logColor.magenta(`[${shortId(ctx.requestId)}]`)}` + (error ? ` ${logColor.red(error.message)}` : ""),
+			severity: error ? "ERROR" : "INFO",
+			msgid: "req"
+		};
+	}
+};
+function colorizeStatus(status) {
+	if (status === null) return logColor.blackBright("---");
+	const s = String(status);
+	if (status >= 500) return logColor.red(s);
+	if (status >= 400) return logColor.yellowBold(s);
+	if (status >= 300) return logColor.yellow(s);
+	return logColor.green(s);
+}
+function formatDuration(ms) {
+	if (ms === null) return "---";
+	if (ms < 1) return `${ms.toFixed(2)}ms`;
+	if (ms < 1e3) return `${ms.toFixed(1)}ms`;
+	return `${(ms / 1e3).toFixed(2)}s`;
+}
+function shortId(id) {
+	return id.length > 8 ? id.slice(0, 8) : id;
+}
+function computeDurationMs(phases) {
+	if (!phases.length) return null;
+	const first = phases[0];
+	if (typeof first.startMs !== "number") return null;
+	return performance.now() - first.startMs;
+}
+//#endregion
+export { PrettyRequestLogger as default };

package/dist/nodefony/service/request-logger.js

@@ -0,0 +1,54 @@
+import { logColor } from "nodefony";
+//#region nodefony/service/request-logger.ts
+/**
+* Default Nodefony per-request logger — preserves the legacy colored format.
+*
+* HTTP success: `URL : <url> FROM : <remote> ORIGIN : <host> ID : <uuid>`
+* HTTP error:   adds the error toString (in dev), single-line in prod
+* WebSocket:    adds `Accept-Protocol : <proto>` on success
+*
+* Stateless singleton — zero per-request allocation. Override via
+* `httpKernel.setRequestLogger(custom)` for JSON access logs (P3.1),
+* pretty formatter (P3.2), or NCSA combined format (P3.10).
+*/
+var DefaultRequestLogger = class {
+	renderHttp(context, error) {
+		const ctx = context;
+		const txt = `${logColor.cyan("URL")} : ${ctx.url} ${logColor.cyan("FROM")} : ${ctx.remoteAddress} ${logColor.cyan("ORIGIN")} : ${ctx.originUrl?.host} ${logColor.cyan("ID")} : ${ctx.requestId}`;
+		const err = error ?? ctx.error;
+		if (err) {
+			const errCode = err.code ?? ctx.response?.statusCode ?? 500;
+			const msgid = `${ctx.type} ${logColor.magenta(errCode)} ${logColor.red(ctx.method ?? "")}`;
+			return {
+				text: ctx.kernel?.environment === "production" ? `${txt} ${err}` : `${txt}\n          ${err}`,
+				severity: "ERROR",
+				msgid
+			};
+		}
+		return {
+			text: txt,
+			severity: "INFO",
+			msgid: `${ctx.type} ${logColor.magenta(ctx.response?.statusCode ?? "")} ${ctx.method}`
+		};
+	}
+	renderWebsocket(context, error, acceptedProtocol) {
+		const ctx = context;
+		if (error) {
+			const errCode = error.code ?? ctx.response?.statusCode ?? 500;
+			const msgid = `${ctx.type} ${logColor.magenta(errCode)} ${logColor.red(ctx.method ?? "")}`;
+			return {
+				text: `${logColor.cyan("URL")} : ${ctx.url}  ${logColor.cyan("FROM")} : ${ctx.remoteAddress} ${logColor.cyan("ORIGIN")} : ${ctx.originUrl?.host} ${logColor.cyan("ID")} : ${ctx.requestId}\n        ` + error.toString(),
+				severity: "ERROR",
+				msgid
+			};
+		}
+		const msgid = `${ctx.type} ${logColor.magenta(ctx.response?.statusCode ?? "")} ${ctx.method}`;
+		return {
+			text: `${logColor.cyan("URL")} : ${ctx.url} ${logColor.cyan("Accept-Protocol")} : ${acceptedProtocol || "*"} ${logColor.cyan("FROM")} : ${ctx.remoteAddress} ${logColor.cyan("ORIGIN")} : ${ctx.originUrl?.host} ${logColor.cyan("ID")} : ${ctx.requestId}`,
+			severity: "INFO",
+			msgid
+		};
+	}
+};
+//#endregion
+export { DefaultRequestLogger as default };

package/dist/nodefony/service/servers/clientError.js

@@ -0,0 +1,20 @@
+//#region nodefony/service/servers/clientError.ts
+/**
+* Gère l'event `clientError` d'un `http.Server` / `https.Server`.
+*
+* ⚠️ Doc Node (`http.Server` event `'clientError'`) : dès qu'un listener
+* `clientError` est attaché, Node **cesse de fermer le socket automatiquement**
+* (le défaut aurait répondu `400` + détruit le socket). Sans fermeture
+* explicite, un socket malformé reste ouvert → fuite de socket/FD = DoS sur
+* requête mal formée. On répond donc une réponse minimale et on ferme.
+*
+* @param error - erreur émise (codes `llhttp` : `HPE_*`, ou `ECONNRESET`…).
+* @param socket - flux client brut (l'event `clientError` fournit un `Duplex`).
+*/
+function handleClientError(error, socket) {
+	if (error?.code === "ECONNRESET" || !socket.writable) return;
+	const statusLine = error?.code === "HPE_HEADER_OVERFLOW" ? "431 Request Header Fields Too Large" : "400 Bad Request";
+	socket.end(`HTTP/1.1 ${statusLine}\r\nConnection: close\r\n\r\n`);
+}
+//#endregion
+export { handleClientError };

package/dist/nodefony/service/servers/server-http.js

@@ -0,0 +1,135 @@
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import http_kernel_default from "../http-kernel.js";
+import { handleClientError } from "./clientError.js";
+import { createDrainTerminator } from "./serverShutdown.js";
+import { bindWithFallback, buildBindPlan } from "../../src/servers/portBinder.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateParam.js";
+import { Module, Service, extend, inject, nodefonyError } from "nodefony";
+import http from "node:http";
+//#region nodefony/service/servers/server-http.ts
+let ServerHttp = class ServerHttp extends Service {
+	httpKernel;
+	module;
+	server = null;
+	httpTerminator = null;
+	port;
+	protocol = "1.1";
+	ready = false;
+	type = "http";
+	domain;
+	scheme = "http";
+	address = null;
+	family = null;
+	active = false;
+	infos = null;
+	constructor(module, httpKernel) {
+		super("server-http", module.container, module.notificationsCenter, module.options.http);
+		this.httpKernel = httpKernel;
+		this.module = module;
+		this.active = !!module.kernel?.options.servers.http;
+		this.port = this.setPort();
+		this.domain = this.module.kernel?.domain;
+	}
+	setPort() {
+		if (this.module.kernel?.options.servers?.http) return this.module.kernel?.options.servers?.http?.port || 0;
+		return 0;
+	}
+	createServer() {
+		return new Promise((resolve, reject) => {
+			try {
+				if (!this.active) return reject(/* @__PURE__ */ new Error(`Server http is not allowed in config file `));
+				const opt = extend({ requestTimeout: this.options.requestTimeout });
+				this.server = http.createServer(opt);
+				this.httpTerminator = createDrainTerminator(this.server, this.options.shutdownTimeout);
+				if (this.options.maxHeadersCount) {
+					if (this.server) this.server.maxHeadersCount = this.options.maxHeadersCount;
+				}
+				if (this.options.timeout) {
+					if (this.server) {
+						this.server.setTimeout(this.options.timeout, () => {
+							this.fire("onTimeout", this);
+						});
+						this.server.timeout = this.options.timeout;
+					}
+				}
+				if (this.options.keepAliveTimeout) {
+					if (this.server) this.server.keepAliveTimeout = this.options.keepAliveTimeout;
+				}
+				this.server.on("request", (request, response) => this.httpKernel?.onHttpRequest(request, response, this.type).catch(() => {}));
+				this.module.fire("onCreateServer", this.type, this);
+				bindWithFallback(this.server, this.domain, buildBindPlan("http", this.module.kernel?.options.servers, this.module.kernel?.environment)).then(({ address, shiftedFrom }) => {
+					this.infos = address;
+					this.port = address.port;
+					this.address = address.address;
+					this.family = address.family;
+					if (shiftedFrom !== null) this.log(`Port ${shiftedFrom} déjà occupé → HTTP écoute sur ${this.port}. Figer le port : servers.http.port ; échouer au lieu de glisser : servers.portPolicy = "strict".`, "WARNING");
+					this.ready = true;
+					this.module.fire("onServersReady", this.type, this);
+					this.attachErrorHandler();
+					resolve(this.server);
+				}).catch((error) => {
+					this.reportBindError(error);
+					reject(error);
+				});
+				this.kernel?.once("onTerminate", async () => {
+					if (!this.server) return;
+					try {
+						await this.httpTerminator?.terminate();
+						this.log(`${this.type} SHUTDOWN Server is listening on DOMAIN : ${this.domain}    PORT : ${this.port}`, "INFO");
+					} catch (e) {
+						this.log(e, "ERROR", "TERMINATE");
+					}
+				});
+				this.server.on("clientError", (e, socket) => {
+					this.fire("onClientError", e, socket);
+					handleClientError(e, socket);
+				});
+			} catch (e) {
+				this.log(e, "CRITIC");
+				return reject(e);
+			}
+		});
+	}
+	/**
+	* Handler d'erreur DURABLE — posé une fois le serveur en écoute.
+	*
+	* Il ne traite donc plus `EADDRINUSE` au bind (le binder s'en charge, avec ou
+	* sans repli) : il couvre les erreurs de la VIE du serveur.
+	*/
+	attachErrorHandler() {
+		this.server?.on("error", (error) => {
+			this.log(new nodefonyError(error), "CRITIC");
+		});
+	}
+	/**
+	* Le bind a échoué pour de bon — soit `portPolicy: "strict"`, soit tous les
+	* ports de repli étaient pris, soit une erreur qui n'est pas un conflit de port.
+	*
+	* Reste FATAL (contrat inchangé) : un serveur qui n'écoute pas ne doit jamais
+	* laisser le process traîner en se croyant démarré.
+	*/
+	reportBindError(error) {
+		const myError = new nodefonyError(error);
+		switch (error.code) {
+			case "ENOTFOUND":
+				this.log(`CHECK DOMAIN IN /etc/hosts or config unable to connect to : ${this.domain}`, "ERROR");
+				this.log(myError, "CRITIC");
+				break;
+			case "EADDRINUSE":
+				this.log(`Port ${this.port} déjà occupé (domaine ${this.domain}) — le serveur HTTP ne peut pas écouter. Libérer le port, en choisir un autre (servers.http.port), ou autoriser le repli automatique (servers.portPolicy = "auto", défaut en développement).`, "ERROR");
+				this.log(myError, "CRITIC");
+				break;
+			default: this.log(myError, "CRITIC");
+		}
+		this.server?.close();
+		setTimeout(() => this.kernel?.terminate(1), 1e3);
+	}
+	showBanner() {
+		if (this.infos) this.log(`Server Listen on ${this.scheme}://${this.infos.address}:${this.infos.port} Family: ${this.infos.family} Protocol : ${this.protocol}`);
+	}
+};
+ServerHttp = __decorate([__decorateParam(1, inject("HttpKernel")), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module, typeof http_kernel_default === "undefined" ? Object : http_kernel_default])], ServerHttp);
+var server_http_default = ServerHttp;
+//#endregion
+export { server_http_default as default };

package/dist/nodefony/service/servers/server-https.js

@@ -0,0 +1,204 @@
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import http_kernel_default from "../http-kernel.js";
+import { handleClientError } from "./clientError.js";
+import { createDrainTerminator } from "./serverShutdown.js";
+import { bindWithFallback, buildBindPlan } from "../../src/servers/portBinder.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateParam.js";
+import { Module, Service, extend, inject, nodefonyError } from "nodefony";
+import http2 from "node:http2";
+import https from "node:https";
+import { TLSSocket } from "node:tls";
+//#region nodefony/service/servers/server-https.ts
+let ServerHttps = class ServerHttps extends Service {
+	httpKernel;
+	httpTerminator = null;
+	module;
+	server = null;
+	port;
+	protocol = "1.1";
+	ready = false;
+	type = "https";
+	domain;
+	scheme = "https";
+	address = null;
+	family = null;
+	active = false;
+	infos = null;
+	constructor(module, httpKernel) {
+		super("server-https", module.container, module.notificationsCenter, module.options.https);
+		this.httpKernel = httpKernel;
+		this.module = module;
+		this.active = !!this.kernel?.options.servers.https;
+		this.port = this.setPort();
+		this.domain = this.kernel?.domain;
+	}
+	terminator() {
+		if (this.server) return createDrainTerminator(this.server, this.options.shutdownTimeout);
+		throw new Error(`Server not found`);
+	}
+	setPort() {
+		if (this.kernel?.options.servers?.https) return this.kernel?.options.servers?.https?.port || 0;
+		return 0;
+	}
+	createServer() {
+		return new Promise((resolve, reject) => {
+			try {
+				if (!this.active) return reject(/* @__PURE__ */ new Error(`Server https is not allowed in config file `));
+				this.protocol = this.kernel?.options.servers.https.protocol;
+				if (this.protocol === "2.0") return resolve(this.createServerH2());
+				const opt = extend({
+					requestTimeout: this.options.requestTimeout,
+					rejectUnauthorized: this.options.rejectUnauthorized,
+					key: this.httpKernel?.serviceCerticats?.key,
+					cert: this.httpKernel?.serviceCerticats?.cert,
+					ca: this.httpKernel?.serviceCerticats?.ca ? this.httpKernel?.serviceCerticats?.ca : void 0
+				});
+				this.server = https.createServer(opt);
+				this.httpTerminator = this.terminator();
+				if (this.options.timeout) {
+					if (this.server) {
+						this.server.setTimeout(this.options.timeout, () => {
+							this.fire("onTimeout", this);
+						});
+						this.server.timeout = this.options.timeout;
+					}
+				}
+				if (this.options.maxHeadersCount) {
+					if (this.server) this.server.maxHeadersCount = this.options.maxHeadersCount;
+				}
+				if (this.options.keepAliveTimeout) {
+					if (this.server) this.server.keepAliveTimeout = this.options.keepAliveTimeout;
+				}
+				this.module.fire("onCreateServer", this.type, this);
+				this.listenWithPolicy().then(() => resolve(this.server)).catch((error) => {
+					this.reportBindError(error);
+					reject(error);
+				});
+				this.server.on("request", (request, response) => {
+					this.httpKernel?.onHttpRequest(request, response, this.type).catch(() => {});
+				});
+				this.kernel?.once("onTerminate", async () => {
+					if (!this.server) return;
+					try {
+						await this.httpTerminator?.terminate();
+						this.log(`${this.type} SHUTDOWN Server is listening on DOMAIN : ${this.domain}    PORT : ${this.port}`, "INFO");
+					} catch (e) {
+						this.log(e, "ERROR", "TERMINATE");
+					}
+				});
+				this.server.on("clientError", (e, socket) => {
+					this.fire("onClientError", e, socket);
+					handleClientError(e, socket);
+				});
+			} catch (e) {
+				this.log(e, "CRITIC");
+				return reject(e);
+			}
+		});
+	}
+	createServerH2() {
+		return new Promise((resolve, reject) => {
+			try {
+				const h2Cfg = (this.module?.options)?.http2 ?? {};
+				const opt = extend({
+					allowHTTP1: true,
+					rejectUnauthorized: this.options.rejectUnauthorized,
+					key: this.httpKernel?.serviceCerticats?.key,
+					cert: this.httpKernel?.serviceCerticats?.cert,
+					ca: this.httpKernel?.serviceCerticats?.ca ? this.httpKernel?.serviceCerticats?.ca : void 0
+				});
+				if (h2Cfg.maxSessionMemory) opt.maxSessionMemory = h2Cfg.maxSessionMemory;
+				if (h2Cfg.maxConcurrentStreams) opt.settings = {
+					...opt.settings,
+					maxConcurrentStreams: h2Cfg.maxConcurrentStreams
+				};
+				this.server = http2.createSecureServer(opt);
+				this.httpTerminator = this.terminator();
+				if (this.options.timeout) this.server.setTimeout(this.options.timeout, () => {
+					this.fire("onTimeout", this);
+				});
+				this.server.on("request", (request, response) => {
+					let alpnProtocol = false;
+					if (request && request.stream && request.stream.session?.socket) {
+						if (request.stream.session.socket instanceof TLSSocket) alpnProtocol = request.stream.session.socket.alpnProtocol;
+					}
+					if (request.socket) {
+						if (request.socket instanceof TLSSocket) alpnProtocol = request.socket.alpnProtocol;
+					}
+					if (alpnProtocol === "h2") return this.httpKernel?.onHttpRequest(request, response, "http2").catch(() => {});
+					else return this.httpKernel?.onHttpRequest(request, response, "https").catch(() => {});
+				});
+				this.listenWithPolicy().then(() => resolve(this.server)).catch((error) => {
+					this.reportBindError(error);
+					reject(error);
+				});
+				this.kernel?.once("onTerminate", async () => {
+					if (!this.server) return;
+					try {
+						await this.httpTerminator?.terminate();
+						this.log(`${this.type} SHUTDOWN Server is listening on DOMAIN : ${this.domain}    PORT : ${this.port}`, "INFO");
+					} catch (e) {
+						this.log(e, "ERROR", "TERMINATE");
+					}
+				});
+				this.server.on("sessionError", (error) => {
+					this.log(error, "ERROR", "HTTP2 Server sessionError");
+				});
+				this.server.on("streamError", (error) => {
+					this.log(error, "ERROR", "HTTP2 Server streamError");
+				});
+			} catch (e) {
+				return reject(e);
+			}
+		});
+	}
+	/**
+	* Écoute selon `servers.portPolicy`, commune aux deux branches TLS (HTTP/1.1 et
+	* HTTP/2) — leur seule différence est le type du serveur, pas la politique.
+	*
+	* Pose le handler d'erreur durable une fois en écoute (donc APRÈS les éventuels
+	* `EADDRINUSE` de repli, qui ne sont pas des pannes).
+	*/
+	async listenWithPolicy() {
+		const { address, shiftedFrom } = await bindWithFallback(this.server, this.domain, buildBindPlan("https", this.module.kernel?.options.servers, this.module.kernel?.environment));
+		this.infos = address;
+		this.port = address.port;
+		this.address = address.address;
+		this.family = address.family;
+		if (shiftedFrom !== null) this.log(`Port ${shiftedFrom} déjà occupé → HTTPS écoute sur ${this.port}. Figer le port : servers.https.port ; échouer au lieu de glisser : servers.portPolicy = "strict".`, "WARNING");
+		this.ready = true;
+		this.module.fire("onServersReady", this.type, this);
+		this.attachErrorHandler();
+	}
+	/** Erreurs de la VIE du serveur (le bind est déjà passé — cf server-http.ts). */
+	attachErrorHandler() {
+		this.server?.on("error", (error) => {
+			this.log(new nodefonyError(error), "CRITIC");
+		});
+	}
+	/** Bind définitivement impossible → FATAL (contrat inchangé). */
+	reportBindError(error) {
+		const myError = new nodefonyError(error);
+		switch (error.code) {
+			case "ENOTFOUND":
+				this.log(`CHECK DOMAIN IN /etc/hosts or config unable to connect to : ${this.domain}`, "ERROR");
+				this.log(myError, "CRITIC");
+				break;
+			case "EADDRINUSE":
+				this.log(`Port ${this.port} déjà occupé (domaine ${this.domain}) — le serveur HTTPS ne peut pas écouter. Libérer le port, en choisir un autre (servers.https.port), ou autoriser le repli automatique (servers.portPolicy = "auto", défaut en développement).`, "ERROR");
+				this.log(myError, "CRITIC");
+				break;
+			default: this.log(myError, "CRITIC");
+		}
+		this.server?.close();
+		setTimeout(() => this.kernel?.terminate(1), 1e3);
+	}
+	showBanner() {
+		if (this.infos) this.log(`Server Listen on ${this.scheme}://${this.infos.address}:${this.infos.port} Family: ${this.infos.family} Protocol : ${this.protocol}`);
+	}
+};
+ServerHttps = __decorate([__decorateParam(1, inject("HttpKernel")), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module, typeof http_kernel_default === "undefined" ? Object : http_kernel_default])], ServerHttps);
+var server_https_default = ServerHttps;
+//#endregion
+export { server_https_default as default };

package/dist/nodefony/service/servers/server-static.js

@@ -0,0 +1,192 @@
+import { Service, extend } from "nodefony";
+import { URL } from "node:url";
+import http from "node:http";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import mime from "mime-types";
+import http2 from "node:http2";
+import tls from "node:tls";
+import serveStatic from "serve-static";
+//#region nodefony/service/servers/server-static.ts
+const defaultOptions = {
+	cacheControl: true,
+	maxAge: 345600
+};
+var Statics = class extends Service {
+	module;
+	servers;
+	/** Montages préfixés (prod frontend). Lazy : `[]` rempli à `addMount`. */
+	mounts = [];
+	/**
+	* Serveur statique config-driven actif. `false` (config `statics.enabled`) =
+	* aucun montage `web`/`assets`, 0 listener — quand un reverse-proxy/CDN sert
+	* les statiques. Ne gate PAS les `addMount()` programmatiques (frontend prod).
+	*/
+	enabled = true;
+	defaultOptions = defaultOptions;
+	constructor(module) {
+		const container = module.container || void 0;
+		const options = module.options.statics || {};
+		let event;
+		if (container) event = container.get("notificationsCenter");
+		super("server-static", container, event, options);
+		this.module = module;
+		this.servers = {};
+		this.enabled = this.options.enabled !== false;
+		if (typeof this.options.enabled !== "undefined") delete this.options.enabled;
+		this.defaultOptions = extend(defaultOptions, this.options.defaultOptions || {});
+		if (this.options.defaultOptions) delete this.options.defaultOptions;
+		if (this.enabled) this.initStaticFiles();
+		else this.log("Static file server DISABLED (statics.enabled=false) — reverse-proxy/CDN attendu", "INFO");
+		this.kernel?.once("onReady", () => {
+			this.mountModulePublics();
+		});
+		this.kernel?.on("onPostReady", () => {
+			if (this.kernel?.suppressBootBanners) return;
+			for (const ele in this.servers) this.log(`Server Listen on ${ele}`, "INFO");
+		});
+	}
+	/**
+	* Auto-monte le `public/` de chaque module applicatif sous le préfixe natif
+	* `/<module>/` (basename du nom — `@nodefony/test` → `/test/`). Appelé une fois
+	* à `onReady`. Idempotent via {@link addMount} (un même préfixe est remplacé).
+	*
+	* Exclusions :
+	* - **app root** (`isApp`) — son `public/` est servi à la racine `/` par la
+	*   racine statique `web` (favicon…), sans préfixe.
+	* - **modules frontend-managed** (présents dans `frontend.listEntries()`) —
+	*   leurs assets buildés sont servis sous `/_assets/<name>/` par
+	*   `@nodefony/frontend` ; on ne double-sert pas leur `public/dist`.
+	* - **modules sans `public/`** — rien à monter (http, framework, security…).
+	*
+	* Enregistré dans {@link mounts} quel que soit `enabled` → la carte
+	* préfixe→dossier reste lisible par `proxy:generate` même statiques désactivés
+	* (reverse-proxy/CDN en prod).
+	*/
+	mountModulePublics() {
+		const modules = this.kernel?.modules;
+		if (!modules) return;
+		const frontend = this.container?.get("frontend");
+		const frontManaged = frontend?.listEntries ? new Set(frontend.listEntries().map((e) => e.moduleName)) : null;
+		for (const name in modules) {
+			const mod = modules[name];
+			if (!mod || mod.isApp) continue;
+			const cfg = mod.options?.publicMount;
+			if (cfg === false) continue;
+			if (cfg == null && frontManaged?.has(mod.name)) continue;
+			const dir = join(mod.path, cfg?.dir || "public");
+			if (!existsSync(dir)) continue;
+			const prefix = cfg?.publicPath || `/${mod.name.split("/").pop()}/`;
+			this.addMount(prefix, dir);
+		}
+	}
+	initStaticFiles() {
+		for (const staticRoot in this.options) {
+			let Path = this.options[staticRoot].path;
+			Path = this.kernel?.checkPath(Path);
+			let setHeaders = null;
+			const opt = this.options[staticRoot].options || {};
+			if (opt.setHeaders) {
+				if (typeof opt.setHeaders === "function") {
+					setHeaders = opt.setHeaders;
+					delete opt.setHeaders;
+				}
+			}
+			opt.setHeaders = (res, path) => {
+				this.log(`Render ${path}`, "DEBUG", `SERVE STATIC ${staticRoot}`);
+				this.fire("onServeStatic", res, path, staticRoot, this);
+			};
+			if (setHeaders) this.on("onServeStatic", setHeaders);
+			this.addDirectory(Path, opt);
+		}
+	}
+	/**
+	* Monte un dossier sous un préfixe public (ex `/_assets/studio/` → outDir).
+	* Le préfixe est normalisé (leading + trailing `/`). Idempotent : un même
+	* préfixe est remplacé. Consommé par `@nodefony/frontend` en prod (assets
+	* Vite buildés) — résolu par nom via le Container, sans import croisé.
+	*
+	* @param prefix préfixe d'URL public
+	* @param dir dossier absolu à servir
+	*/
+	addMount(prefix, dir) {
+		let p = prefix.trim();
+		if (!p.startsWith("/")) p = `/${p}`;
+		if (!p.endsWith("/")) p = `${p}/`;
+		p = p.replace(/\/{2,}/g, "/");
+		const server = serveStatic(dir, extend({}, this.defaultOptions));
+		const entry = {
+			prefix: p,
+			server,
+			dir
+		};
+		const i = this.mounts.findIndex((m) => m.prefix === p);
+		if (i >= 0) this.mounts[i] = entry;
+		else this.mounts.push(entry);
+		this.log(`mount ${p} → ${dir}`, "INFO");
+	}
+	/** `true` si au moins un montage préfixé est actif (gate du pipeline). */
+	hasMounts() {
+		return this.mounts.length > 0;
+	}
+	addDirectory(Path, options) {
+		if (!Path) throw new Error("Static file path not Defined ");
+		const opt = extend({}, this.defaultOptions, options);
+		const server = serveStatic(Path, opt);
+		this.servers[Path] = server;
+		return server;
+	}
+	getStatic(server, request, response) {
+		return new Promise((resolve, reject) => {
+			server(request, response, (err) => {
+				if (err) return reject(err);
+				return resolve(response);
+			});
+		});
+	}
+	getUrl(request) {
+		let scheme, host;
+		if (request instanceof http.IncomingMessage) {
+			scheme = request.connection instanceof tls.TLSSocket && request.connection.encrypted ? "https" : "http";
+			host = request.headers.host;
+			return scheme + "://" + host;
+		} else if (request instanceof http2.Http2ServerRequest) {
+			scheme = request.socket instanceof tls.TLSSocket && request.socket.encrypted ? "https" : "http";
+			host = request.headers[":authority"];
+			return scheme + "://" + host;
+		}
+		throw new Error(`Bad request type`);
+	}
+	async handle(request, response) {
+		if (!this.enabled && this.mounts.length === 0) return Promise.resolve(response);
+		const baseURL = this.getUrl(request);
+		const { pathname } = new URL(request.url, baseURL);
+		if (!pathname) throw new Error(`Bad url ${request.url}`);
+		if (this.mounts.length > 0) {
+			const raw = request.url;
+			for (const m of this.mounts) {
+				if (!raw.startsWith(m.prefix)) continue;
+				request.url = `/${raw.slice(m.prefix.length)}`;
+				try {
+					await this.getStatic(m.server, request, response);
+					request.url = raw;
+				} catch (e) {
+					request.url = raw;
+					return Promise.reject(e);
+				}
+				break;
+			}
+		}
+		for (const server in this.servers) try {
+			let ele = this.servers[server];
+			await this.getStatic(ele, request, response);
+			const type = mime.lookup(pathname);
+			response.setHeader("Content-Type", type);
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		return Promise.resolve(response);
+	}
+};
+//#endregion
+export { Statics as default };