@nodefony/frontend 10.0.0-alpha.1

package/dist/nodefony/service/FrontendService.js

@@ -0,0 +1,708 @@
+import config from "../config/config.js";
+import { FrontendNoEntriesError, FrontendSupervisorStartError } from "../src/errors/FrontendError.js";
+import { ViteBuilder } from "../src/builders/ViteBuilder.js";
+import { allowedHostPatternForTemplate, detectRemoteDev, isValidOriginTemplate, viteAllowedHostFromPattern } from "../src/remoteDev.js";
+import { ViteProcessSupervisor } from "./ViteProcessSupervisor.js";
+import { TemplateHelper } from "../src/template/TemplateHelper.js";
+import { familyPortBlocks, familyPortPlan, isolationGroup } from "../src/isolationGroups.js";
+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 { Module, Service, extend, injectable, stripTrailingSlashes } from "nodefony";
+import path from "node:path";
+import fs from "node:fs";
+//#region nodefony/service/FrontendService.ts
+/**
+* Normalise un préfixe public : garantit un `/` en tête et en queue.
+* `"_assets/x"` → `"/_assets/x/"`, `"/"` → `"/"`.
+*/
+const normalizePublicPath = (p) => {
+	let s = p.trim();
+	if (!s.startsWith("/")) s = `/${s}`;
+	if (!s.endsWith("/")) s = `${s}/`;
+	return s.replace(/\/{2,}/g, "/");
+};
+/**
+* Service injectable du module `@nodefony/frontend`.
+*
+* Cycle de vie :
+*  1. construction : merge options par défaut + surcharge app (`module-frontend`).
+*  2. `onKernelReady` : si dev + `autoStartInDevelopment` → start superviseur.
+*  3. modules consommateurs appellent `registerEntry(...)` dans leur init.
+*  4. terminate kernel : `stop()` superviseur.
+*
+* Branche POC `poc/frontend-child` : utilise `ViteProcessSupervisor` (spawn).
+* Branche POC `poc/frontend-single` : remplacera par `ViteInProcSupervisor`.
+*/
+let FrontendService = class FrontendService extends Service {
+	module;
+	cfg;
+	builder = new ViteBuilder();
+	entries = [];
+	/** Une instance Vite par famille d'isolation (`default`, `angular`, …). */
+	supervisors = /* @__PURE__ */ new Map();
+	/** Template helper par famille (route les `<script>` vers le bon port Vite). */
+	templateHelpers = /* @__PURE__ */ new Map();
+	/** Index inverse `entryName → famille`, pour router `renderTags`. */
+	entryFamily = /* @__PURE__ */ new Map();
+	/** Helper prod unique (lit les manifests) — `null` tant qu'on n'est pas en prod. */
+	prodHelper = null;
+	/**
+	* L'origine publique est-elle ÉPINGLÉE par une décision explicite
+	* (`frontend.publicOrigin` en config, ou plateforme de dev déporté détectée) ?
+	* `true` → la dérivation par `Host` est désactivée : un réglage voulu gagne
+	* toujours sur une déduction (cf ordre de priorité, README du module).
+	*/
+	originPinned = false;
+	/**
+	* Ports que l'instance Vite de chaque famille PEUT prendre pour ce démarrage
+	* (bloc de la famille, port-retry compris) — `null` tant que `startDev` n'a
+	* pas établi le plan, et remis à `null` par `stopDev`.
+	*
+	* Alloué une fois par démarrage de développement, jamais en production
+	* (`startDev` n'y tourne pas) : aucun coût par requête.
+	*/
+	plannedPortBlocks = null;
+	constructor(module) {
+		const merged = extend(true, {}, config, module.options ?? {});
+		super("frontend", module.container, module.notificationsCenter, merged);
+		this.module = module;
+		this.cfg = merged;
+	}
+	/** Base CDN normalisée (sans slash final). `""` = origine Nodefony. */
+	get assetBase() {
+		return stripTrailingSlashes(this.cfg.assetBaseUrl ?? "");
+	}
+	/**
+	* Résout l'URL publique d'un asset. Préfixe `p` par `assetBaseUrl` (CDN) si
+	* renseigné, sinon le renvoie tel quel (origine, chemin relatif). Les URLs
+	* absolues (`http(s)://…`) sont renvoyées inchangées. Helper template :
+	* `asset('/test/logo.png')` → `https://cdn.example.com/test/logo.png` ou
+	* `/test/logo.png` (assetBaseUrl vide).
+	*/
+	assetUrl(p) {
+		if (/^https?:\/\//i.test(p)) return p;
+		const base = this.assetBase;
+		if (!base) return p;
+		return base + (p.startsWith("/") ? p : `/${p}`);
+	}
+	async init() {
+		this.log(`MODULE frontend service init`, "DEBUG");
+		this.kernel?.once("onServersReady", async () => {
+			const env = this.kernel?.environment;
+			if (env === "development" && this.cfg.autoStartInDevelopment) {
+				if (this.entries.length === 0) {
+					this.log("no frontend entries declared — Vite supervisor not started", "INFO");
+					return;
+				}
+				const names = this.entries.map((e) => e.entryName);
+				this.kernel?.fire("onFrontendStart", { bundles: names.length });
+				try {
+					await this.startDev();
+				} catch (e) {
+					this.log(e, "ERROR");
+				} finally {
+					let ready = 0;
+					for (const [, sup] of this.supervisors) {
+						const st = sup.status();
+						if (st.state !== "ready") continue;
+						ready++;
+						const scheme = st.https ? "https" : "http";
+						const url = `${st.origin ?? `${scheme}://${st.host}:${st.port}`}/`;
+						for (const e of st.entries) {
+							const fw = e.type.replace(/[0-9]+$/, "");
+							this.kernel?.reportBootLine("Frontend (Vite)", `${e.entryName.padEnd(24)}${url}${fw ? `   ${fw}` : ""}`);
+						}
+					}
+					this.kernel?.fire("onFrontendReady", {
+						bundles: names.length,
+						names,
+						ready
+					});
+				}
+			} else if (env !== "development") await this.setupProd();
+		});
+		this.kernel?.once("onTerminate", async () => {
+			try {
+				await this.stopDev();
+			} catch {}
+		});
+		return this;
+	}
+	/**
+	* Enregistre une déclaration frontend d'un module consommateur.
+	*
+	* À appeler dans le `initialize()` ou `onKernelReady()` du module
+	* consommateur — toujours AVANT `onReady` du kernel (sinon le supervisor
+	* démarre sans cette entrée).
+	*/
+	registerEntry(consumerModule, declaration) {
+		const moduleRoot = consumerModule.path ?? process.cwd();
+		const root = path.resolve(moduleRoot, declaration.root ?? this.cfg.defaultRoot);
+		const outDir = path.resolve(moduleRoot, declaration.outDir ?? this.cfg.defaultOutDir);
+		const absEntry = path.resolve(moduleRoot, declaration.entry);
+		const relEntry = path.relative(root, absEntry);
+		const entryName = declaration.name ?? consumerModule.name;
+		const entry = {
+			moduleName: consumerModule.name,
+			entryName,
+			type: declaration.type,
+			root,
+			entryFile: relEntry,
+			outDir,
+			publicPath: normalizePublicPath(declaration.publicPath ?? `/_assets/${entryName}`),
+			apiProxyPaths: declaration.apiProxyPaths ?? []
+		};
+		this.entries.push(entry);
+		this.log(`registered entry: ${entry.entryName} (${entry.type}) from "${entry.moduleName}"`, "INFO");
+		return entry;
+	}
+	listEntries() {
+		return this.entries;
+	}
+	status() {
+		const primary = this.supervisors.get("default") ?? [...this.supervisors.values()][0];
+		if (!primary) return {
+			state: "idle",
+			host: this.cfg.devHost,
+			origin: null,
+			port: null,
+			pid: null,
+			https: !!this.cfg.https,
+			restartCount: 0,
+			healthFailures: 0,
+			portRetries: 0,
+			lastError: null,
+			entries: this.entries
+		};
+		return primary.status();
+	}
+	statusAll() {
+		return [...this.supervisors.entries()].map(([family, s]) => ({
+			family,
+			status: s.status()
+		}));
+	}
+	/**
+	* Démarre une instance Vite **par famille d'isolation** (multi-supervisor).
+	*
+	* Résilience : chaque famille démarre indépendamment (`Promise.allSettled`).
+	* Une famille qui échoue (ex. Angular) est isolée — elle ne fait jamais
+	* échouer les autres ni le backend. `startDev` ne rejette que si **aucune**
+	* famille n'a pu démarrer.
+	*/
+	async startDev() {
+		if (this.entries.length === 0) throw new FrontendNoEntriesError();
+		if (this.supervisors.size > 0 && [...this.supervisors.values()].some((s) => s.status().state === "ready")) return;
+		const backendOrigin = `${this.cfg.backendProtocol}://${this.cfg.backendHost}:${this.resolveBackendPort()}`;
+		const https = this.resolveHttps();
+		const publicOriginTemplate = this.resolvePublicOriginTemplate();
+		this.originPinned = publicOriginTemplate !== void 0;
+		const allowedHosts = this.viteAllowedHosts(publicOriginTemplate);
+		const nodeEnv = this.kernel?.environment;
+		const extraEnv = this.cfg.viteEnv ?? {};
+		const groups = this.groupEntriesByFamily();
+		const portPlan = familyPortPlan(this.cfg.devPort, [...groups.keys()], this.cfg.resilience?.portRetryAttempts ?? 3);
+		const families = [...portPlan.keys()];
+		if (publicOriginTemplate && !publicOriginTemplate.includes("{port}") && families.length > 1) this.log(`publicOrigin figée (« ${publicOriginTemplate} ») avec ${families.length} familles Vite (${families.join(", ")}) — une origine ne peut en servir qu'UNE : utiliser {port} (ex. https://host:{port}) pour suivre chaque famille`, "WARNING");
+		this.plannedPortBlocks = familyPortBlocks(portPlan, this.cfg.resilience?.portRetryAttempts ?? 3);
+		this.#registerCsp();
+		this.fire("frontend:starting", {
+			backendOrigin,
+			entries: this.entries
+		});
+		const total = this.entries.length;
+		let done = 0;
+		(await Promise.allSettled(families.map((family) => {
+			const famSize = groups.get(family).length;
+			return this.startFamily(family, groups.get(family), portPlan.get(family), {
+				backendOrigin,
+				https,
+				nodeEnv,
+				extraEnv,
+				publicOriginTemplate,
+				allowedHosts
+			}).finally(() => {
+				done += famSize;
+				this.kernel?.fire("onFrontendProgress", {
+					ready: done,
+					total
+				});
+			});
+		}))).forEach((res, i) => {
+			if (res.status === "rejected") {
+				const reason = res.reason;
+				this.log(`frontend family "${families[i]}" failed to start (isolated): ${reason?.message ?? reason}`, "ERROR");
+			}
+		});
+		if ([...this.supervisors.values()].filter((s) => s.status().state === "ready").length === 0) {
+			const err = new FrontendSupervisorStartError("no frontend family could start");
+			this.fire("frontend:error", err);
+			throw err;
+		}
+		this.#registerCsp();
+		this.fire("frontend:ready", this.status());
+	}
+	/**
+	* Port backend que Vite doit proxifier — le port RÉELLEMENT écouté, pas celui
+	* qu'on espérait.
+	*
+	* `config.backendPort` (5151) n'est qu'une intention : avec
+	* `servers.portPolicy: "auto"`, un port occupé fait glisser l'écoute du backend
+	* (5151 → 5153). Un proxy figé sur 5151 enverrait alors les appels API du front
+	* vers le serveur d'une AUTRE app — au mieux des 404, au pire les données du
+	* voisin. On lit donc le port sur le serveur lui-même.
+	*
+	* Résolution par NOM (`server-http`), jamais par import : `@nodefony/frontend`
+	* ne dépend pas de `@nodefony/http` (cycle via la config d'app).
+	*/
+	resolveBackendPort() {
+		const server = this.container?.get?.("server-http");
+		const real = server?.active && server.port ? server.port : 0;
+		if (real > 0 && real !== this.cfg.backendPort) this.log(`backend à l'écoute sur ${real} (et non ${this.cfg.backendPort}) — le proxy Vite suit le port réel`, "INFO");
+		return real > 0 ? real : this.cfg.backendPort;
+	}
+	/**
+	* Résout les certificats HTTPS partagés (service `certificates` de
+	* @nodefony/http) si `https: true`. Pas de duplication — mêmes PEM que
+	* `server-https` (5152). Retombe sur HTTP avec un warning si indisponible.
+	*/
+	resolveHttps() {
+		if (!this.cfg.https) return void 0;
+		const certs = this.container?.get?.("certificates");
+		if (!certs?.privateKeyPath || !certs?.certPath) {
+			this.log("https: true requested but `certificates` service unavailable — falling back to HTTP", "WARNING");
+			return;
+		}
+		return {
+			keyPath: certs.privateKeyPath,
+			certPath: certs.certPath
+		};
+	}
+	/**
+	* Template d'origine publique Vite (P14.17). Priorité : `frontend.publicOrigin`
+	* (config, validée — invalide = ERROR + ignorée, jamais un boot cassé) puis
+	* détection de plateforme (Codespaces/Gitpod — variables documentées de la
+	* plateforme, qu'on lit sans les posséder). `undefined` = dérivation locale.
+	* Chaque adaptation est JOURNALISÉE : on doit pouvoir lire dans le boot
+	* pourquoi les `<script>` pointent où ils pointent.
+	*/
+	resolvePublicOriginTemplate() {
+		const cfgOrigin = this.cfg.publicOrigin;
+		if (cfgOrigin) {
+			if (!isValidOriginTemplate(cfgOrigin)) {
+				this.log(`frontend.publicOrigin invalide (« ${cfgOrigin} ») — attendu scheme://host[:port|:{port}] sans chemin ; origine locale utilisée`, "ERROR");
+				return;
+			}
+			this.log(`origine publique Vite (config) : ${cfgOrigin}`, "INFO");
+			return cfgOrigin;
+		}
+		const detected = detectRemoteDev(process.env);
+		if (detected) {
+			this.log(`dev déporté détecté (${detected.provider}) — origine publique Vite : ` + detected.originTemplate, "INFO");
+			return detected.originTemplate;
+		}
+	}
+	/**
+	* `server.allowedHosts` pour Vite. Vite accepte d'office IP et `localhost` ;
+	* cette liste ne porte que les NOMS. Source des noms légitimes = la MÊME que
+	* la barrière Host de Nodefony (`kernel.domain` + `trustedHosts` http) — une
+	* seule liste à maintenir : autoriser un hôte dans `trustedHosts` ouvre à la
+	* fois la barrière 421 ET Vite. S'y ajoute l'hôte du template d'origine
+	* publique. `trustedHosts: true` (barrière déléguée au reverse-proxy) →
+	* `true` (même délégation). Un pattern non exprimable chez Vite est ANNONCÉ.
+	*/
+	viteAllowedHosts(publicOriginTemplate) {
+		const th = (this.container?.get?.("HttpKernel"))?.trustedHosts;
+		if (th === true) return true;
+		const hosts = /* @__PURE__ */ new Set();
+		if (this.kernel?.domain) {
+			const d = viteAllowedHostFromPattern(this.kernel.domain);
+			if (d) hosts.add(d);
+		}
+		const patterns = Array.isArray(th) ? th : th ? [th] : [];
+		for (const p of patterns) {
+			if (typeof p !== "string") continue;
+			const v = viteAllowedHostFromPattern(p);
+			if (v) hosts.add(v);
+			else this.log(`trustedHosts « ${p} » non exprimable en allowedHosts Vite — cet hôte passera la barrière Nodefony mais Vite le refusera`, "WARNING");
+		}
+		if (publicOriginTemplate) {
+			const v = allowedHostPatternForTemplate(publicOriginTemplate);
+			if (v) hosts.add(v);
+		}
+		return hosts.size > 0 ? [...hosts] : void 0;
+	}
+	/** Regroupe les entries par famille d'isolation + remplit l'index inverse. */
+	groupEntriesByFamily() {
+		const groups = /* @__PURE__ */ new Map();
+		this.entryFamily.clear();
+		for (const entry of this.entries) {
+			const family = isolationGroup(entry.type);
+			this.entryFamily.set(entry.entryName, family);
+			const arr = groups.get(family);
+			if (arr) arr.push(entry);
+			else groups.set(family, [entry]);
+		}
+		return groups;
+	}
+	/**
+	* Démarre l'instance Vite d'une famille sur un port dédié. Enregistre le
+	* supervisor + son template helper AVANT le `start()` (l'état dégradé reste
+	* observable même si le démarrage échoue → rendu propre, pas d'exception).
+	*/
+	async startFamily(family, entries, port, ctx) {
+		const r = this.cfg.resilience ?? {};
+		const supervisor = new ViteProcessSupervisor({
+			devHost: this.cfg.devHost,
+			devPort: port,
+			publicOriginTemplate: ctx.publicOriginTemplate,
+			allowedHosts: ctx.allowedHosts,
+			startupTimeoutMs: this.cfg.startupTimeoutMs,
+			pipeLogs: this.cfg.pipeViteLogs,
+			cwd: entries[0].root,
+			backendOrigin: ctx.backendOrigin,
+			https: ctx.https,
+			nodeEnv: ctx.nodeEnv,
+			extraEnv: ctx.extraEnv,
+			autoRestart: r.autoRestart,
+			maxRestarts: r.maxRestarts,
+			restartBackoffBaseMs: r.restartBackoffBaseMs,
+			restartBackoffMaxMs: r.restartBackoffMaxMs,
+			healthCheckIntervalMs: r.healthCheckIntervalMs,
+			healthCheckFailureThreshold: r.healthCheckFailureThreshold,
+			healthCheckTimeoutMs: r.healthCheckTimeoutMs,
+			portRetryAttempts: r.portRetryAttempts,
+			logger: {
+				info: (m) => this.log(`[${family}] ${m}`, "INFO"),
+				error: (m) => this.log(`[${family}] ${m}`, "ERROR"),
+				debug: (m) => this.log(`[${family}] ${m}`, "DEBUG")
+			}
+		});
+		this.supervisors.set(family, supervisor);
+		this.templateHelpers.set(family, new TemplateHelper(supervisor, "development"));
+		const cfg = await this.builder.buildViteConfig([...entries], "development");
+		await supervisor.start(entries, cfg);
+		this.log(`vite [${family}] ready on ${supervisor.status().host}:${supervisor.status().port}`, "INFO");
+	}
+	/**
+	* Câblage prod (idempotent) : monte chaque `outDir` sur son `publicPath`
+	* auprès du serveur statique `server-static` (résolu par nom — pas d'import
+	* http) et crée le helper prod (lecture manifests). No-op si pas d'entrée.
+	*
+	* Une entrée SANS build servirait une page blanche : jamais en silence.
+	* Cas nominal cloud-native : le build est fait à l'image (`npm run build`,
+	* qui chaîne `frontend:build` dans les apps générées) → manifest présent,
+	* zéro travail ici. Cas « prod essayée sur le poste » (devDeps installées →
+	* vite résolvable) : build one-shot au boot — idempotent, et il supprime
+	* l'écran blanc qui perd l'utilisateur, surtout en `--detach`. Sans vite
+	* (image runtime sans devDependencies) : impossible de réparer ici → on
+	* NOMME l'entrée, le manifest attendu et le geste, en ERROR.
+	* Cf project_resilience_no_silent_degradation (fail-soft dispo, fail-loud
+	* dégradation — tout fallback annoncé).
+	*/
+	async setupProd() {
+		if (this.prodHelper) return;
+		if (this.entries.length === 0) {
+			this.log("no frontend entries declared — prod static not mounted", "INFO");
+			return;
+		}
+		const unbuilt = this.entries.filter((e) => !fs.existsSync(path.join(e.outDir, ".vite", "manifest.json")));
+		if (unbuilt.length > 0) {
+			const names = unbuilt.map((e) => e.entryName).join(", ");
+			try {
+				this.log(`entrée(s) frontend sans build (${names}) — construction au boot (one-shot). En production réelle, builde à l'image : npm run build.`, "WARNING");
+				const r = await this.build();
+				if (r.failures.length > 0) this.log(`build front en ÉCHEC au boot (${r.failures.map((f) => f.entryName).join(", ")}) — ces pages seront servies SANS interface`, "ERROR");
+			} catch (e) {
+				this.log(`entrée(s) frontend sans build (${names}) et vite indisponible ici — les pages seront servies SANS interface (blanches). Builde AVANT de lancer : npm run build (ou nodefony frontend:build), puis redémarre. Si vite manque aussi en développement, il n'est pas une dépendance de ce module : installe-le côté application (npm i -D vite, plus le plugin de ton framework). Détail : ${e instanceof Error ? e.message : String(e)}`, "ERROR");
+			}
+		}
+		const stat = this.container?.get?.("server-static");
+		if (stat?.addMount) for (const e of this.entries) {
+			stat.addMount(e.publicPath, e.outDir);
+			this.log(`prod static mount ${e.publicPath} → ${e.outDir}`, "INFO");
+		}
+		else this.log("server-static service unavailable — assets won't be served by Nodefony (expecting a frontal proxy)", "WARNING");
+		this.prodHelper = new TemplateHelper(null, "production", this.entries, this.assetBase);
+		this.fire("frontend:ready", this.status());
+	}
+	async stopDev() {
+		if (this.supervisors.size === 0) return;
+		await Promise.allSettled([...this.supervisors.values()].map((s) => s.stop()));
+		this.supervisors.clear();
+		this.templateHelpers.clear();
+		this.entryFamily.clear();
+		this.plannedPortBlocks = null;
+		(this.container?.get?.("firewall"))?.unregisterCspOrigins?.("frontend");
+		this.fire("frontend:stopped");
+	}
+	/**
+	* Build production — `vite.build()` **par entry** (chaque bundle a son propre
+	* `root`/`outDir`/`base`/`manifest` : multi-module + isolation Angular).
+	*
+	* Idempotent : une entrée dont le `manifest.json` est plus récent que ses
+	* sources est **ignorée** (`skipped`) — relance prod console rapide. `force`
+	* rebuild tout. Les échecs sont **collectés** (un bundle KO n'arrête pas les
+	* autres) et remontés dans `failures` → la commande CLI casse l'exit code.
+	*
+	* ⚠️ **`NODE_ENV` est posé le temps du build, et restauré.** Vite dérive son
+	* `isProduction` de `process.env.NODE_ENV`, qui **prime sur le `mode`** de la
+	* configuration : une commande CLI, dont le kernel démarre en développement,
+	* produisait donc un bundle de DÉVELOPPEMENT malgré `mode: "production"` —
+	* `import.meta.env.DEV` vrai chez l'utilisateur final (tout code gardé par ce
+	* drapeau s'exécutait en production), et les messages d'aide de Vue publiés.
+	* La restauration n'est pas une précaution de style : `build()` est aussi
+	* appelé par `setupProd()`, et laisser la variable retournée marquerait un
+	* process de développement comme production pour le reste de sa vie.
+	*
+	* @param opts.force ignore le cache de fraîcheur (rebuild systématique).
+	*/
+	async build(opts) {
+		if (this.entries.length === 0) throw new FrontendNoEntriesError();
+		const vite = await import("vite");
+		const result = {
+			built: [],
+			skipped: [],
+			failures: []
+		};
+		const nodeEnvBefore = process.env.NODE_ENV;
+		process.env.NODE_ENV = "production";
+		try {
+			return await this.#buildEntries(vite, result, opts);
+		} finally {
+			if (nodeEnvBefore === void 0) delete process.env.NODE_ENV;
+			else process.env.NODE_ENV = nodeEnvBefore;
+		}
+	}
+	/**
+	* La boucle de build proprement dite — extraite pour que `build()` ne porte
+	* que la garde d'environnement, et que le `finally` de restauration couvre
+	* tous les chemins de sortie sans indenter cent lignes.
+	*/
+	async #buildEntries(vite, result, opts) {
+		for (const entry of this.entries) {
+			if (!opts?.force && this.isBuildFresh(entry)) {
+				result.skipped.push(entry.entryName);
+				this.log(`build skip "${entry.entryName}" (à jour — --force pour forcer)`, "INFO");
+				continue;
+			}
+			try {
+				const cfg = await this.builder.buildViteConfig([entry], "production", this.assetBase);
+				await vite.build(cfg);
+				result.built.push(entry.entryName);
+				this.log(`build ok "${entry.entryName}" → ${entry.outDir}`, "INFO");
+			} catch (e) {
+				const message = e instanceof Error ? e.message : String(e);
+				result.failures.push({
+					entryName: entry.entryName,
+					message
+				});
+				this.log(`build FAILED "${entry.entryName}": ${message}`, "ERROR");
+			}
+		}
+		this.log(`frontend build: ${result.built.length} built, ${result.skipped.length} skipped, ${result.failures.length} failed`, result.failures.length ? "WARNING" : "INFO");
+		return result;
+	}
+	/**
+	* Une entrée est « fraîche » si son `manifest.json` existe ET qu'aucun fichier
+	* source (sous `root`, hors `node_modules`/`outDir`/`.vite`) n'est plus récent.
+	* Scan disque borné (dossier front petit) — évite un rebuild Vite inutile.
+	*/
+	isBuildFresh(entry) {
+		let manifestMtime;
+		try {
+			manifestMtime = fs.statSync(path.join(entry.outDir, ".vite", "manifest.json")).mtimeMs;
+		} catch {
+			return false;
+		}
+		return this.newestSourceMtime(entry.root, entry.outDir) <= manifestMtime;
+	}
+	/** Mtime du fichier le plus récent sous `dir` (récursif borné). */
+	newestSourceMtime(dir, outDir) {
+		let newest = 0;
+		const walk = (d) => {
+			let items;
+			try {
+				items = fs.readdirSync(d, { withFileTypes: true });
+			} catch {
+				return;
+			}
+			for (const it of items) {
+				if (it.name === "node_modules" || it.name === ".vite") continue;
+				const full = path.join(d, it.name);
+				if (full === outDir) continue;
+				if (it.isDirectory()) walk(full);
+				else try {
+					const m = fs.statSync(full).mtimeMs;
+					if (m > newest) newest = m;
+				} catch {}
+			}
+		};
+		walk(dir);
+		return newest;
+	}
+	/**
+	* Document HTML complet pour une entrée — lit l'`index.html` du module
+	* (le dev y met meta/polices/scripts externes) + injecte les tags Nodefony.
+	* Le controller renvoie : `this.render(svc.renderDocument("x", this.context.cspNonce))`.
+	* @param nonce nonce CSP de la requête (`Context.cspNonce`) — propagé aux `<script>`.
+	*/
+	renderDocument(entryName, nonce, requestHost) {
+		if (this.prodHelper) return this.prodHelper.renderDocument(entryName, nonce);
+		const family = this.entryFamily.get(entryName);
+		const helper = family ? this.templateHelpers.get(family) : void 0;
+		if (!helper) return `<!-- @nodefony/frontend: helper not initialized for "${entryName}" -->`;
+		return helper.renderDocument(entryName, nonce, this.derivableHost(requestHost));
+	}
+	renderTags(entryName, nonce, requestHost) {
+		if (this.prodHelper) return this.prodHelper.renderTags(entryName, nonce);
+		const family = this.entryFamily.get(entryName);
+		const helper = family ? this.templateHelpers.get(family) : void 0;
+		if (!helper) return `<!-- @nodefony/frontend: helper not initialized for "${entryName}" -->`;
+		return helper.renderTags(entryName, nonce, this.derivableHost(requestHost));
+	}
+	/**
+	* Le `Host` de la requête peut-il servir à dériver l'origine des assets ?
+	*
+	* Trois conditions, dans cet ordre — chacune protège un cas RÉEL :
+	*  1. **origine non épinglée** : un `frontend.publicOrigin` explicite (ou une
+	*     plateforme de dev déporté détectée) est une décision de l'auteur, elle
+	*     gagne toujours sur une déduction ;
+	*  2. **barrière `trustedHosts` franchie** : le `Host` est une donnée
+	*     CLIENTE. Sans ce filtre, un `Host` forgé ferait émettre des
+	*     `<script src="https://attaquant:5173/…">` dans une page de dev ;
+	*  3. **barrière non déléguée** (`trustedHosts !== true`) : le bypass total
+	*     ne dit plus rien de la légitimité d'un nom, et surtout le CSP émis par
+	*     le firewall (`#viteCspFragment`) ne couvre alors QUE loopback +
+	*     domaine canonique — dériver ailleurs produirait une page dont les
+	*     scripts sont bloqués. Les deux listes doivent rester la même liste.
+	*
+	* @returns le nom d'hôte à employer, ou `undefined` pour garder l'origine
+	*   résolue au démarrage (comportement d'avant la dérivation).
+	*/
+	derivableHost(requestHost) {
+		if (!requestHost || this.originPinned) return void 0;
+		const httpKernel = this.container?.get?.("HttpKernel");
+		if (!httpKernel || httpKernel.trustedHosts === true) return void 0;
+		return httpKernel.isTrustedHostname?.(requestHost) === true ? requestHost : void 0;
+	}
+	/**
+	* Déclare les origines Vite dev au firewall `@nodefony/security` (résolution PAR
+	* NOM = anti-cycle, comme `setupProd`/`server-static`). Le firewall émet alors UN
+	* seul CSP (nonce + origines mergées) → remplace le hack `setHeader` des controllers.
+	* No-op si security absent (app sans firewall).
+	*/
+	#registerCsp() {
+		(this.container?.get?.("firewall"))?.registerCspOrigins?.("frontend", this.#viteCspFragment());
+	}
+	/**
+	* Fragment CSP des besoins Vite DEV. Deux exigences :
+	*  1. **`'self'` dans CHAQUE directive** : `connect-src`/`style-src`/`img-src`/
+	*     `font-src` n'héritent PAS de `default-src` → sans `'self'`, tout le
+	*     same-origin (fetch API, styles, images, fonts) serait bloqué.
+	*  2. **Origines Vite sur tous les hosts de dev** : loopback + `kernel.domain`
+	*     + la liste `trustedHosts` du module http (vhosts comme `nodefony.com`) ×
+	*     ports Vite. Sans ça, accéder via un vhost bloque les ressources Vite.
+	* Tokens : `'unsafe-eval'` (React Fast Refresh — le nonce ne couvre PAS l'eval)
+	* et `'unsafe-inline'` style (styles injectés par Vite). PAS de `'unsafe-inline'`
+	* script : le preamble inline est NONCÉ. Mergé par le firewall (jamais en prod :
+	* `startDev` ne tourne pas en production → CSP strict same-origin).
+	*/
+	#viteCspFragment() {
+		const scheme = this.cfg.https ? "https" : "http";
+		const wsScheme = this.cfg.https ? "wss" : "ws";
+		const ports = this.cspPorts();
+		const hosts = /* @__PURE__ */ new Set(["127.0.0.1", "localhost"]);
+		if (this.kernel?.domain) hosts.add(this.kernel.domain);
+		const th = (this.container?.get?.("HttpKernel"))?.trustedHosts;
+		if (typeof th === "string") hosts.add(th);
+		else if (Array.isArray(th)) for (const h of th) hosts.add(h);
+		const httpSrc = [];
+		const wsSrc = [];
+		for (const h of hosts) for (const p of ports) {
+			httpSrc.push(`${scheme}://${h}:${p}`);
+			wsSrc.push(`${wsScheme}://${h}:${p}`);
+		}
+		for (const s of this.supervisors.values()) {
+			const o = s.status().origin;
+			if (!o) continue;
+			if (!httpSrc.includes(o)) httpSrc.push(o);
+			const w = o.replace(/^http/, "ws");
+			if (!wsSrc.includes(w)) wsSrc.push(w);
+		}
+		return {
+			"script-src": [
+				"'self'",
+				"'unsafe-eval'",
+				...httpSrc
+			],
+			"style-src": [
+				"'self'",
+				"'unsafe-inline'",
+				...httpSrc
+			],
+			"worker-src": ["'self'", "blob:"],
+			"img-src": [
+				"'self'",
+				"data:",
+				"blob:",
+				"https://www.gravatar.com",
+				"https://*.googleusercontent.com",
+				"https://avatars.githubusercontent.com",
+				...httpSrc
+			],
+			"font-src": [
+				"'self'",
+				"data:",
+				...httpSrc
+			],
+			"connect-src": [
+				"'self'",
+				"blob:",
+				"data:",
+				...httpSrc,
+				...wsSrc
+			]
+		};
+	}
+	/**
+	* Ports Vite à déclarer au CSP, famille par famille : le BLOC entier tant que
+	* l'instance ne sert pas, son port RÉEL dès qu'elle sert.
+	*
+	* Pourquoi le bloc avant : le CSP part AVEC la page et ne se renégocie jamais.
+	* Une page servie avant que Vite ait résolu son port doit déjà porter le port
+	* qu'il prendra, sinon son socket de rechargement à chaud est refusé pour
+	* toute la durée de la page.
+	*
+	* Pourquoi le port seul après : la plage est le prix d'une incertitude, elle
+	* ne doit pas lui survivre. Mesuré sur ce dépôt (3 familles × 4 hôtes de
+	* confiance), garder les blocs porte l'en-tête CSP à ~7,9 Ko sur CHAQUE
+	* réponse, contre ~2,3 Ko une fois les ports connus — au bord des 8 Ko que
+	* refusent beaucoup de relais.
+	*
+	* Développement seulement : `startDev` ne tourne pas en production. La
+	* garantie reste une liste d'origines nommées — jamais un `ws:` sans hôte,
+	* qui la supprimerait au lieu de corriger le symptôme.
+	*
+	* @returns ports en chaîne, dédupliqués ; repli `devPort` si rien n'est connu.
+	*/
+	cspPorts() {
+		const ports = /* @__PURE__ */ new Set();
+		for (const [family, block] of this.plannedPortBlocks ?? []) {
+			const st = this.supervisors.get(family)?.status();
+			if ((st?.state === "ready" || st?.state === "compiling") && st?.port) ports.add(String(st.port));
+			else for (const p of block) ports.add(String(p));
+		}
+		for (const [family, sup] of this.supervisors) {
+			if (this.plannedPortBlocks?.has(family)) continue;
+			const st = sup.status();
+			if (st.port) ports.add(String(st.port));
+		}
+		if (ports.size === 0) ports.add(String(this.cfg.devPort));
+		return ports;
+	}
+};
+FrontendService = __decorate([injectable(), __decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module])], FrontendService);
+var FrontendService_default = FrontendService;
+//#endregion
+export { FrontendService_default as default };