nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/service/cluster/topology.js

@@ -0,0 +1,71 @@
+import { resolveWorkerCount } from "./cpuQuota.js";
+import path from "node:path";
+//#region src/service/cluster/topology.ts
+/**
+* Traduit un réglage `WorkersSetting` (ou chaîne CLI/env) en nombre de workers
+* résolu, ou `undefined` si la valeur est absente / invalide (→ source suivante).
+*
+* `"auto"` → {@link resolveWorkerCount} (cgroup-aware) ; un nombre `> 0` → idem en
+* `requested` (honoré tel quel). Tout le reste (vide, `0`, non-numérique) → `undefined`.
+*/
+function coerce(value) {
+	if (value === void 0 || value === null || value === "") return;
+	if (value === "auto") return resolveWorkerCount();
+	const n = typeof value === "number" ? value : Number(value);
+	if (!Number.isFinite(n) || n <= 0) return;
+	return resolveWorkerCount({ requested: n });
+}
+/**
+* Résout LA topologie de lancement — source unique de vérité pour « combien de
+* workers ». Ordre de priorité (premier défini gagne) :
+*
+* 1. **CLI `--workers`** — override explicite de l'opérateur (jamais borné).
+* 2. **env `NF_WORKERS`** — override déploiement (Docker/k8s, sans éditer de fichier).
+* 3. **config app `cluster.workers`** — le knob DevOps par défaut (remplace PM2 `instances`).
+* 4. **défaut `1`** — mono-process cloud-native.
+*
+* @returns `{ workers, source }` — `workers >= 1` toujours.
+*/
+function resolveTopology(opts = {}) {
+	const fromFlag = coerce(opts.flag);
+	if (fromFlag !== void 0) return {
+		workers: fromFlag,
+		source: "flag"
+	};
+	const fromEnv = coerce(opts.env ?? process.env.NF_WORKERS);
+	if (fromEnv !== void 0) return {
+		workers: fromEnv,
+		source: "env"
+	};
+	const fromConfig = coerce(opts.config);
+	if (fromConfig !== void 0) return {
+		workers: fromConfig,
+		source: "config"
+	};
+	return {
+		workers: 1,
+		source: "default"
+	};
+}
+/**
+* Lit le bloc `cluster` de la config app de façon **standalone** (best-effort), sans
+* booter de Kernel — c'est tout ce dont le master a besoin pour décider du fork.
+*
+* Importe le fichier compilé `dist/nodefony/config/cluster/cluster.config.js` sous
+* `appPath` (défaut `process.cwd()`, = `Kernel.path`). Toute erreur (fichier absent,
+* import KO) → `null` : la résolution retombe alors sur CLI/env/défaut. Le fichier
+* config DOIT rester kernel-free pour être importable ici.
+*
+* @param appPath - racine de l'app (défaut `process.cwd()`).
+* @returns la valeur `cluster.workers`, ou `null` si introuvable.
+*/
+async function loadClusterConfig(appPath = process.cwd()) {
+	try {
+		const workers = (await import(path.resolve(appPath, "dist/nodefony/config/cluster/cluster.config.js"))).default?.workers;
+		return workers === void 0 ? null : workers;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { loadClusterConfig, resolveTopology };

package/dist/node/service/dev/BootReporter.js

@@ -0,0 +1,490 @@
+import Syslog from "../../syslog/Syslog.js";
+import { discoverDevProcesses, splitByProject } from "./devProcess.js";
+import { renderProcessTable } from "./devStatusReport.js";
+import readline from "node:readline";
+//#region src/service/dev/BootReporter.ts
+/**
+* Pattern de zone LISIBLE : `describe()` remonte `RegExp.source`, où V8 échappe
+* les slashes (`^\/nodefony\/…`) — on dé-échappe pour l'affichage ET pour le
+* classement par namespace (un `startsWith("^/nodefony")` sur la source brute
+* ne matcherait jamais — bug vécu au premier boot réel).
+*/
+function cleanZonePattern(pattern) {
+	return pattern.replace(/\\\//g, "/");
+}
+/**
+* `true` si la zone vit dans le namespace réservé `/nodefony` → déclarée par
+* `@nodefony/framework` (les aires data plane admin). L'inférence par pattern
+* est fiable PAR CONVENTION : le routage `/nodefony` est réservé au framework
+* (règle figée), aucune app/module tiers n'y monte d'aire.
+*/
+function isFrameworkZone(z) {
+	return cleanZonePattern(z.pattern).startsWith("^/nodefony");
+}
+/**
+* Tableau ANSI des zones firewall (ZONE/MODULE/PATTERN/AUTH/ACCÈS) — même
+* gabarit que le tableau process du bilan (`renderProcessTable`). MODULE = qui
+* déclare l'aire (`framework` pour le data plane `/nodefony`, `app` pour les
+* zones du `nodefony.config.ts`). ACCÈS résume la politique effective :
+* `public` (security:false), `anonyme OK` (authenticator anonymous dans la
+* chaîne — jamais bloquant, identité résolue si présente) ou `protégé`
+* (preuve exigée, 401 sinon). Zones applicatives en vert, aires framework en dim.
+*/
+function renderZoneTable(lines, zones, indent = "  ") {
+	const moduleOf = (z) => isFrameworkZone(z) ? "framework" : "app";
+	const authOf = (z) => (z.authenticators ?? []).join(", ") || "—";
+	const nameW = Math.max(4, ...zones.map((z) => z.name.length));
+	const modW = Math.max(6, ...zones.map((z) => moduleOf(z).length));
+	const patW = Math.max(7, ...zones.map((z) => cleanZonePattern(z.pattern).length));
+	const authW = Math.max(4, ...zones.map((z) => authOf(z).length));
+	const GREEN = "\x1B[32m";
+	const YELLOW = "\x1B[33m";
+	const DIM = "\x1B[2m";
+	const RESET = "\x1B[0m";
+	lines.push(`${DIM}${indent}${"ZONE".padEnd(nameW)}  ${"MODULE".padEnd(modW)}  ${"PATTERN".padEnd(patW)}  ${"AUTH".padEnd(authW)}  ACCÈS${RESET}`, `${DIM}${indent}${"─".repeat(nameW + modW + patW + authW + 13)}${RESET}`);
+	for (const z of zones) {
+		const framework = isFrameworkZone(z);
+		const access = z.security === false ? `${YELLOW}public${RESET}` : z.allowsAnonymous || (z.authenticators ?? []).includes("anonymous") ? `anonyme OK` : `${GREEN}protégé${RESET}`;
+		const color = framework ? DIM : GREEN;
+		lines.push(`${indent}${color}${z.name.padEnd(nameW)}${RESET}  ${DIM}${moduleOf(z).padEnd(modW)}${RESET}  ${cleanZonePattern(z.pattern).padEnd(patW)}  ${DIM}${authOf(z).padEnd(authW)}${RESET}  ${access}`);
+	}
+}
+/** Frames braille du spinner (rotation fluide, 10 étapes). */
+const FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const GREEN = "\x1B[32m";
+const RED = "\x1B[31m";
+const YELLOW = "\x1B[33m";
+const CYAN = "\x1B[36m";
+const DIM = "\x1B[2m";
+const BOLD = "\x1B[1m";
+const RESET = "\x1B[0m";
+/**
+* Phases du boot dans l'ordre chronologique. Chaque phase se ferme quand son
+* event Kernel fire (le spinner se fige en `✓` + durée, puis la suivante démarre).
+* `onStart` clôt « Application » → couvre `loadApp()` (le gros import des modules,
+* ~1.2 s, sinon un écran figé sans feedback — cf audit boot 2026-06-01).
+*/
+const PHASES = [
+	{
+		event: "onStart",
+		label: "Application"
+	},
+	{
+		event: "onRegister",
+		label: "Modules"
+	},
+	{
+		event: "onBoot",
+		label: "Configuration"
+	},
+	{
+		event: "onReady",
+		label: "Services & ORM"
+	},
+	{
+		event: "onServersReady",
+		label: "Serveurs"
+	}
+];
+/**
+* Affichage « boot de rêve » du serveur en développement : une checklist animée
+* (spinner + `✓`/`✗` par phase de boot) à la place du mur de logs `INFO`/`MODULE ADD`.
+*
+* **Dev-only** : instancié uniquement par `DevCommand`, côté enfant supervisé
+* (`NF_DEV_CHILD=1`). En prod/cluster : jamais (logs structurés cloud-native).
+*
+* **Backplane-safe** : le spinner s'écrit DIRECTEMENT sur `process.stdout`, jamais via
+* le Syslog. Le mute pendant le boot = {@link Syslog.setSinkEnabled} (coupe le sink
+* texte écran) ; les transports d'écriture (`_transports` : file/cluster/loki) ET le
+* ring buffer reçoivent TOUS les logs → rien perdu, le Log Backplane intact.
+*
+* Trois modes (tous dev-only) :
+* - **TTY normal** : spinner animé + console mutée (logs → buffer/backplane).
+* - **`--debug`** : pas d'animation, pas de mute → marqueurs `✓` de phase entre les logs
+*   bruts complets (structure sans rien cacher).
+* - **non-TTY** (CI/redirection) : marqueurs statiques, zéro séquence `\r`.
+*/
+var BootReporter = class {
+	#kernel;
+	/** true = spinner animé + mute (TTY non-debug) ; false = marqueurs statiques. */
+	#animated;
+	#frame = 0;
+	#phaseIndex = 0;
+	#bootStart = 0;
+	#phaseStart = 0;
+	#timer = null;
+	#done = false;
+	/** Vite compile encore (event pont `onFrontendStart` reçu, `onFrontendReady` pas encore). */
+	#frontendPending = false;
+	/** `performance.now()` au démarrage de la compilation Vite (pour la durée affichée). */
+	#frontendStart = 0;
+	/** Libellé dynamique de la phase Vite (override `#label()` tant que Vite tourne). */
+	#frontendLabel = null;
+	/** `onPostReady` est arrivé pendant la compilation Vite → « ✓ Prêt » en attente. */
+	#finishDeferred = false;
+	/** Total de bundles Vite (jauge de progression) — posé à `onFrontendStart`. */
+	#frontendTotal = 0;
+	/** Bundles Vite résolus (ready/échec) — incrémenté à `onFrontendProgress`. */
+	#frontendDone = 0;
+	/** Handler `onFrontendProgress` (détaché à la fin de la phase Vite). */
+	#onFrontendProgress = null;
+	/**
+	* Résultat final de la compilation Vite (payload `onFrontendReady`) — gardé
+	* pour rappeler un échec dans le bloc « Bilan » (la ligne `✗` de la checklist
+	* défile et se perd). `null` = pas de frontend ou pas encore fini.
+	*/
+	#frontendResult = null;
+	constructor(kernel, opts) {
+		this.#kernel = kernel;
+		this.#animated = opts.tty && !opts.debug;
+	}
+	/**
+	* Branche les hooks de phase sur le Kernel + démarre l'affichage.
+	* À appeler depuis `DevCommand.onKernelPreStart` (après le splash, avant `loadApp`).
+	*/
+	attach() {
+		this.#bootStart = this.#phaseStart = performance.now();
+		if (this.#animated) {
+			Syslog.setSinkEnabled(false);
+			this.#kernel.suppressBootBanners = true;
+			this.#render();
+			this.#timer = setInterval(() => this.#render(), 80);
+			this.#timer.unref?.();
+		}
+		for (const phase of PHASES) this.#kernel.once(phase.event, () => this.#phaseDone(phase.label));
+		this.#kernel.once("onPostReady", () => this.#finish());
+		this.#kernel.once("onTerminate", (_k, code) => this.#abort(typeof code === "number" ? code : 0));
+		this.#kernel.once("onFrontendStart", (payload) => this.#frontendBegin(payload));
+		this.#onFrontendProgress = (payload) => {
+			const p = payload;
+			if (typeof p?.ready === "number") this.#frontendDone = p.ready;
+			if (typeof p?.total === "number") this.#frontendTotal = p.total;
+			if (!this.#animated && this.#frontendTotal > 0) process.stdout.write(`  ${CYAN}·${RESET} Frontend (Vite) ${this.#frontendDone}/${this.#frontendTotal}\n`);
+		};
+		this.#kernel.on("onFrontendProgress", this.#onFrontendProgress);
+		this.#kernel.once("onFrontendReady", (payload) => this.#frontendEnd(payload));
+	}
+	/** Libellé de la phase courante (ou « Finalisation » au-delà des phases connues). */
+	#label() {
+		if (this.#frontendLabel) return this.#frontendLabel;
+		return PHASES[this.#phaseIndex]?.label ?? "Finalisation";
+	}
+	/** Réécrit la ligne courante : jauge Vite (X of Y) en phase frontend, sinon spinner. */
+	#render() {
+		this.#frame = (this.#frame + 1) % FRAMES.length;
+		readline.clearLine(process.stdout, 0);
+		readline.cursorTo(process.stdout, 0);
+		if (this.#frontendPending && this.#frontendTotal > 0) {
+			process.stdout.write(`  ${CYAN}${FRAMES[this.#frame]}${RESET} Frontend (Vite)  ${this.#bar(this.#frontendDone, this.#frontendTotal)}  ${DIM}${this.#frontendDone}/${this.#frontendTotal} bundles${RESET}`);
+			return;
+		}
+		process.stdout.write(`  ${CYAN}${FRAMES[this.#frame]}${RESET} ${this.#label()}${DIM}…${RESET}`);
+	}
+	/** Barre `▰▰▰▱▱` proportionnelle (vert rempli / dim vide), largeur fixe 14. */
+	#bar(done, total) {
+		const width = 14;
+		const filled = total > 0 ? Math.min(width, Math.round(done / total * width)) : 0;
+		return `${GREEN}${"▰".repeat(filled)}${RESET}${DIM}${"▱".repeat(width - filled)}${RESET}`;
+	}
+	/** Fige une ligne de phase terminée : `mark label (durée)`. */
+	#freeze(mark, label, ms) {
+		if (this.#animated) {
+			readline.clearLine(process.stdout, 0);
+			readline.cursorTo(process.stdout, 0);
+		}
+		const dt = ms >= 1e3 ? `${(ms / 1e3).toFixed(2)}s` : `${Math.round(ms)}ms`;
+		process.stdout.write(`  ${mark} ${label} ${DIM}(${dt})${RESET}\n`);
+	}
+	/** Une phase vient de se clôturer (son event Kernel a fire). */
+	#phaseDone(label) {
+		if (this.#done) return;
+		const now = performance.now();
+		this.#freeze(`${GREEN}✓${RESET}`, label, now - this.#phaseStart);
+		this.#renderPhaseDetail(label);
+		this.#phaseStart = now;
+		this.#phaseIndex++;
+	}
+	/**
+	* Lignes de détail SOUS une phase qui vient de se figer — pour que le boot
+	* RACONTE ce qui se passe (pas une phase muette). Deux sources :
+	* - le canal NEUTRE `Kernel.getBootLines(phase)` que tout module alimente
+	*   (`reportBootLine` — ex. ORM : « drizzle → sqlite »), le core restant
+	*   agnostique ;
+	* - un digest intégré pour `Modules` (liste lisible, dérivée du Kernel).
+	*/
+	#renderPhaseDetail(label) {
+		let lines = this.#kernel.getBootLines(label);
+		if (label === "Modules" && lines.length === 0) lines = this.#moduleDigest();
+		for (const line of lines) process.stdout.write(`       ${DIM}${line}${RESET}\n`);
+	}
+	/**
+	* Digest lisible des modules chargés (noms courts, ~6 par ligne) affiché sous
+	* la phase « Modules ». Donne au dev la composition réelle de son app d'un
+	* coup d'œil.
+	*/
+	#moduleDigest() {
+		const names = Object.keys(this.#kernel.modules).map((m) => m.replace(/^@nodefony\//, ""));
+		if (!names.length) return [];
+		const out = [];
+		for (let i = 0; i < names.length; i += 8) out.push(names.slice(i, i + 8).join(" · "));
+		return out;
+	}
+	/**
+	* Boot complet (`onPostReady`). Si Vite compile encore (`#frontendPending`), on
+	* DIFFÈRE le récap final jusqu'à `onFrontendReady` : sinon « ✓ Prêt » s'afficherait
+	* avant la ligne Vite. On GARDE le spinner animé sur « Frontend (Vite)… » et le
+	* sink RESTE muté → le dev voit la progression, pas le mur de logs de build (Vite
+	* + `Server Listen…`) qui partent au buffer/backplane (visibles en `--debug`).
+	*/
+	#finish() {
+		if (this.#done) return;
+		if (this.#frontendPending) {
+			this.#finishDeferred = true;
+			return;
+		}
+		this.#doFinish();
+	}
+	/**
+	* Récap final + rend la main au Syslog (idempotent sur le sink). Le verdict
+	* écran vient du {@link Kernel.getBootReport} (vérité unique) :
+	* - sain → bloc « Prêt » : identité + serveurs HTTP|WS (URLs cliquables),
+	* - dégradé (modules ignorés, serveurs up) → + lignes `⚠`,
+	* - **garde-fou 0-serveur** → bloc `⛔` non silencieux + action corrective.
+	*/
+	#doFinish() {
+		if (this.#done) return;
+		this.#done = true;
+		this.#stopTimer();
+		if (this.#animated) Syslog.setSinkEnabled(true);
+		const dt = ((performance.now() - this.#bootStart) / 1e3).toFixed(2);
+		const report = this.#kernel.getBootReport();
+		if (!report.healthy && report.serversExpected) {
+			this.#renderBootFailure(report, dt);
+			return;
+		}
+		this.#renderReady(report, dt);
+		if (report.modulesSkipped.length) this.#renderSkipped(report.modulesSkipped);
+		process.stdout.write("\n");
+	}
+	/**
+	* Récap « prêt » : chaque serveur sur sa ligne, `➜  LABEL  url` (label aligné,
+	* URL cliquable cyan) — mise en avant des 4 points d'entrée (HTTP, HTTP/2, WS,
+	* WSS : le différenciateur Nodefony HTTP + WebSocket co-citoyens). L'identité
+	* (version · env · pid) est déjà posée par `Kernel.printDevHeader` en TÊTE.
+	*/
+	#renderReady(report, dt) {
+		process.stdout.write(`\n  ${GREEN}${BOLD}✓  Prêt${RESET} ${DIM}en ${dt}s${RESET}\n\n`);
+		const rows = [
+			["http", "HTTP"],
+			["https", "HTTP/2"],
+			["ws", "WS"],
+			["wss", "WSS"]
+		];
+		process.stdout.write(`     ${DIM}Serveurs${RESET}\n`);
+		for (const [scheme, label] of rows) {
+			const url = report.serversListening.find((s) => s.scheme === scheme)?.url;
+			if (!url) continue;
+			process.stdout.write(`     ${GREEN}➜${RESET}  ${BOLD}${label.padEnd(9)}${RESET}${CYAN}${url}${RESET}\n`);
+		}
+		this.#renderSection("Frontend (Vite)", "Frontend (Vite)");
+		if (this.#kernel.modules["studio"]) {
+			const adminUrl = report.serversListening.find((s) => s.scheme === "https")?.url ?? report.serversListening.find((s) => s.scheme === "http")?.url;
+			if (adminUrl) {
+				process.stdout.write(`\n     ${DIM}Studio${RESET}\n`);
+				process.stdout.write(`     ${GREEN}➜${RESET}  ${BOLD}${"Admin".padEnd(9)}${RESET}${CYAN}${adminUrl}/nodefony${RESET}\n`);
+			}
+		}
+		this.#renderSection("Données", "Services & ORM");
+		this.#renderVerdict(report);
+	}
+	/**
+	* Bloc « Bilan » du verdict — le « développeur rassuré » : composition réelle du
+	* boot (modules chargés / ignorés par gating AVEC la raison / échecs fail-soft),
+	* rappel d'un échec Vite (la ligne `✗` de la checklist défile et se perd), et
+	* journal du boot (compteurs WARNING/ERROR du ring syslog). Tout vient du
+	* {@link IBootReport} (vérité unique — le futur endpoint Studio lira la même).
+	*/
+	#renderVerdict(report) {
+		process.stdout.write(`\n     ${DIM}Bilan${RESET}\n`);
+		const loaded = report.modulesLoaded.length;
+		const gated = report.modulesGated.length;
+		const failed = report.modulesSkipped.length;
+		let modules = `${loaded} module${loaded > 1 ? "s" : ""}`;
+		if (gated) modules += ` ${DIM}·${RESET} ${YELLOW}${gated} ignoré${gated > 1 ? "s" : ""}${RESET} ${DIM}(policy/when)${RESET}`;
+		if (failed) modules += ` ${DIM}·${RESET} ${RED}${failed} échec${failed > 1 ? "s" : ""}${RESET}`;
+		this.#verdictRow("Modules", modules);
+		for (const g of report.modulesGated) process.stdout.write(`        ${DIM}· ${g.module} — ${g.reason}${RESET}\n`);
+		if (this.#frontendResult && (this.#frontendResult.ready ?? 0) === 0 && (this.#frontendResult.bundles ?? 0) > 0) this.#verdictRow("Vite", `${RED}✗ compilation échouée${RESET} ${DIM}(voir logs)${RESET}`);
+		this.#renderProcessRow();
+		this.#renderFirewallRow();
+		process.stdout.write("\n");
+		const journal = !report.warnings && !report.errors ? `${GREEN}aucun warning${RESET}` : [report.errors ? `${RED}${report.errors} ERROR${RESET}` : "", report.warnings ? `${YELLOW}${report.warnings} WARNING${RESET}` : ""].filter(Boolean).join(` ${DIM}·${RESET} `) + ` ${DIM}(détail : --debug)${RESET}`;
+		this.#verdictRow("Journal", journal);
+	}
+	/** Ligne du bilan `➜  LABEL  valeur` (même gabarit que les lignes serveurs). */
+	#verdictRow(label, value) {
+		process.stdout.write(`     ${GREEN}➜${RESET}  ${BOLD}${label.padEnd(9)}${RESET}${value}\n`);
+	}
+	/**
+	* Ligne « Process » du bilan — topologie runtime réelle (superviseur / serveur /
+	* Vite avec pid + RSS), MÊME source d'observation que `nodefony status`
+	* (`discoverDevProcesses`, ps sans IPC), scopée à CE projet (`splitByProject` —
+	* un runtime d'un autre dossier ne pollue pas le bilan). Best-effort : `ps`
+	* indisponible (Windows) ou vide → aucune ligne. Sync, 1× au boot, dev-only.
+	* Les ports ne sont PAS re-sondés ici : la section « Serveurs » du verdict est
+	* déjà la vérité interne (une liste sondée serait une convention — vécu 3×).
+	*/
+	#renderProcessRow() {
+		let procs = [];
+		try {
+			procs = splitByProject(discoverDevProcesses({ includeSelf: true }), this.#kernel.path).mine;
+		} catch {
+			return;
+		}
+		if (!procs.length) return;
+		process.stdout.write("\n");
+		const roles = [
+			["supervisor", "superviseur"],
+			["master", "master"],
+			["server", "serveur"],
+			["worker", "worker"],
+			["vite", "Vite"]
+		];
+		const parts = [];
+		for (const [role, label] of roles) {
+			const n = procs.filter((p) => p.role === role).length;
+			if (n) parts.push(`${n} ${label}${n > 1 && role !== "vite" ? "s" : ""}`);
+		}
+		this.#verdictRow("Process", parts.join(` ${DIM}·${RESET} `));
+		const table = [];
+		renderProcessTable(table, procs, "        ");
+		process.stdout.write(table.join("\n") + "\n");
+	}
+	/**
+	* Ligne « Firewall » du bilan — aiguillage sécurité, même gabarit que
+	* « Process » : synthèse sur la ligne `➜`, puis TABLEAU des zones montées
+	* (ZONE / PATTERN / AUTH / ACCÈS). Vue minimale du service `firewall`
+	* (@nodefony/security) résolu PAR NOM (le core n'importe jamais security).
+	* Zones APPLICATIVES = hors namespace réservé `/nodefony` (les aires admin y
+	* sont portées par le framework). Aucune zone applicative → les routes
+	* métier sont PUBLIQUES : on le DIT, avec la recette (fail-loud annoncé —
+	* hors zone, l'identité n'est jamais résolue). Security absent → aucune
+	* ligne (une app sans firewall est un choix assumé).
+	*/
+	#renderFirewallRow() {
+		const fw = this.#kernel.container?.get?.("firewall");
+		if (typeof fw?.describe !== "function") return;
+		let zones = [];
+		try {
+			zones = fw.describe().zones ?? [];
+		} catch {
+			return;
+		}
+		process.stdout.write("\n");
+		const app = zones.filter((z) => !isFrameworkZone(z));
+		const fwk = zones.length - app.length;
+		const summary = app.length ? `${app.length} zone${app.length > 1 ? "s" : ""} applicative${app.length > 1 ? "s" : ""}` + (fwk ? ` ${DIM}·${RESET} ${fwk} aire${fwk > 1 ? "s" : ""} framework` : "") : `${YELLOW}aires framework seules — tes routes métier sont PUBLIQUES${RESET}`;
+		this.#verdictRow("Firewall", summary);
+		if (zones.length) {
+			const table = [];
+			renderZoneTable(table, zones, "        ");
+			process.stdout.write(table.join("\n") + "\n");
+		}
+		if (!app.length) process.stdout.write(`        ${DIM}· déclare une zone : use("@nodefony/security", { areas: { main: { pattern: "^/api", authenticators: ["session"] } } })${RESET}\n`);
+	}
+	/**
+	* Section « titre » + lignes `➜ valeur` (cyan, cliquable) lues du canal neutre
+	* de boot (`Kernel.getBootLines`). No-op si la phase n'a poussé aucune ligne.
+	*/
+	#renderSection(title, phase) {
+		const lines = this.#kernel.getBootLines(phase);
+		if (!lines.length) return;
+		process.stdout.write(`\n     ${DIM}${title}${RESET}\n`);
+		for (const line of lines) process.stdout.write(`     ${GREEN}➜${RESET}  ${CYAN}${line}${RESET}\n`);
+	}
+	/**
+	* Bloc ⛔ **non silencieux** : un profil serveur a fini sans aucun serveur en
+	* écoute. Liste les modules en cause + l'action corrective. Le process va
+	* s'arrêter (le Kernel a déjà décidé `terminate(EX_UNAVAILABLE)`).
+	*/
+	#renderBootFailure(report, dt) {
+		process.stdout.write(`\n  ${RED}⛔ Aucun serveur n'a démarré${RESET} ${DIM}(boot en ${dt}s — le process va s'arrêter)${RESET}\n`);
+		for (const f of report.modulesSkipped) process.stdout.write(`     ${RED}✗${RESET} ${f.module} ${DIM}— ${f.reason}${RESET}\n`);
+		if (report.remediation) process.stdout.write(`     ${CYAN}→ ${report.remediation}${RESET}\n`);
+		process.stdout.write("\n");
+	}
+	/** Lignes ⚠ des modules en échec fail-soft (boot dégradé mais serveurs en écoute). */
+	#renderSkipped(skipped) {
+		const m = skipped.length;
+		process.stdout.write(`  ${YELLOW}⚠ ${m} module${m > 1 ? "s" : ""} en échec (fail-soft)${RESET}\n`);
+		for (const f of skipped) process.stdout.write(`     ${YELLOW}·${RESET} ${f.module} ${DIM}— ${f.reason}${RESET}\n`);
+	}
+	/** Vite a commencé à compiler (`onFrontendStart`) — ouvre la phase Vite dynamique. */
+	#frontendBegin(payload) {
+		if (this.#done) return;
+		this.#frontendPending = true;
+		this.#frontendStart = performance.now();
+		this.#frontendLabel = "Frontend (Vite)";
+		this.#frontendTotal = payload?.bundles ?? 0;
+		this.#frontendDone = 0;
+	}
+	/**
+	* Vite a fini ou échoué (`onFrontendReady`) : fige la ligne Vite (`✓`/`✗` + durée
+	* + bundles servis), puis débloque le « ✓ Prêt » si `onPostReady` l'attendait.
+	*/
+	#frontendEnd(payload) {
+		if (this.#done || !this.#frontendPending) return;
+		this.#frontendPending = false;
+		this.#frontendResult = payload ?? null;
+		this.#frontendLabel = null;
+		if (this.#onFrontendProgress) {
+			this.#kernel.removeListener("onFrontendProgress", this.#onFrontendProgress);
+			this.#onFrontendProgress = null;
+		}
+		const ms = performance.now() - this.#frontendStart;
+		const n = payload?.bundles ?? 0;
+		if ((payload?.ready ?? 0) > 0) {
+			const plural = n > 1 ? "s" : "";
+			const names = payload?.names?.length ? ` ${DIM}(${payload.names.join(", ")})${RESET}` : "";
+			this.#freeze(`${GREEN}✓${RESET}`, `Frontend (Vite) — ${n} bundle${plural} servi${plural}${names}`, ms);
+		} else this.#freeze(`${RED}✗${RESET}`, `Frontend (Vite) — échec ${DIM}(voir logs)${RESET}`, ms);
+		if (this.#finishDeferred) this.#doFinish();
+	}
+	/** Boot interrompu (`onTerminate`) : marque `✗`, rend la main, déverse les erreurs. */
+	#abort(code) {
+		if (this.#done) return;
+		this.#done = true;
+		this.#stopTimer();
+		if (this.#animated) {
+			this.#freeze(`${RED}✗${RESET}`, this.#label(), performance.now() - this.#phaseStart);
+			Syslog.setSinkEnabled(true);
+			this.#dumpErrors();
+		}
+		if (code !== 0) process.stdout.write(`  ${RED}✗ Boot interrompu${RESET} ${DIM}(code ${code})${RESET}\n`);
+	}
+	/** Déverse les ERROR/CRITIC/ALERT/EMERGENCY restés dans le ring buffer pendant le mute. */
+	#dumpErrors() {
+		const sys = this.#kernel.syslog;
+		if (!sys) return;
+		for (const pdu of sys.ringStack) if (pdu.severity >= 0 && pdu.severity <= 3) process.stdout.write(`  ${pdu.toString()}\n`);
+	}
+	#stopTimer() {
+		if (this.#timer) {
+			clearInterval(this.#timer);
+			this.#timer = null;
+		}
+	}
+};
+//#endregion
+export { cleanZonePattern, BootReporter as default, isFrameworkZone, renderZoneTable };