nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/kernel/Kernel.js

@@ -0,0 +1,2198 @@
+import { Nodefony } from "../Nodefony.js";
+import { logColor, resolveColorEnabled, setLogColor } from "../syslog/logColor.js";
+import { extend, isSubclassOf } from "../Tools.js";
+import FileClass from "../FileClass.js";
+import { DEFAULT_ENGINE_ENVIRONMENT, engineModeOf } from "../runtime/engineEnvironment.js";
+import Syslog, { NULL_LOG_SINK } from "../syslog/Syslog.js";
+import Service from "../Service.js";
+import { FileSink } from "../syslog/sinks/FileSink.js";
+import { getActiveLogDriver, getLogDriverFactory, listLogDriverFactories, registerLogDriver, setActiveLogDriver } from "../syslog/drivers/logDriverRegistry.js";
+import { registerBuiltinLogDrivers, resolveQueryDriver } from "../syslog/drivers/builtinLogDrivers.js";
+import { isInKubernetes, shouldWarnPerPodView } from "../service/cluster/podEnvironment.js";
+import "../cli/sysexits.js";
+import { resolveModuleEntry, toImportSpecifier } from "./resolveModuleEntry.js";
+import { isUnboundedListener, readListenerTags } from "./lifecycleTags.js";
+import nodefonyError from "../Error.js";
+import { clearReadinessState, writeReadinessState } from "../service/dev/devProcess.js";
+import { isClusterMessage } from "../service/cluster/clusterMessage.js";
+import { writeLastBoot } from "./checks/lastBoot.js";
+import { applyResolvedPath, closestMatch, parseNfEnvOverrides, pathLooksSecret, readResolvedPath, resolveFailureHint } from "../config/envOverride.js";
+import { gateModuleManifest } from "./moduleGating.js";
+import { resolveInfra } from "../config/infra.js";
+import CliKernel from "./CliKernel.js";
+import Injector from "./injector/injector.js";
+import Module from "./Module.js";
+import { defaultAppConfig } from "../config/defaults.js";
+import { isConfigDescriptor, readAppEnvOverrideReport } from "../config/defineConfig.js";
+import { findSetReservedKeys } from "../config/configProvenance.js";
+import { TimeoutError, withTimeout } from "../runtime/withTimeout.js";
+import { BootConfigurationError } from "./BootConfigurationError.js";
+import { ReadinessRegistry } from "./readinessRegistry.js";
+import cluster from "node:cluster";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+//#region src/kernel/Kernel.ts
+const colorLogEvent = () => logColor.cyanBgBlue("EVENT KERNEL");
+const SERVER_SCHEME = {
+	http: "http",
+	https: "https",
+	websocket: "ws",
+	"websocket-secure": "wss"
+};
+const kernelDefaultOptions = { events: { nbListeners: 60 } };
+const DEFAULT_SHUTDOWN_DEADLINE = 15e3;
+const SHUTDOWN_DEADLINE = Symbol("shutdown-deadline");
+const SHUTDOWN_DRAIN_ERROR = Symbol("shutdown-drain-error");
+/**
+* Dérogation au gating `policy:"dev"` en production — posée à `1`, les modules de
+* développement sont chargés malgré le mode.
+*
+* Existe pour éprouver un runtime de production AVEC les briques de banc (une suite
+* d'intégration interroge des routes qu'un module `policy:"dev"` porte, et qui
+* n'existent donc pas là-bas : tout répond 404). Réservée aux bancs et au
+* diagnostic — chaque module chargé par dérogation est journalisé en WARNING, et
+* la variable n'a **aucun effet** hors production.
+*/
+const FORCE_DEV_MODULES_ENV = "NF_WITH_DEV_MODULES";
+/**
+* Durée de vie d'un runtime de production qui a dérogé au gating des modules dev.
+*
+* La variable seule ne protège de rien : elle s'oublie, dans une image, un manifeste
+* de déploiement, un fichier d'environnement recopié — et le jour où elle survit à
+* une mise en production, plus rien ne le dit. Un runtime en dérogation **s'arrête
+* donc tout seul** : l'oubli devient un incident immédiat et lisible plutôt qu'une
+* surface offerte pour des mois. Large devant toute suite de tests (les tâches
+* d'intégration continue du dépôt expirent à 20 minutes), dérisoire devant la durée
+* de vie d'un déploiement.
+*/
+const FORCE_DEV_MODULES_TTL_MS = 18e5;
+/**
+* Plafond DUR de cette durée de vie. Un banc de charge légitime dure plus qu'une
+* suite d'intégration, d'où le réglage ci-dessous — mais aucune valeur ne désarme
+* la minuterie : une protection qu'on peut annuler par la même variable que celle
+* qu'elle protège n'en est pas une.
+*/
+const FORCE_DEV_MODULES_TTL_MAX_MS = 144e5;
+/** Variable de réglage de la durée de vie, en MINUTES (bornée par le plafond dur). */
+const FORCE_DEV_MODULES_TTL_ENV = "NF_WITH_DEV_MODULES_TTL_MIN";
+/**
+* Durée de vie effective d'un runtime en dérogation — fonction PURE.
+*
+* @param env - environnement à lire (injecté : la règle s'éprouve sans toucher au process).
+* @returns la durée en millisecondes, toujours comprise entre le défaut et le plafond.
+*/
+function resolveDevModulesTtlMs(env) {
+	const raw = Number.parseInt(env["NF_WITH_DEV_MODULES_TTL_MIN"] ?? "", 10);
+	if (!Number.isFinite(raw) || raw <= 0) return FORCE_DEV_MODULES_TTL_MS;
+	return Math.min(Math.max(raw * 6e4, FORCE_DEV_MODULES_TTL_MS), FORCE_DEV_MODULES_TTL_MAX_MS);
+}
+const Events = Object.freeze({
+	onInit: 1,
+	onPreStart: 2,
+	onStart: 4,
+	onPreRegister: 8,
+	onRegister: 16,
+	onPreBoot: 32,
+	onBoot: 64,
+	onReady: 128,
+	onServersReady: 256,
+	onPostReady: 512,
+	onTerminate: 1024
+});
+/** Profil par défaut — équivaut à l'ancien `type = "CONSOLE"` (one-shot, sans serveur). */
+const CONSOLE_RUN_PROFILE = Object.freeze({
+	servers: false,
+	lifetime: "oneshot",
+	interactive: false
+});
+/**
+* Combien de messages CRITIC un bilan de démarrage retient.
+*
+* Trois : au-delà, ce sont presque toujours des conséquences du premier, et un
+* bilan qu'on ne lit pas ne vaut pas mieux qu'un bilan muet.
+*/
+const MAX_BOOT_CRITICALS = 3;
+/** Longueur d'un message retenu — au-delà, la ligne déborde tout rendu. */
+const MAX_BOOT_CRITICAL_LENGTH = 200;
+/**
+* Orchestrateur central de Nodefony — gère le boot, les modules, le DI Container racine,
+* et expose les events lifecycle auxquels services/modules se branchent.
+*
+* Hérite de {@link Service} → bénéficie DI, EventEmitter, Syslog. Pollue le singleton
+* `Nodefony.#kernel` au constructor (`Nodefony.setKernel(this)`) — isoler les tests avec
+* un mock minimal.
+*
+* **Lifecycle phases** (chronologiques, jamais régressives) :
+* `started → preRegistered → registered → booted → ready → postReady`
+*
+* **Events bitmask** (`progress` = OR cumulatif) :
+* - `onInit=1`, `onPreStart=2`, `onStart=4`
+* - `onPreRegister=8`, `onRegister=16`
+* - `onPreBoot=32`, `onBoot=64`
+* - `onReady=128`, `onServersReady=256`, `onPostReady=512`
+* - `onTerminate=1024`
+*
+* **Chaîne async** (chaque maillon appelle le suivant si `!setCommandComplete`) :
+* `start() → preRegister() → boot() → onReady() → initServers()`
+*
+* @example
+* ```ts
+* import { CliKernel } from "nodefony";
+* const cli = new CliKernel("development");
+* await cli.start();   // → new Kernel(env, cli) → kernel.start() → boot complet
+* ```
+*/
+var Kernel = class extends Service {
+	Events = Events;
+	runProfile;
+	version = "1.0.0";
+	started = false;
+	booted = false;
+	ready = false;
+	postReady = false;
+	/**
+	* Composants qui RETIENNENT la mise en service (cf `readinessRegistry.ts`).
+	*
+	* `null` tant que personne ne s'inscrit — et de nouveau `null` quand le
+	* dernier contributeur se retire : la sonde `/readyz` est sur le chemin le
+	* plus chaud du framework, elle ne doit rien payer pour un mécanisme dont
+	* aucune application ne se sert. Lire {@link Kernel.readinessBlocked}.
+	*/
+	readiness = null;
+	/**
+	* Supprime les bannières serveurs « Server Listen on… » (`showBanner`) — posé
+	* par le `BootReporter` animé (dev TTY non-debug) : le bloc « ✓ Prêt » liste
+	* déjà les URLs, ces logs feraient doublon. Reste `false` en prod/CI/`--debug`
+	* → bannières affichées (aucun changement hors écran de boot animé).
+	*/
+	suppressBootBanners = false;
+	trunk = null;
+	_appEntry = void 0;
+	core = false;
+	command = null;
+	commandArgs = [];
+	preRegistered = false;
+	registered = false;
+	app = null;
+	cli = null;
+	/**
+	* Mode MOTEUR par défaut, quand RIEN ne le dit.
+	*
+	* 🔴 `development`, et c'est un choix de sûreté — pas de confort. Le défaut
+	* ne s'applique que si `NODE_ENV` est absent ET que la commande n'exprime
+	* aucune intention. Or cette information ne manque JAMAIS en production : le
+	* `Dockerfile` généré pose `ENV NODE_ENV=production`, tout orchestrateur pose
+	* la variable, et les trois lanceurs posent leur mode eux-mêmes
+	* (`ProdCommand`, `DevCommand`, `ClusterCommand`). Elle ne manque que sur un
+	* poste de développement — le défaut doit donc protéger CE cas.
+	*
+	* L'ancien défaut `production` a produit trois défauts constatés : un jeton
+	* émis contre la mauvaise configuration, une inspection qui montrait les
+	* modules de production sur une machine de développement, et un contrôle de
+	* banc qui comparait deux applications différentes. Aucun n'a levé d'erreur :
+	* deviner « production » là où l'on est manifestement en développement est
+	* une dégradation SILENCIEUSE, ce que ce framework s'interdit.
+	*
+	* Il était de surcroît incohérent avec lui-même : la cascade `.env` ne
+	* chargeait alors NI `.env.production` ni `.env.development` (le lanceur
+	* rendait `undefined`), si bien que l'application se déclarait en production
+	* sans en avoir la configuration.
+	*/
+	environment = DEFAULT_ENGINE_ENVIRONMENT;
+	debug = false;
+	appEnvironment = { environment: process.env.NODE_ENV };
+	path = process.cwd();
+	typeCluster = this.clusterIsMaster() ? "master" : "worker";
+	pid = process.pid;
+	workerId = cluster.worker?.id;
+	worker = cluster.worker;
+	console = this.isConsole();
+	/**
+	* Vrai terminal disponible ? Résolu UNE fois dans le constructor (volet
+	* « environnement », cf {@link IKernel.isTTY}). Surchargeable via `NF_NO_TTY` (test/CI).
+	*/
+	isTTY = process.env.NF_NO_TTY ? false : process.stdout?.isTTY === true;
+	/**
+	* Timer no-op ref'd gardant l'event loop vivant pendant un {@link park} `keepAlive`
+	* (daemon CONSOLE sans socket). `null` tant qu'aucun park alive — lazy. Nettoyé par
+	* {@link terminate}.
+	*/
+	parkTimer = null;
+	/**
+	* Le shutdown en cours, s'il y en a un — garde de ré-entrance de
+	* {@link terminate}. `null` par défaut : aucune allocation tant qu'on ne
+	* termine pas, et un kernel ne termine qu'une fois.
+	*/
+	terminating = null;
+	/** Minuterie d'auto-arrêt d'un runtime en dérogation de modules dev (`null` = aucune). */
+	devModulesStopTimer = null;
+	node_start = process.env.NF_START || this.options.node_start;
+	platform = process.platform;
+	projectName = "NODEFONY";
+	uptime = (/* @__PURE__ */ new Date()).getTime();
+	numberCpu = os.cpus().length;
+	modules = {};
+	tmpDir;
+	/**
+	* Répertoire des données runtime **persistées** (`<path>/var`) — base commune des
+	* stores fichier (passkeys, TOTP, sessions) et bases SQLite. Gitignoré comme
+	* `tmpDir` → garanti créé au boot. Distinct de `tmpDir` (éphémère).
+	*/
+	varDir;
+	interfaces;
+	domain = "localhost";
+	progress = Events.onInit;
+	injector;
+	/**
+	* Transports d'ÉCRITURE montés par {@link initializeLog} (drivers du Log
+	* Backplane). `initializeLog` est ré-entrant (logger précoce dans `start()`,
+	* puis re-init avec la config app dans `loadApp()`) : on retire ces transports
+	* AVANT d'en monter de nouveaux, sinon chaque `FileTransport` (nouvelle instance
+	* → dédup `addTransport` par référence inopérante) s'accumule et chaque log est
+	* écrit N× dans le JSONL. Lazy (`null` tant qu'aucun transport monté).
+	*/
+	_mountedLogTransports = null;
+	isDev = false;
+	isProd = true;
+	/**
+	* En dev, `BootReporter` (checklist animée) prend la main sur l'en-tête de boot
+	* (splash + banner `SERVER`). Quand `true`, `initCluster()` ne ré-imprime PAS le
+	* banner `logEnv()` (le reporter le place lui-même, dans le bon ordre). Dev-only,
+	* boot-only — 0 impact runtime/requête.
+	*/
+	reporterOwnsHeader = false;
+	pendingModuleAddLogs = [];
+	/**
+	* Échecs de boot non fatals (fail-soft) agrégés pour le {@link IBootReport}.
+	* **Lazy** : reste `null` tant qu'aucun module/hook n'échoue → 0 allocation sur
+	* un boot nominal (règle perf core).
+	*/
+	bootFailures = null;
+	/**
+	* Modules du manifeste volontairement NON chargés (gating `policy`/`when` de
+	* {@link resolveModuleEntries}), avec leur raison — un gating silencieux se lit
+	* comme un module perdu. **Lazy** : `null` si rien n'est gaté (cas nominal).
+	*/
+	modulesGated = null;
+	/**
+	* Compteurs WARNING/ERROR du journal de boot, **figés** quand `postReady` passe
+	* true (après, le ring syslog mélange boot et runtime). `null` = boot en cours
+	* → {@link getBootReport} compte à la volée.
+	*/
+	bootLogCounts = null;
+	/**
+	* Serveurs réellement en écoute, figés à `onPostReady`. `null` tant que le boot
+	* n'a pas atteint cette phase ; `[]` si profil serveur mais rien n'écoute (cas
+	* du garde-fou 0-serveur).
+	*/
+	bootServers = null;
+	/** Horodatage (`Date.now()`) du début de `start()` — base de `durationMs`. */
+	bootStartedAt = 0;
+	/**
+	* Lignes de détail de boot par phase (canal NEUTRE) : un module pousse via
+	* {@link reportBootLine} ce qu'il veut voir RACONTÉ sous sa phase (ex. un
+	* adapter ORM : « drizzle → sqlite »). Le core reste agnostique du contenu.
+	* Lazy : `null` tant qu'aucune ligne (dev-only en pratique).
+	*/
+	bootLines = null;
+	/**
+	* Construit le Kernel. **Side effect critique** : appelle `Nodefony.setKernel(this)` →
+	* écrase le singleton global. Isoler les tests avec un mock minimal pour éviter de
+	* polluer les autres tests qui dépendent de `Nodefony.getKernel()`.
+	*
+	* Récupère le container du CLI si présent, sinon en crée un nouveau. Initialise les
+	* interfaces réseau OS pour `setDomain()`. Fire `"onInit"` à la fin.
+	*
+	* @param environment - mode MOTEUR (`"development"` / `"production"`, ou leurs
+	*   abrégés `"dev"` / `"prod"`). ⚠️ Ni `"test"` ni `"staging"` : `test` est une valeur
+	*   de `NODE_ENV` normalisée en `runtimeEnv` (→ `ConfigContext.isTest`), et un staging
+	*   tourne EN mode `production` — il se distingue par `APP_ENV`, pas par son moteur.
+	* @param cli - kernel CLI parent (fournit container, packageManager, commander). Peut être null.
+	* @param options - options surchargées (events.nbListeners, log, etc.).
+	*/
+	constructor(environment, cli, options) {
+		const container = cli?.container;
+		const mergedOptions = extend({}, kernelDefaultOptions, options);
+		super("KERNEL", container, void 0, mergedOptions);
+		this.environment = environment;
+		if (process.env.NF_KERNEL_TRACE_FILE) try {
+			fs.appendFileSync(process.env.NF_KERNEL_TRACE_FILE, `${process.pid}:${environment}\n`);
+		} catch {}
+		this.setMaxListeners(mergedOptions.events?.nbListeners ?? 60);
+		Nodefony.setKernel(this);
+		this.kernel = this;
+		this.set("kernel", this);
+		this.runProfile = { ...CONSOLE_RUN_PROFILE };
+		this.cli = this.setCli(cli);
+		this.interfaces = this.getNetworkInterfaces();
+		this.injector = new Injector(this);
+		this.set("injector", this.injector);
+		this.fire("onInit", this);
+	}
+	/**
+	* Point d'entrée du boot — et POINT DE PASSAGE UNIQUE de l'échec de démarrage.
+	*
+	* Le déroulé vit dans {@link startBoot} ; cette enveloppe ne fait qu'une
+	* chose : figer le bilan (`var/last-boot.json`) quand le démarrage est
+	* abandonné, puis relancer l'erreur inchangée. Le bilan d'un démarrage
+	* ABOUTI est écrit ailleurs — au moment où il est complet (cf
+	* {@link captureBootServers} / `onPostReady`), pas ici.
+	*
+	* Pourquoi l'échec ICI et pas dans les `catch` du pipeline : ils sont une
+	* douzaine, et chacun relance. Y répartir l'écriture donnerait autant
+	* d'implémentations d'une même règle — dont certaines seraient oubliées au
+	* premier ajout de phase, sans que rien ne le signale. Un seul point ne peut
+	* pas diverger de lui-même.
+	*
+	* Et pourquoi RIEN n'est effacé sur un succès : une commande console
+	* (`inspect`, une commande de module) démarre et réussit sans jamais monter
+	* de serveur. Effacer ici ferait disparaître le bilan d'un échec applicatif
+	* au premier `nodefony inspect` lancé pour le diagnostiquer — l'outil de
+	* diagnostic détruirait la preuve qu'il vient chercher.
+	*
+	* @returns `this` après boot complet.
+	* @throws Toute exception du pipeline est loggée CRITIC puis re-throw — le
+	*         bilan n'en absorbe aucune.
+	*/
+	async start() {
+		try {
+			return await this.startBoot();
+		} catch (e) {
+			this.traceFatalBootFailure(e);
+			throw e;
+		}
+	}
+	/**
+	* Traduit le bitmask {@link progress} en NOM de la dernière phase atteinte.
+	*
+	* C'est l'information la plus discriminante d'une trace d'échec : elle situe
+	* le défaut dans le cycle de vie (« mort à `onBoot` » désigne les modules,
+	* « mort à `onReady` » désigne les serveurs) sans qu'on ait à lire une pile.
+	*
+	* @returns le nom de la phase la plus avancée, `"onInit"` par défaut.
+	*/
+	lastReachedPhase() {
+		let reached = "onInit";
+		for (const [name, bit] of Object.entries(Events)) if (this.progress & bit) reached = name;
+		return reached;
+	}
+	/**
+	* Socle commun des deux bilans (abouti et abandonné) — ce qui est vrai dans
+	* les deux cas se remplit ICI, une seule fois.
+	*
+	* @param status - issue du démarrage.
+	* @returns le bilan, prêt à être complété par l'appelant.
+	*/
+	baseLastBoot(status) {
+		return {
+			status,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			profile: this.lastBootProfile(),
+			command: this.command?.name,
+			environment: this.environment ?? "unknown",
+			pid: process.pid,
+			node: process.version,
+			phase: this.lastReachedPhase()
+		};
+	}
+	/**
+	* QUI démarre — la distinction qui empêche `doctor` de désigner le mauvais
+	* coupable.
+	*
+	* Un `nodefony inspect` ou un `orm:migrate` boote en console et échoue
+	* souvent pour une raison qui ne concerne pas le serveur : un environnement
+	* absent du terminal où l'on tape. Sans ce champ, son bilan s'écrivait
+	* par-dessus celui du serveur, et le diagnostic envoyait chercher là où il
+	* n'y a rien.
+	*
+	* `cluster` est distingué de `server` parce que le maître ne sert AUCUNE
+	* requête lui-même : ses workers le font. Le critère se CONSTATE — la
+	* commande `cluster` dans le process primaire ; un worker forké, lui, porte
+	* `cluster.isWorker` et sert bien des requêtes, donc c'est un `server`.
+	*
+	* @returns le profil de ce démarrage.
+	*/
+	lastBootProfile() {
+		if (!this.runProfile?.servers) return "console";
+		if (this.command?.name === "cluster" && cluster.isPrimary) return "cluster";
+		return "server";
+	}
+	/**
+	* Fige le bilan d'un démarrage ABOUTI.
+	*
+	* Ce n'est pas une redondance avec le journal : le bilan retient ce que le
+	* terminal a montré une fois puis perdu — les briques ignorées AVEC leur
+	* raison, celles que le gating a écartées, les comptes d'avertissements. Une
+	* application qui démarre amputée ne se signale plus après sa première
+	* seconde de vie ; c'est justement le cas que personne ne diagnostique.
+	*
+	* @param report - bilan de boot figé (serveurs capturés).
+	*/
+	writeBootSummary(report) {
+		const entry = this.baseLastBoot("ok");
+		entry.durationMs = report.durationMs;
+		entry.healthy = report.healthy;
+		entry.modulesLoaded = report.modulesLoaded;
+		entry.warnings = report.warnings;
+		entry.errors = report.errors;
+		entry.criticals = report.criticals ?? void 0;
+		entry.remediation = report.remediation ?? void 0;
+		if (report.modulesSkipped.length) entry.bricksSkipped = report.modulesSkipped.map((f) => ({
+			module: f.module,
+			reason: f.reason,
+			phase: f.phase
+		}));
+		if (report.modulesGated.length) entry.bricksGated = report.modulesGated.map((g) => ({
+			module: g.module,
+			reason: g.reason
+		}));
+		if (report.serversListening.length) entry.serversListening = report.serversListening.map((s) => `${s.type}${s.port ? `:${s.port}` : ""}`);
+		writeLastBoot(this.path, entry);
+	}
+	/**
+	* Consigne le démarrage ABANDONNÉ, sans jamais pouvoir aggraver la panne.
+	*
+	* À ne pas confondre avec {@link recordBootFailure}, qui collecte les échecs
+	* **non fatals** (fail-soft) d'un boot qui, lui, continue. Les deux se
+	* complètent, et c'est pourquoi le bilan embarque le second : quand le boot
+	* meurt, savoir quelles briques avaient DÉJÀ été ignorées avant désigne
+	* souvent la cause réelle — un module optionnel tombé emporte plus loin celle
+	* qui en dépendait, et seul le premier incident l'explique.
+	*
+	* @param e - l'erreur qui a fait abandonner le boot.
+	*/
+	traceFatalBootFailure(e) {
+		const err = e instanceof Error ? e : new Error(String(e));
+		const entry = this.baseLastBoot("failed");
+		entry.error = {
+			message: err.message,
+			name: err.name,
+			exitCode: err.exitCode,
+			stack: err.stack
+		};
+		if (this.bootFailures?.length) entry.bricksSkipped = this.bootFailures.map((f) => ({
+			module: f.module,
+			reason: f.reason,
+			phase: f.phase
+		}));
+		const { criticals } = this.countBootLogIssues();
+		if (criticals) entry.criticals = criticals;
+		writeLastBoot(this.path, entry);
+	}
+	/**
+	* Déroulé du boot. Fire `"onPreStart"` puis `"onStart"`, charge l'application
+	* (`loadApp()`), instancie services kernel (Rollup), puis enchaîne sur
+	* `preRegister()` → `boot()` → `onReady()` → `initServers()`.
+	*
+	* Si `command.kernelEvent` matche la phase atteinte → {@link finishOrPark} immédiat
+	* (la command a fini son boulot : terminate one-shot OU park daemon long-running) —
+	* même sémantique de sortie à TOUTES les phases d'arrêt.
+	*
+	* Appelé UNIQUEMENT par {@link start}, qui porte la trace d'échec.
+	*
+	* @returns `this` après boot complet.
+	* @throws Toute exception du pipeline est loggée CRITIC puis re-throw.
+	*/
+	async startBoot() {
+		if (this.bootStartedAt === 0) this.bootStartedAt = Date.now();
+		this.debug = Boolean(this.cli?.commander?.opts().debug) || false;
+		this.trunk = await this.isTrunk();
+		this.initializeLog();
+		if (!this.trunk && this.cli) {
+			const hint = this.diagnoseUnbootableProject();
+			if (hint) {
+				this.log(hint, "CRITIC");
+				return await this.terminate(1);
+			}
+			if (!this.isTTY) {
+				this.log(`Pas de projet Nodefony ici (${this.path}) : aucune entrée d'app résolue (package.json \`main\`, dist/index.js ou index.js). Vérifie le répertoire de travail et le build (dist/).`, "CRITIC");
+				return await this.terminate(1);
+			}
+			return await this.cli.runCommandAsync("menu", ["-i"]).then(() => {
+				if (this.command) return this.command?.action(...this.commandArgs).then(() => {
+					return this;
+				});
+				return this;
+			}).catch((e) => {
+				this.log(e, "ERROR");
+				throw e;
+			});
+		}
+		const devSplash = this.environment === "development" && process.env.NF_DEV_CHILD === "1";
+		if (this.cli && devSplash) {
+			await this.cli.showAsciify(this.projectName).catch((e) => {
+				this.log(e, "WARNING");
+			});
+			this.printDevHeader();
+			this.reporterOwnsHeader = true;
+		}
+		const tmpPath = path.resolve(process.cwd(), "tmp");
+		fs.mkdirSync(tmpPath, { recursive: true });
+		this.tmpDir = new FileClass(tmpPath);
+		const varPath = path.resolve(this.path, "var");
+		fs.mkdirSync(varPath, { recursive: true });
+		this.varDir = new FileClass(varPath);
+		if (!this.started) {
+			await this.fireAsync("onPreStart", this).catch((e) => {
+				this.log(e, "CRITIC");
+				throw e;
+			});
+			if (this.setCommandComplete(Events.onPreStart)) return this.finishOrPark(0);
+			await this.loadApp().catch((e) => {
+				if (!e.presented) this.log(e, "CRITIC");
+				throw e;
+			});
+			this.domain = this.setDomain();
+			if (this.app) this.projectName = this.app.getModuleName();
+			return this.fireAsync("onStart", this).then(async () => {
+				this.started = true;
+				if (this.cli) this.runProfile = this.cli.runProfile;
+				if (this.setCommandComplete(Events.onStart)) return this.finishOrPark(0);
+				return this.preRegister();
+			}).catch((e) => {
+				if (e.message !== "(outputHelp)") this.log(e, "CRITIC");
+				throw e;
+			});
+		}
+		return this;
+	}
+	/**
+	* Phase pré-registration — fire `"onPreRegister"` puis `"onRegister"`. Le manifeste
+	* `config.modules` est consommé ici (chargement via {@link loadModulesFromManifest}).
+	*
+	* @returns `this` ou chaîne sur `boot()`.
+	*/
+	async preRegister() {
+		await this.fireLifecycle("onPreRegister", this);
+		if (this.resolveRuntimeEnv(this.cli?.environment) === "development" || !this.runProfile?.servers) this.cli?.writeCompletionManifest().catch(() => {});
+		if (this.setCommandComplete(Events.onPreRegister)) return this.finishOrPark(0);
+		this.preRegistered = true;
+		if (this.cli) {
+			this.debug = Boolean(this.cli?.commander?.opts().debug) || false;
+			this.setEnv(this.cli.environment);
+			this.cli.setProcessTitle(this.projectName.toLowerCase());
+		}
+		this.setNodeEnv(this.environment);
+		this.initCluster();
+		this.applyModuleConfigOverrides();
+		return this.fireLifecycle("onRegister", this).then(() => {
+			this.registered = true;
+			this.warnReservedConfigKeys();
+			if (this.setCommandComplete(Events.onRegister)) return this.finishOrPark(0);
+			return this.boot().catch((e) => {
+				throw e;
+			});
+		}).catch((e) => {
+			throw e;
+		});
+	}
+	fixCommanderCli(version = true, debug = false) {
+		if (this.cli && this.cli.commander && this.cli.commander?.options.length) {
+			if (version) {
+				if (this.cli?.commander?.options.some((opt) => opt.short === "-v" || opt.long === "--version")) {
+					const index = this.cli.commander.options.findIndex((value) => {
+						if (value.flags === "-v, --version") return value;
+					});
+					if (index >= 0) this.cli.commander.options.splice(index, 1);
+				}
+			}
+			if (debug) {
+				if (this.cli?.commander?.options.some((opt) => opt.short === "-d" || opt.long === "--debug")) {
+					const index = this.cli.commander.options.findIndex((value) => {
+						if (value.flags === "-d, --debug") return value;
+					});
+					if (index >= 0) this.cli.commander.options.splice(index, 1);
+				}
+			}
+		}
+	}
+	/**
+	* Phase boot — fire `"onPreBoot"` puis `"onBoot"`. Les services kernel (router, certificats,
+	* sessions, http-kernel) sont créés ici via les décorateurs `@services`.
+	*
+	* @returns `this` ou chaîne sur `onReady()`.
+	*/
+	async boot() {
+		await this.fireLifecycle("onPreBoot", this);
+		if (this.setCommandComplete(Events.onPreBoot)) return this.finishOrPark(0);
+		return this.fireLifecycle("onBoot", this).then(() => {
+			this.booted = true;
+			if (this.setCommandComplete(Events.onBoot)) return this.finishOrPark(0);
+			return this.onReady().catch((e) => {
+				throw e;
+			});
+		}).catch((e) => {
+			throw e;
+		});
+	}
+	/**
+	* Phase ready — fire `"onReady"`, démarre les serveurs HTTP/WS via `initServers()`, log
+	* memoryUsage, puis fire `"onPostReady"`. C'est ici que les Server Listen apparaissent.
+	*
+	* @returns `this` après tout le pipeline post-ready.
+	*/
+	async onReady() {
+		return this.fireLifecycle("onReady", this).then(async () => {
+			this.ready = true;
+			if (this.setCommandComplete(Events.onReady)) return this.finishOrPark(0);
+			return this.initServers().then(async (servers) => {
+				this.captureBootServers(servers);
+				const report = this.getBootReport();
+				this.logBootVerdict(report);
+				this.writeBootSummary(report);
+				if (global && global.gc) {
+					this.memoryUsage("MEMORY POST READY ");
+					setTimeout(() => {
+						if (global && global.gc) global.gc();
+						this.memoryUsage("EXPOSE GARBADGE COLLECTOR ON START");
+					}, 2e4);
+				} else this.memoryUsage("MEMORY POST READY ");
+				return this.fireLifecycle("onPostReady", this).then(() => {
+					this.postReady = true;
+					this.bootLogCounts = this.countBootLogIssues();
+					if (!this.suppressBootBanners) servers.map((server) => {
+						server.showBanner();
+					});
+					if (!report.healthy && report.serversExpected) return this.terminate(69);
+					if (this.setCommandComplete(Events.onPostReady)) {
+						if (!this.runProfile.servers) return this.finishOrPark(typeof process.exitCode === "number" ? process.exitCode : 0);
+						this.log(`Live cycle terminate`, "DEBUG");
+						return this;
+					} else return this;
+				}).catch((e) => {
+					throw e;
+				});
+			});
+		}).catch((e) => {
+			throw e;
+		});
+	}
+	/**
+	* Démarre les serveurs HTTP/HTTPS/HTTP2/WS/WSS via le `HttpKernel` (@nodefony/http).
+	*
+	* Si le HttpKernel n'est pas dans le container (mode CONSOLE pur) → retourne tableau vide.
+	* Sinon → délègue à `httpKernel.initServers()`, fire `"onServersReady"` après succès.
+	*
+	* **Le profil d'exécution fait foi** : une commande qui déclare ne pas vouloir
+	* de serveur (`runProfile.servers === false`, le défaut console) n'en obtient
+	* pas, même si le `HttpKernel` est chargé. Sans cette garde, toute commande
+	* poussée jusqu'à `onPostReady` ouvrait les ports par effet de bord — elle
+	* échouait alors si un serveur tournait déjà, et refusait le service à celui
+	* qui tournait pendant sa brève existence. `onServersReady` n'est pas émis :
+	* annoncer des serveurs prêts quand il n'y en a aucun rendrait l'événement
+	* inexploitable pour ceux qui l'écoutent.
+	*
+	* @returns array d'instances de serveurs démarrés (ou `[]`).
+	*/
+	async initServers() {
+		if (this.runProfile?.servers === false) return [];
+		const httpKernel = this.get("HttpKernel");
+		if (httpKernel) return await httpKernel.initServers().then(async (servers) => {
+			await this.fireAsync("onServersReady");
+			return servers;
+		}).catch((e) => {
+			throw e;
+		});
+		return [];
+	}
+	/**
+	* Parke le flow : retourne une Promise qui ne se résout JAMAIS (met en pause le
+	* pipeline async appelant). **Source UNIQUE** du « rester vivant jusqu'à un signal »
+	* — remplace les `new Promise(() => {})` inline disséminés (DevSupervisor parent,
+	* master cluster, daemon).
+	*
+	* ⚠️ Une Promise pending ne garde PAS Node en vie (le process sort dès l'event loop
+	* vide). Pour un daemon CONSOLE qui n'a aucun socket/handle → `keepAlive: true` ref un
+	* timer no-op (réveil ~tous les 12 j, coût nul). Les superviseurs ont DÉJÀ leurs propres
+	* handles (watchers fs du DevSupervisor / canaux IPC workers + timers de sonde du
+	* master) → `keepAlive` défaut `false` : aucun handle en trop qui empêcherait leur
+	* sortie naturelle au shutdown. Le timer alive est nettoyé par {@link terminate}.
+	*
+	* Signal handling : déjà fourni globalement par `Cli.handleSignals` → `terminate()`.
+	*
+	* @param opts.keepAlive - ref un timer no-op pour garder l'event loop vivant.
+	* @returns Promise jamais résolue.
+	*/
+	park(opts = {}) {
+		if (opts.keepAlive && this.parkTimer === null) this.parkTimer = setInterval(() => {}, 1 << 30);
+		return new Promise(() => {});
+	}
+	/**
+	* Fin de cycle d'une commande ayant atteint sa phase cible : `terminate(code)` pour un
+	* run one-shot (build, install, batch, help), MAIS **park** pour un run long-running
+	* sans serveur (daemon CONSOLE : worker de queue, consumer, agent IA, cron daemon).
+	*
+	* C'est ICI que `lifetime` devient effectif : avant, chaque commande daemon inlinait
+	* son propre park ; désormais le Kernel décide à partir de la `lifetime` DÉCLARÉE par
+	* la commande (`command.lifetime`, fallback `runProfile.lifetime`) croisée avec
+	* `runProfile.servers` (les serveurs gardent déjà le process vivant → jamais de park).
+	*
+	* @param code - exit code si run one-shot.
+	* @returns Promise du terminate (one-shot) ou park (daemon, jamais résolue).
+	*/
+	finishOrPark(code) {
+		if ((this.command?.lifetime ?? this.runProfile.lifetime) === "longrunning" && !this.runProfile.servers) {
+			this.log("CONSOLE long-running — park (no server, until signal)", "DEBUG");
+			return this.park({ keepAlive: true });
+		}
+		const failure = typeof process.exitCode === "number" && process.exitCode !== 0 ? process.exitCode : null;
+		return this.terminate(failure ?? code);
+	}
+	clean() {
+		this.removeAllListeners();
+		this.modules = {};
+	}
+	setCommand(command) {
+		this.command = command;
+	}
+	setDomain() {
+		if (this.options.domain == "selectAuto") return this.getFirstExternalInterface()?.address || "localhost";
+		else return this.options.domain || "localhost";
+	}
+	readConfig(config) {
+		if (!config) return this.options;
+		return extend(this.options, config);
+	}
+	async addService(service, module, ...args) {
+		return module.addService(service, module, ...args);
+	}
+	/**
+	* Instancie un service au niveau kernel (vs niveau module via `Module.addService`).
+	*
+	* Utilisé pour les services partagés essentiels au boot (Rollup, HttpKernel).
+	* Stocke directement dans le container kernel.
+	*
+	* @param ctor - constructeur du service (typiquement décoré `@injectable`).
+	* @param args - args additionnels après les `@inject` resolved.
+	* @returns instance du service prête à l'usage.
+	*/
+	async addKernelService(service, ...args) {
+		const inst = Injector.instantiate(service, this, ...args);
+		if (this.get(inst.name)) this.log(`SERVICE ALREADY EXIST  override old service  : ${inst.name}`, "WARNING");
+		this.log(`SERVICE ADD : ${inst.name}`, "DEBUG");
+		const serviceInit = inst;
+		await this.guardServiceInitialize(serviceInit, this, true);
+		Injector.rememberContainerKey(service, inst.name);
+		this.set(inst.name, inst);
+		return this.get(inst.name);
+	}
+	async loadService(service, module = this.app, ...args) {
+		if (!module) throw new Error(`Applcation not ready`);
+		const res = await import(toImportSpecifier(service));
+		return this.addService(res.default, module, ...args);
+	}
+	/**
+	* Charge un module du manifeste. La résolution part de l'APPLICATION
+	* ({@link resolveModuleEntry}) et non du paquet `nodefony` : sans cela, un
+	* module local de l'app (workspace `modules/*`) est introuvable dès que le core
+	* vit hors de l'arbre `node_modules` de l'app (`--link`, monorepo, pnpm).
+	*/
+	async loadModule(moduleName) {
+		const moduleClass = await import(resolveModuleEntry(this.path, moduleName));
+		return await this.addModule(moduleClass.default);
+	}
+	/**
+	* Résout la liste ORDONNÉE des entrées de modules à charger depuis le manifeste
+	* `config.modules`, AVEC leur config colocalisée (`use(name, config)`). L'ordre
+	* du tableau est conservé (= priorité de chargement) ; `policy`/`when` ne font
+	* que FILTRER, jamais réordonner.
+	*
+	* - `policy:"dev"` → ignoré en production (gain mémoire = non-chargement ; en
+	*   ESM un module importé n'est jamais déchargé).
+	* - `when(config)` faux → ignoré (sa config colocalisée l'est aussi → pas de
+	*   warning « module absent » sur un module volontairement gaté).
+	* - string nue → policy `optional`, toujours chargée, sans config.
+	*
+	* @returns entrées `{ name, config? }` à charger, dans l'ordre.
+	*/
+	resolveModuleEntries() {
+		const isProd = this.resolveRuntimeEnv(this.cli?.environment) === "production";
+		const devModulesForced = isProd && process.env["NF_WITH_DEV_MODULES"] === "1";
+		const outcome = gateModuleManifest(this.options.modules, {
+			isProduction: isProd,
+			forceDevModules: devModulesForced,
+			config: this.options
+		});
+		this.modulesGated = null;
+		for (const gated of outcome.gated) this.recordModuleGated(gated.module, gated.reason);
+		for (const name of outcome.derogated) {
+			this.log(`module "${name}" (policy "dev") chargé en PRODUCTION sur ${FORCE_DEV_MODULES_ENV}=1 — dérogation explicite, à ne jamais poser sur un déploiement réel`, "WARNING", "KERNEL");
+			this.armDevModulesSelfStop();
+		}
+		return outcome.entries;
+	}
+	/**
+	* Enregistre un module volontairement non chargé (gating `policy`/`when`) avec
+	* sa raison — surfacé par le bilan de boot ({@link getBootReport}). Lazy : 0
+	* allocation si rien n'est gaté.
+	*
+	* @param module - nom d'entrée du manifeste.
+	* @param reason - raison lisible du non-chargement.
+	*/
+	recordModuleGated(module, reason) {
+		(this.modulesGated ??= []).push({
+			module,
+			reason
+		});
+		this.log(`MODULE GATED : ${module} — ${reason}`, "DEBUG");
+	}
+	/**
+	* Arme l'auto-arrêt d'un runtime de production ayant dérogé au gating des modules
+	* de développement (cf {@link FORCE_DEV_MODULES_ENV}). Idempotent : une seule
+	* minuterie, quel que soit le nombre de modules concernés.
+	*
+	* **L'échéance est ANNONCÉE, deux fois.** Un arrêt temporisé qui surprend est pire
+	* que pas de garde-fou : il coupe un banc de charge au milieu d'une mesure, et le
+	* journal qu'on relira ensuite accusera le code. On dit donc l'échéance au
+	* démarrage — avec le moyen de l'allonger — puis on prévient avant de tomber, et
+	* l'arrêt lui-même en donne la raison. Les minuteries sont `unref` : elles
+	* n'empêchent jamais une sortie naturelle.
+	*/
+	armDevModulesSelfStop() {
+		if (this.devModulesStopTimer) return;
+		const ttl = resolveDevModulesTtlMs(process.env);
+		const minutes = Math.round(ttl / 6e4);
+		this.log(`runtime en DÉROGATION (modules dev en production) — arrêt automatique dans ${minutes} min. Allonger : ${FORCE_DEV_MODULES_TTL_ENV}=<minutes> (plafond ${Math.round(FORCE_DEV_MODULES_TTL_MAX_MS / 6e4)} min, jamais désarmé)`, "WARNING", "KERNEL");
+		const notice = ttl - 3e5;
+		if (notice > 0) setTimeout(() => {
+			this.log(`arrêt automatique dans 5 min (dérogation ${FORCE_DEV_MODULES_ENV}) — termine ta mesure ou relance avec ${FORCE_DEV_MODULES_TTL_ENV} plus haut`, "WARNING", "KERNEL");
+		}, notice).unref();
+		this.devModulesStopTimer = setTimeout(() => {
+			this.log(`arrêt automatique : ce runtime tournait en production avec des modules "policy: dev" (${FORCE_DEV_MODULES_ENV}=1). Ce n'est pas une panne — c'est la garde qui empêche une dérogation de banc de survivre à un déploiement`, "CRITIC", "KERNEL");
+			this.terminate(0);
+		}, ttl);
+		this.devModulesStopTimer.unref();
+	}
+	/**
+	* Charge en série les modules résolus par {@link resolveModuleEntries} via
+	* `loadModule` (import dynamique → lazy : un module hors liste n'est jamais
+	* importé), puis applique la config colocalisée (`use(name, config)`) de
+	* chaque entrée. Branché à `onPreRegister` par {@link loadApp} si un manifeste
+	* `config.modules` est présent. Seul orchestrateur du chargement de modules.
+	*/
+	async loadModulesFromManifest() {
+		for (const entry of this.resolveModuleEntries()) try {
+			const mod = await this.loadModule(entry.name);
+			if (entry.config) {
+				mod.options = extend(true, {}, mod.options, entry.config);
+				this.log(`MODULE CONFIG (use) : ${entry.name}`, "DEBUG");
+			}
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			this.log(`MODULE LOAD: échec non bloquant (fail-soft) de "${entry.name}" — ${msg}`, "WARNING");
+			this.recordBootFailure({
+				module: entry.name,
+				reason: msg,
+				phase: "load"
+			});
+		}
+	}
+	/**
+	* Instancie un module et l'enregistre dans `kernel.modules[name]`. Appelle `initialize(this)`
+	* sur le module si défini (équivalent constructeur async).
+	*
+	* @param Mod - constructeur du module (extends `Module`).
+	* @param args - arguments additionnels (après `kernel, path, options` par défaut).
+	* @returns instance du module enregistrée.
+	*/
+	async addModule(Mod, ...args) {
+		const mod = new Mod(this, ...args);
+		this.modules[mod.name] = mod;
+		if (this.pendingModuleAddLogs) this.pendingModuleAddLogs.push(mod.name);
+		else this.log(`MODULE ADD : ${mod.name}`, "INFO");
+		if (mod.init) {
+			this.log(`MODULE INITIALIZE : ${mod.name}`, "DEBUG");
+			const init = mod.init.bind(mod);
+			await this.guardInitialize(() => init(this), mod.name, mod.constructor.critical);
+		}
+		return mod;
+	}
+	getModule(name) {
+		return this.modules[name];
+	}
+	getModules() {
+		return this.modules;
+	}
+	/**
+	* Applique les overrides de config inter-modules (clés `Module-<name>` /
+	* `module-<name>` dans les options d'un module — typiquement l'app qui
+	* reconfigure un autre module) en itérant TOUS les modules enregistrés.
+	*
+	* Appelé par {@link preRegister} ENTRE `onPreRegister` (tous les modules sont
+	* alors enregistrés via `@modules`/`loadApp`) et `onRegister` (où les modules
+	* valident + gèlent leur config Zod dans `onKernelRegister`). Corrige la dette
+	* d'ordering : l'override était auparavant posé à `onPreBoot` (après la
+	* validation) → silencieusement ignoré par tout module qui fige sa config tôt
+	* (redis, realtime…). Désormais il précède la validation, qui le voit.
+	*
+	* Ordre d'application = ordre d'insertion dans `this.modules` (app chargée en
+	* premier → configure les modules avant qu'ils ne se valident). Idempotent.
+	*/
+	applyModuleConfigOverrides() {
+		for (const name in this.modules) this.modules[name].readOverrideModuleConfig();
+		this.applyEnvConfigOverrides();
+	}
+	/**
+	* Applique les overrides de config par variable d'environnement générique
+	* `NF__<MODULE>__<CHEMIN…>` (ADR-0006 D3) sur la config de chaque module ciblé.
+	*
+	* Résolu 1× au boot (hors hot path). La surcharge est déposée sur
+	* `module.options` → elle sera validée par le schéma Zod du module à
+	* `onKernelRegister` (fail-closed si invalide). Un module ou un chemin
+	* introuvable est SIGNALÉ (WARNING) sans bloquer le boot — jamais de clé
+	* fantôme silencieuse. Les valeurs de chemins « secrets » sont rédigées au log.
+	*/
+	applyEnvConfigOverrides() {
+		const overrides = parseNfEnvOverrides(process.env);
+		if (!overrides.length) return;
+		/**
+		* Le schéma d'un module, quand il en publie un — jamais une hypothèse.
+		*
+		* `configSchema()` est une méthode de `Module`, mais rien ne garantit qu'un
+		* module l'ait : un paquet tiers, un module ancien ou un objet de banc
+		* peuvent n'être que compatibles de forme. Appeler à l'aveugle ferait tomber
+		* le BOOT sur une amélioration de confort — le pire échange possible.
+		*/
+		const schemaDe = (m) => {
+			const f = m.configSchema;
+			return typeof f === "function" ? f.call(m) ?? void 0 : void 0;
+		};
+		for (const ov of overrides) {
+			const mod = this.findModuleBySegment(ov.moduleSeg);
+			if (!mod) {
+				const suggestion = closestMatch(ov.moduleSeg, this.moduleSegments());
+				this.log(`Override env ignoré : module "${ov.moduleSeg}" introuvable (${ov.envKey})` + (suggestion ? ` — vouliez-vous dire « ${suggestion} » ?` : ""), "WARNING");
+				continue;
+			}
+			if (applyResolvedPath(mod.options, ov.path, ov.value, ov.raw, schemaDe(mod))) {
+				const appliedValue = readResolvedPath(mod.options, ov.path);
+				const shown = pathLooksSecret(ov.path) ? "«***»" : JSON.stringify(appliedValue);
+				this.log(`Override env: ${mod.name}.${ov.path.join(".")} = ${shown}`, "INFO");
+			} else this.log(`Override env ignoré : chemin "${ov.path.join(".")}" inconnu sur ${mod.name} (${ov.envKey})` + resolveFailureHint(mod.options, ov.path, schemaDe(mod)), "WARNING");
+		}
+	}
+	/**
+	* Filet « clé réservée » : avertit au BOOT quand une application a posé une clé de
+	* config marquée `reserved` (inerte — son levier vit ailleurs) à une valeur
+	* non-défaut. C'est le pendant runtime du drapeau que Studio se contente de griser :
+	* sans lui, une clé réservée écrite reste un silence total (l'app croit régler un
+	* comportement, rien ne se produit, rien ne le dit). Symétrique du signalement des
+	* chemins env inconnus ({@link applyEnvConfigOverrides}).
+	*
+	* Générique — 0 `if` par module : le JSON Schema (`Module.configSchema()`, avec les
+	* flags `.meta()`) et la config résolue suffisent. Un module non migré (schéma
+	* `null`) est ignoré. Appelé 1× après `onRegister` (options validées) → hors hot
+	* path ; le message inclut la `description` du champ, qui nomme la remplaçante.
+	*/
+	warnReservedConfigKeys() {
+		for (const name in this.modules) {
+			const mod = this.modules[name];
+			const schema = mod.configSchema();
+			if (!schema) continue;
+			const hits = findSetReservedKeys(schema, mod.options);
+			for (const hit of hits) this.log(`Clé de config RÉSERVÉE posée sans effet : ${mod.name}.${hit.path} est inerte.${hit.description ? " " + hit.description : ""}`, "WARNING", "CONFIG");
+		}
+	}
+	/**
+	* Résout un segment de nom de module (minuscule, issu d'un `NF__<MODULE>__…`)
+	* vers son instance : compare au **basename** du nom de module (après le `/`),
+	* insensible à la casse (`security` → `@nodefony/security`).
+	*
+	* @param seg - segment module normalisé (minuscule).
+	* @returns le module correspondant, ou `undefined`.
+	*/
+	findModuleBySegment(seg) {
+		for (const name in this.modules) {
+			const slash = name.lastIndexOf("/");
+			if ((slash >= 0 ? name.slice(slash + 1) : name).toLowerCase() === seg) return this.modules[name];
+		}
+	}
+	/**
+	* Basenames de tous les modules chargés (segment ciblable par `NF__<MODULE>__…`).
+	* Sert au « did you mean » quand le segment module d'un override ne résout pas.
+	*
+	* @returns la liste des basenames (ex. `security`, `http`).
+	*/
+	moduleSegments() {
+		const out = [];
+		for (const name in this.modules) {
+			const slash = name.lastIndexOf("/");
+			out.push(slash >= 0 ? name.slice(slash + 1) : name);
+		}
+		return out;
+	}
+	/**
+	* Valide la config de l'app au boot via le schéma fourni par l'app, si présent.
+	*
+	* Convention générique (le core ne dépend PAS de Zod) : si l'entrée de l'app
+	* (`dist/index.js`) exporte une fonction `validateConfig`, le Kernel l'exécute sur
+	* la config résolue de l'app (`app.options`) — l'app porte le schéma + la dépendance
+	* Zod. Absent → étape sautée (rétro-compatible avec une app sans schéma). L'import
+	* est déjà résolu par `loadModule` (cache ESM) → coût négligeable, hors hot path.
+	*
+	* @throws si le validateur de l'app rejette la config (message agrégé).
+	*/
+	async validateAppConfig() {
+		const entry = this.resolveAppEntry();
+		if (entry === null) return;
+		(await import(toImportSpecifier(entry))).validateConfig?.(this.app?.options);
+	}
+	/**
+	* Construit le contexte d'environnement (`ctx`) passé au descripteur
+	* {@link defineConfig} d'une app moderne. `runtimeEnv` = `NODE_ENV` normalisé
+	* (`dev`→`development`, conserve `test`/`production`) — granularité que le ctx
+	* expose (`isTest`), DISTINCTE du collapse dev/prod de {@link resolveRuntimeEnv}
+	* (gating moteur : un staging tourne « comme prod »). `appEnv` = axe déploiement
+	* libre (`APP_ENV`/`NF_ENV`). `process.env` est déjà peuplé par `loadEnv`
+	* (bin/nodefony) avant le boot → lecture sûre ici.
+	*
+	* @param env - catalogue env typé exposé par l'app (`export const env = defineEnv(…)`) ;
+	*   `undefined` (app legacy / pas de catalogue) → `process.env` brut.
+	* @returns contexte d'environnement pour `descriptor.resolve(ctx)`.
+	*/
+	buildConfigContext(env) {
+		const raw = process.env.NODE_ENV || this.cli?.environment || "development";
+		const runtimeEnv = raw === "dev" ? "development" : raw;
+		const appEnv = process.env.APP_ENV || process.env.NF_ENV || runtimeEnv;
+		return {
+			env: env ?? process.env,
+			infra: this.infra,
+			appEnv,
+			runtimeEnv,
+			isProd: runtimeEnv === "production",
+			isDev: runtimeEnv === "development",
+			isTest: runtimeEnv === "test"
+		};
+	}
+	/** Infra déclarée mémoïsés — lazy, `null` tant que non lus. */
+	_infra = null;
+	/**
+	* Infra déclarée (`database`/`cache`/`logs`) résolus depuis
+	* `process.env` (modèle « infra déclarée », Phase 0.8). Calcul 1 fois, mémoïsé —
+	* consommé par le ctx `defineConfig` (`ctx.infra`) et par les briques dont
+	* le store vaut `"auto"` (`resolveAutoStore`).
+	*
+	* @throws Error au premier accès si `NF_DATABASE_URL` a un scheme non
+	*   supporté (fail-loud : jamais de repli sqlite silencieux).
+	*/
+	get infra() {
+		if (this._infra === null) this._infra = resolveInfra(process.env);
+		return this._infra;
+	}
+	/**
+	* Registre des résolutions de stores — lazy (`null` tant qu'aucune brique n'a
+	* résolu son store). Alloué au premier `registerStoreResolution` (au boot, une
+	* fois par brique) — jamais dans le hot-path. Clé = `brick` (dernière gagne).
+	*/
+	_storeResolutions = null;
+	/**
+	* Résolutions EFFECTIVES des stores de persistance capturées au boot — la
+	* vérité vécue (replis annoncés inclus). Alimente `/nodefony/kernel/api/stores`
+	* et l'écran Studio « Stores ». Vide si aucune brique n'a encore résolu.
+	*/
+	get storeResolutions() {
+		return this._storeResolutions ? Array.from(this._storeResolutions.values()) : [];
+	}
+	/**
+	* Enregistre la résolution effective d'une brique (idempotent par `brick`).
+	* La provenance est dérivée de `configured` : la sentinelle `"auto"` ⇒
+	* `"infra"` (résolu depuis l'infra déclarée), un backend nommé ⇒ `"explicit"`.
+	*
+	* @param resolution - triplet brique/configuré/résolu + raison + nature
+	*   ({@link IStoreResolution} sans `provenance`, dérivée ici).
+	*/
+	registerStoreResolution(resolution) {
+		if (this._storeResolutions === null) this._storeResolutions = /* @__PURE__ */ new Map();
+		this._storeResolutions.set(resolution.brick, {
+			...resolution,
+			provenance: resolution.configured === "auto" ? "infra" : "explicit"
+		});
+	}
+	/**
+	* Résout les options brutes de l'app. App moderne (`export default defineConfig(…)`)
+	* → `raw` est un descripteur {@link AppConfigDescriptor} (le symbole de marque
+	* survit au spread d'options de `Service`) → résolu avec `ctx` (deep-merge des
+	* défauts framework + validation Zod intégrée à `resolve`). App legacy → objet de
+	* config retourné tel quel (validé séparément par son export `validateConfig`).
+	*
+	* @param raw - export par défaut de l'app (descripteur ou objet de config).
+	* @param ctx - contexte d'environnement ({@link buildConfigContext}).
+	* @returns options résolues + `wasDescriptor` (pilote le fallback de validation).
+	*/
+	resolveAppOptions(raw, ctx) {
+		if (isConfigDescriptor(raw)) {
+			const options = raw.resolve(ctx);
+			this.surfaceAppEnvOverrides(options);
+			return {
+				options,
+				wasDescriptor: true
+			};
+		}
+		return {
+			options: extend(true, {}, defaultAppConfig, raw ?? {}),
+			wasDescriptor: false
+		};
+	}
+	/**
+	* Émet au log le rapport des overrides `NF__APP__*` appliqués à la config app
+	* (INFO par override, secret rédigé) + les warnings « did you mean » des chemins
+	* non résolus. Appelé APRÈS `resolve()` : le logger kernel est prêt (le merge,
+	* lui, tourne dans `resolve()` AVANT le logger → rapport différé, cf defineConfig).
+	*
+	* @param options - config app résolue (porte le rapport en clé non-énumérable).
+	*/
+	surfaceAppEnvOverrides(options) {
+		const report = readAppEnvOverrideReport(options);
+		if (!report) return;
+		for (const ov of report.applied) this.log(`Override env app: ${ov.path.join(".")} = ${ov.secret ? "«***»" : "(env)"}`, "INFO");
+		for (const w of report.warnings) this.log(w, "WARNING");
+	}
+	/**
+	* Construit + PRÉSENTE une erreur de configuration de boot de façon
+	* EXCEPTIONNELLEMENT claire, et EXPLICITE sur la config PAR DÉFAUT du framework
+	* (ce qui s'applique pour tout champ omis). Une config cassée n'est pas
+	* récupérable (le framework ne peut pas deviner ports/modules) → fail-fast PROPRE :
+	* log lisible SANS stack brute (faute de config, pas bug framework), erreur marquée
+	* `presented` (le catch de boot ne re-loggue pas) + `exitCode` `EX_CONFIG`
+	* (l'orchestrateur distingue « mauvaise config » d'un crash logiciel).
+	*
+	* @param title - titre court de l'erreur.
+	* @param detail - phrase de contexte.
+	* @param cause - erreur d'origine (Zod, import, fonction de config).
+	* @param hints - correctifs actionnables.
+	* @returns nodefonyError marquée (`exitCode`/`presented`), à `throw`.
+	*/
+	bootConfigError(title, detail, cause, hints) {
+		const causeMsg = cause instanceof Error ? cause.message : String(cause);
+		const lines = [
+			"",
+			`  ✖ ${title}`,
+			`    ${detail}`,
+			`    Cause : ${causeMsg}`,
+			"",
+			"    Configuration PAR DÉFAUT du framework (appliquée à tout champ omis) :",
+			this.formatDefaults(),
+			"",
+			"    Pour corriger :",
+			...hints.map((h) => `      → ${h}`),
+			""
+		];
+		this.log(lines.join("\n"), "CRITIC");
+		const err = new nodefonyError(`${title} : ${causeMsg}`);
+		err.exitCode = 78;
+		err.presented = true;
+		return err;
+	}
+	/** Rendu lisible (1 ligne/clé top-level) des valeurs par défaut du framework. */
+	formatDefaults() {
+		return Object.entries(defaultAppConfig).map(([k, v]) => {
+			return `      • ${k} = ${v !== null && typeof v === "object" ? JSON.stringify(v) : String(v)}`;
+		}).join("\n");
+	}
+	async loadApp(config) {
+		const appEntry = this.resolveAppEntry() ?? `${this.path}/dist/index.js`;
+		try {
+			this.app = await this.loadModule(appEntry);
+		} catch (e) {
+			throw this.bootConfigError("Chargement de l'application impossible", `Le point d'entrée \`${appEntry}\` n'a pas pu être importé/évalué.`, e, ["Build périmé ou absent → `npm run clean && npm run build`.", "Un fichier de config déréférence le kernel au top-level (résolu à l'import) → différer en getter/lazy."]);
+		}
+		this.app.isApp = true;
+		const appModule = await import(toImportSpecifier(appEntry));
+		const ctx = this.buildConfigContext(appModule.env);
+		let wasDescriptor = false;
+		try {
+			const resolved = this.resolveAppOptions(this.app.options, ctx);
+			this.app.options = resolved.options;
+			wasDescriptor = resolved.wasDescriptor;
+		} catch (e) {
+			throw this.bootConfigError("Configuration de l'application invalide", "La résolution de la configuration (`defineConfig`) a échoué.", e, ["Vérifie les types/valeurs des champs signalés dans `nodefony.config.ts`.", "Une fonction `defineConfig((ctx) => …)` qui lève → corrige la logique par-env."]);
+		}
+		this.options = this.readConfig(extend(this.app.options, config));
+		if (!wasDescriptor) try {
+			await this.validateAppConfig();
+		} catch (e) {
+			throw this.bootConfigError("Configuration de l'application invalide", "Le schéma de validation de l'app a rejeté la configuration.", e, ["Corrige les champs signalés ci-dessus.", "Les valeurs par défaut du framework listées s'appliquent aux champs omis."]);
+		}
+		if (Array.isArray(this.options.modules) && this.options.modules.length) this.once("onPreRegister", async () => {
+			await this.loadModulesFromManifest();
+		});
+		this.initializeLog();
+		this.cli?.setPackageManager(this.options.packageManager);
+		this.core = await this.isCore();
+		this.app.package = await this.app.getPackageJson();
+		this.version = this.app?.getModuleVersion();
+		this.fixCommanderCli();
+		this.cli?.setCommandVersion(this.version);
+		await this.fireAsync("onAppLoad", this.app).catch((e) => {
+			throw e;
+		});
+		return this.app;
+	}
+	/**
+	* Résout le point d'entrée de l'application depuis SON `package.json`
+	* (champ `main` — la source de vérité Node), fallback legacy `dist/index.js`
+	* puis `index.js`. Vérifie l'EXISTENCE du fichier, sans jamais l'importer :
+	* l'exécution (side effects top-level, cache ESM) et la validation du module
+	* (export default = `Module`) appartiennent à {@link loadApp}, une seule
+	* fois, avec son diagnostic `bootConfigError`. Mémoïsé (stable pour le boot).
+	*
+	* Anti faux-positif : un projet Node QUELCONQUE (Express…) a aussi un
+	* `package.json` + `main` → on exige le signal d'identité Nodefony, sans
+	* import : `nodefony` déclaré dans les dépendances, OU installé
+	* (`node_modules/nodefony` — couvre le monorepo self-hosted où la racine ne
+	* le déclare pas mais où le workspace le symlinke).
+	*
+	* En production (image Docker), seuls `package.json` + `dist/` +
+	* `node_modules` sont déployés : la détection ne dépend d'AUCUN source.
+	*
+	* @returns chemin absolu de l'entrée, ou `null` (cwd hors projet Nodefony).
+	*/
+	resolveAppEntry() {
+		if (this._appEntry !== void 0) return this._appEntry;
+		let pkg;
+		try {
+			pkg = JSON.parse(fs.readFileSync(path.resolve(this.path, "package.json"), "utf8"));
+		} catch {
+			this._appEntry = null;
+			return null;
+		}
+		if (!Boolean(pkg.dependencies?.nodefony ?? pkg.devDependencies?.nodefony ?? pkg.peerDependencies?.nodefony) && !fs.existsSync(path.resolve(this.path, "node_modules", "nodefony"))) {
+			this._appEntry = null;
+			return null;
+		}
+		for (const candidate of pkg.main ? [pkg.main] : ["dist/index.js", "index.js"]) {
+			const abs = path.resolve(this.path, candidate);
+			if (fs.existsSync(abs)) {
+				this._appEntry = abs;
+				return abs;
+			}
+		}
+		this._appEntry = null;
+		return null;
+	}
+	async isTrunk() {
+		const entry = this.resolveAppEntry();
+		if (entry === null) return null;
+		return entry.includes(`${path.sep}dist${path.sep}`) ? "typescript" : "javascript";
+	}
+	/**
+	* Diagnostic fail-loud d'un PROJET Nodefony non bootable — différencie les
+	* trois raisons qu'un `resolveAppEntry()` nul confond : « vraiment pas un
+	* projet » (→ `null`, wizard/message générique), « dépendances non
+	* installées » et « non construit ». Sans lui, un `nodefony dev` dans une
+	* app fraîchement générée tombait sur le wizard de création — déroutant
+	* alors qu'il ne manque que `npm install` / `npm run build` (vécu).
+	*
+	* @returns le message actionnable à logger CRITIC, ou `null` si ce dossier
+	*   n'est pas un projet Nodefony (le flux hors-projet reste inchangé)
+	*/
+	diagnoseUnbootableProject() {
+		let pkg;
+		try {
+			pkg = JSON.parse(fs.readFileSync(path.resolve(this.path, "package.json"), "utf8"));
+		} catch {
+			return null;
+		}
+		if (!Boolean(pkg.dependencies?.nodefony ?? pkg.devDependencies?.nodefony ?? pkg.peerDependencies?.nodefony)) return null;
+		if (!fs.existsSync(path.resolve(this.path, "node_modules"))) return `Projet Nodefony détecté (${this.path}) mais dépendances NON INSTALLÉES.\nLance :\n  npm install\n  npm run build\npuis relance ta commande.`;
+		return `Projet Nodefony détecté (${this.path}) mais NON CONSTRUIT (aucune entrée d'app : package.json \`main\`, dist/index.js ou index.js).\nLance :\n  npm run build\npuis relance ta commande.`;
+	}
+	async isCore() {
+		return false;
+	}
+	isModule(subclass) {
+		return isSubclassOf(subclass, Module);
+	}
+	getEventName(event) {
+		return Object.keys(Events).find((key) => Events[key] === event);
+	}
+	setCommandComplete(progress) {
+		const index = this.getEventName(progress);
+		this.progress |= Events[index];
+		return this.isCommandComplete(progress);
+	}
+	isCommandComplete(progress) {
+		const index = this.getEventName(progress);
+		if (this.command) {
+			const int = Events[this.command.kernelEvent];
+			const res = !!(this.progress & int);
+			this.log(`Ckeck Command event : ${this.getEventName(int)}   Progress:  ${index}  :  Complete : ${res}`, "DEBUG", `COMMAND ${this.command.name}`);
+			return res;
+		}
+		return false;
+	}
+	initializeLog() {
+		this.syslog?.removeAllListeners();
+		if (this._mountedLogTransports !== null) {
+			for (const t of this._mountedLogTransports) this.syslog?.removeTransport(t);
+			this._mountedLogTransports = null;
+		}
+		if (this.options.log && !this.options.log.active) return;
+		const logCfg = this.options.log;
+		Syslog.setOutputBuffering(logCfg?.buffered ?? "auto");
+		setLogColor(resolveColorEnabled(this.isTTY));
+		const logDirAbs = path.resolve(process.cwd(), logCfg?.dir ?? "logs");
+		const logDriver = logCfg?.driver ?? "stdout";
+		if (logDriver === "file") {
+			const logPath = logCfg?.file?.path ?? path.join(logDirAbs, `nodefony-${process.pid}.log`);
+			Syslog.setLogSink(new FileSink({
+				path: logPath,
+				sync: logCfg?.file?.sync
+			}));
+		} else if (logDriver === "null") Syslog.setLogSink(NULL_LOG_SINK);
+		else Syslog.setLogSink(null);
+		const maxStack = logCfg?.maxStack ?? (this.environment === "development" ? 2e3 : void 0);
+		if (maxStack) this.syslog?.setMaxStack(maxStack);
+		const queryDriver = resolveQueryDriver(logCfg?.queryDriver, cluster.isWorker, {
+			loki: logCfg?.loki?.url,
+			opensearch: logCfg?.opensearch?.url
+		});
+		registerBuiltinLogDrivers();
+		const driverCtx = {
+			logCfg,
+			environment: this.environment ?? "development",
+			logDir: logDirAbs,
+			pid: process.pid,
+			getRingStack: () => this.syslog?.ringStack ?? []
+		};
+		const toMount = /* @__PURE__ */ new Set(["memory", queryDriver]);
+		if (this.environment === "development") for (const name of listLogDriverFactories()) toMount.add(name);
+		const addedWrites = /* @__PURE__ */ new Set();
+		for (const name of toMount) {
+			const factory = getLogDriverFactory(name);
+			if (factory === void 0) continue;
+			const mount = factory(driverCtx);
+			if (mount === null) continue;
+			registerLogDriver(mount.driver);
+			if (mount.transport !== void 0) {
+				const key = mount.writeKey;
+				if (key === void 0 || !addedWrites.has(key)) {
+					this.syslog?.addTransport(mount.transport);
+					(this._mountedLogTransports ??= []).push(mount.transport);
+					if (key !== void 0) addedWrites.add(key);
+				}
+			}
+		}
+		try {
+			setActiveLogDriver(queryDriver);
+		} catch {
+			this.syslog?.log(`Log query driver "${queryDriver}" introuvable — fallback "memory".`, "WARNING", "SYSLOG");
+			setActiveLogDriver("memory");
+		}
+		if (!this.cli && !this.debug && this.options.log?.debug) this.debug = this.options.log.debug;
+		this.syslog?.setSeverityThreshold(this.environment === "production" && !this.debug ? "INFO" : null);
+		const debugSpec = process.env.NF__DEBUG;
+		if (debugSpec && this.syslog) {
+			const { global, overrides } = Syslog.parseDebugSpec(debugSpec);
+			if (global) this.syslog.setSeverityThreshold(null);
+			for (const ov of overrides) this.syslog.setDebugOverride(ov.module, ov.level);
+		}
+		if (this.cli) return this.cli.initSyslog(this.environment, this.debug);
+		else return this.initSyslog(this.environment, this.debug);
+	}
+	setCli(cli) {
+		if (cli) {
+			this.runProfile = cli.runProfile;
+			this.debug = Boolean(cli?.commander?.opts().debug) || false;
+			if (this.typeCluster === "worker") cli.setPid();
+			this.set("cli", cli);
+			return cli;
+		}
+		return null;
+	}
+	isConsole() {
+		return this.runProfile ? !this.runProfile.servers : false;
+	}
+	setNodeEnv(environment) {
+		if (environment) switch (environment) {
+			case "dev":
+			case "development":
+				process.env.NODE_ENV = "development";
+				process.env.BABEL_ENV = "development";
+				this.isDev = true;
+				this.isProd = false;
+				break;
+			default:
+				process.env.NODE_ENV = "production";
+				process.env.BABEL_ENV = "production";
+				this.isProd = true;
+				this.isDev = false;
+		}
+		process.env.NODE_DEBUG = this.debug ? "true" : "false";
+	}
+	/**
+	* Résout le **mode runtime** (dev/prod) : `NODE_ENV`
+	* (ambient, posé par l'orchestrateur en cloud) PRIME sur l'intention de la
+	* commande locale, qui prime sur la valeur courante. Normalise en
+	* `"development" | "production"`. Pur (lit `process.env`, n'écrit rien) → sûr à
+	* appeler avant que `setNodeEnv` n'ait posé `NODE_ENV` (ex. gating de modules à
+	* `onPreRegister`). Cf project_app_config_refonte_chantier (deux axes d'env).
+	*/
+	resolveRuntimeEnv(fromCommand) {
+		const raw = process.env.NODE_ENV || fromCommand || this.environment || "development";
+		return engineModeOf(raw);
+	}
+	setEnv(environment) {
+		const runtime = this.resolveRuntimeEnv(environment);
+		this.environment = runtime;
+		this.appEnvironment.environment = process.env.APP_ENV || process.env.NF_ENV || runtime;
+	}
+	/**
+	* Header de boot dev consolidé, imprimé juste sous l'ASCII (dev-only) : nom +
+	* version + environnement + meta (`cluster · platform · node · pid`). Remplace la
+	* ligne « Version … » et le banner « SERVER … » bruts. Couleurs gatées TTY (logColor).
+	*/
+	printDevHeader() {
+		let version = "";
+		try {
+			const v = this.cli?.commander?.version();
+			if (typeof v === "string") version = v;
+		} catch {}
+		const meta = [
+			String(this.typeCluster ?? ""),
+			process.platform,
+			`node ${process.version}`,
+			`pid ${process.pid}`,
+			`tty ${this.isTTY ? "yes" : "no"}`
+		].filter(Boolean).join(" · ");
+		const tag = version ? ` ${logColor.blackBright(`v${version}`)}` : "";
+		const env = this.environment ? `   ${logColor.green(String(this.environment))}` : "";
+		const appEnv = process.env.APP_ENV || process.env.NF_ENV;
+		const deploy = appEnv && appEnv !== String(this.environment) ? ` ${logColor.blackBright("·")} ${logColor.magenta(appEnv)}` : "";
+		console.log(`  ${logColor.cyan("⬢")} ${logColor.cyanBold("Nodefony")}${tag}${env}${deploy}`);
+		console.log(`  ${logColor.blackBright(meta)}\n`);
+	}
+	logEnv() {
+		if (this.cli) this.runProfile = this.cli.runProfile;
+		const profileLabel = this.runProfile.servers ? "server" : "console";
+		let txt = `      \x1b ${logColor.blue(profileLabel)} `;
+		txt += ` ${logColor.magenta("Cluster")} : ${this.typeCluster} `;
+		txt += ` ${logColor.magenta("Nodefony Environment")} : ${this.environment}  `;
+		if (this.appEnvironment) txt += ` ${logColor.magenta("App Environment")} : ${this.appEnvironment.environment}  `;
+		txt += ` ${logColor.magenta("Debug")} : ${this.debug}\n`;
+		return txt;
+	}
+	clusterIsMaster() {
+		return cluster.isPrimary;
+	}
+	/**
+	* Vide le buffer des `MODULE ADD` accumulés pendant `loadApp()` et bascule
+	* `addModule()` en mode log immédiat. Appelé par `initCluster()` juste
+	* après l'en-tête SERVER, pour que les modules apparaissent SOUS le banner.
+	*/
+	flushPendingModuleAddLogs() {
+		if (!this.pendingModuleAddLogs) return;
+		const pending = this.pendingModuleAddLogs;
+		this.pendingModuleAddLogs = null;
+		for (const name of pending) this.log(`MODULE ADD : ${name}`, "INFO");
+	}
+	initCluster() {
+		this.pid = process.pid;
+		if (this.console && this.cli && this.cli.commander && this.cli.commander.opts().json) return;
+		if (cluster.isPrimary) {
+			if (!this.reporterOwnsHeader && !this.cli?.quietBoot) console.log(this.logEnv());
+			this.flushPendingModuleAddLogs();
+			this.fire("onCluster", "MASTER", this, process);
+		} else if (cluster.isWorker) {
+			if (!this.reporterOwnsHeader && !this.cli?.quietBoot) console.log(this.logEnv());
+			this.flushPendingModuleAddLogs();
+			this.workerId = cluster.worker?.id;
+			this.worker = cluster.worker;
+			this.fire("onCluster", "WORKER", this, process);
+			process.on("message", (msg) => {
+				if (isClusterMessage(msg) && (msg.kind === "nf:rt" || msg.kind === "nf:probe:snap")) return;
+				this.log(msg, "INFO", "IPC MESSAGE");
+				this.fire("onMessage", msg);
+			});
+		}
+	}
+	fire(event, ...args) {
+		this.log(`${colorLogEvent()} ${event}`, "DEBUG");
+		return super.fire(event, ...args);
+	}
+	emit(event, ...args) {
+		this.log(`${colorLogEvent()} ${event}`, "DEBUG");
+		return super.emit(event, ...args);
+	}
+	emitAsync(event, ...args) {
+		this.log(`${colorLogEvent()} ${event}`, "DEBUG");
+		return super.emitAsync(event, ...args);
+	}
+	fireAsync(event, ...args) {
+		this.log(`${colorLogEvent()} ${event}`, "DEBUG");
+		return super.emitAsync(event, ...args);
+	}
+	/**
+	* Timeout par listener appliqué au boot (résilience Phase 3). Précédence :
+	* `NF_BOOT_TIMEOUT_MS` (env, orchestrateur) > défaut par env (dev 20 s,
+	* prod 60 s). Large à dessein : il borne la PENDAISON infinie (ex. file Redis
+	* offline qui ne rejette jamais), pas la lenteur normale d'un hook.
+	*/
+	bootTimeoutMs() {
+		const env = Number(process.env.NF_BOOT_TIMEOUT_MS);
+		if (Number.isFinite(env) && env > 0) return env;
+		return this.environment === "production" ? 6e4 : 2e4;
+	}
+	/**
+	* Seuil d'alerte de lenteur d'un hook de boot (NOTICE, sans le tuer). Précédence :
+	* `NF_BOOT_WARN_MS` (env) > défaut 5 s. `0` désactive la mesure.
+	*/
+	bootWarnMs() {
+		const env = Number(process.env.NF_BOOT_WARN_MS);
+		if (Number.isFinite(env) && env >= 0) return env;
+		return 5e3;
+	}
+	/**
+	* Politique d'échec de boot commune (lifecycle + `initialize`). Log + verdict
+	* de propagation. **Fatal** = module critique (tag `critical !== false`) ET
+	* (`production` OU erreur de **configuration** {@link BootConfigurationError})
+	* → on interrompt le boot (le pod crashe, l'orchestrateur le redémarre —
+	* cloud-native). Sinon **fail-soft** : WARNING, le boot continue.
+	*
+	* **Pourquoi la config est fatale même en dev** : le fail-soft protège la DX
+	* d'un module optionnel cassé — mais une configuration EXPLICITE non
+	* honorable (infra déclarée injoignable, entité non portée sur le dialecte
+	* demandé) ne se répare pas en continuant : le serveur « vivant » qui en
+	* résulte est un piège (briques durables mortes, login impossible, cause
+	* noyée dans un WARNING — vécu). Cf {@link BootConfigurationError}.
+	*
+	* @param error - erreur/timeout capturé.
+	* @param owner - module propriétaire (tag), ou `undefined` (listener interne).
+	* @param critical - criticité (tag) ; `undefined` → traité comme critique.
+	* @param timedOut - `true` si l'échec est un dépassement de timeout.
+	* @returns `true` si l'échec doit interrompre le boot.
+	*/
+	isBootErrorFatal(error, owner, critical, timedOut, phase) {
+		const who = owner ?? "(anonyme)";
+		const configError = BootConfigurationError.is(error);
+		const heldBy = this.#readinessHold();
+		const fatal = configError || critical !== false && this.environment === "production" && heldBy === null;
+		const msg = error instanceof Error ? error.message : String(error);
+		const tag = timedOut ? " [timeout]" : "";
+		this.log(`boot lifecycle: ${fatal ? configError ? "erreur de CONFIGURATION (boot interrompu)" : "échec critique" : "échec non bloquant (fail-soft)"} de "${who}"${tag} — ${msg}`, fatal ? "ERROR" : "WARNING");
+		if (this.debug && error instanceof Error && error.stack) this.log(error.stack, "DEBUG");
+		if (!fatal && critical !== false) this.log(`boot lifecycle: en production, cet échec de "${who}" INTERROMPRAIT le boot` + (critical === void 0 ? " — ce hook ne porte aucun tag de criticité, et un hook non tagué est traité comme CRITIQUE. S'il vient d'un module (ou d'un de ses services), le poser avec `module.hookKernel(\"<event>\", …)` plutôt que `kernel.once(…)` : il héritera du nom et de la criticité du module. `static critical = false` ne couvre QUE les hooks de classe — un hook posé à la main y échappe." : `.`), "WARNING");
+		if (!fatal && heldBy !== null) this.log(`boot lifecycle: l'échec de "${who}" n'interrompt PAS le boot — la mise en service est retenue par ${heldBy}. Cet exemplaire reste vivant et ne reçoit aucun trafic (/readyz rend 503) ; il attend le geste qui lèvera la rétention.`, "WARNING");
+		if (!fatal) this.recordBootFailure({
+			module: who,
+			reason: msg,
+			phase,
+			timedOut
+		});
+		return fatal;
+	}
+	/**
+	* Qui retient la mise en service, en clair — ou `null` si rien ne la retient.
+	*
+	* Lu au moment d'un échec de boot pour décider si l'exemplaire doit mourir.
+	* Ne consulte que l'état DÉJÀ calculé par le registre : aucun appel réseau,
+	* aucune sonde déclenchée ici.
+	*
+	* @returns les contributeurs qui retiennent, séparés par « ; », ou `null`.
+	*/
+	#readinessHold() {
+		const bloquants = this.readinessReport().filter((c) => !c.ready);
+		if (bloquants.length === 0) return null;
+		return bloquants.map((c) => c.reason ? `${c.name} (${c.reason})` : c.name).join(" ; ");
+	}
+	/**
+	* Enregistre un échec de boot **non fatal** (fail-soft) dans le buffer agrégé,
+	* alloué paresseusement au premier échec (0 allocation si le boot est nominal).
+	*
+	* @param failure - module en échec + raison + étape.
+	*/
+	recordBootFailure(failure) {
+		(this.bootFailures ??= []).push(failure);
+	}
+	/**
+	* Fige la liste des serveurs **réellement en écoute** à `onPostReady`
+	* (`initServers()` ne retourne un serveur qu'une fois son `listen()` résolu).
+	* Source de vérité de {@link getBootReport}.
+	*
+	* @param servers - instances de serveurs retournées par `initServers()`.
+	*/
+	captureBootServers(servers) {
+		if (!servers.length) {
+			this.bootServers = [];
+			return;
+		}
+		this.bootServers = servers.map((s) => {
+			const type = typeof s?.type === "string" ? s.type : "server";
+			const port = Number(s?.port ?? 0);
+			const address = typeof s?.address === "string" ? s.address : void 0;
+			const scheme = SERVER_SCHEME[type] ?? type;
+			return {
+				type,
+				scheme,
+				port,
+				address,
+				url: `${scheme}://${address ? address.includes(":") ? `[${address}]` : address : "127.0.0.1"}:${port}`
+			};
+		});
+	}
+	/**
+	* Verdict agrégé du dernier boot (vérité unique, recalculable à la demande pour
+	* l'introspection Studio/IA). `healthy=false` ⇒ un profil serveur a fini sans
+	* aucun serveur en écoute (garde-fou 0-serveur). Les modules ignorés seuls
+	* laissent le boot `healthy` (dégradé mais vivant).
+	*
+	* @returns le {@link IBootReport}.
+	*/
+	getBootReport() {
+		const measured = this.bootServers !== null;
+		const serversListening = this.bootServers ?? [];
+		const serversExpected = Boolean(this.runProfile?.servers);
+		const modulesSkipped = this.bootFailures ?? [];
+		const { warnings, errors, criticals } = this.bootLogCounts ?? this.countBootLogIssues();
+		const manifestEntries = Array.isArray(this.options.modules) ? this.options.modules.length : 0;
+		return {
+			durationMs: this.bootStartedAt > 0 ? Date.now() - this.bootStartedAt : 0,
+			modulesLoaded: Object.keys(this.modules),
+			manifestEntries,
+			modulesSkipped,
+			modulesGated: this.modulesGated ?? [],
+			warnings,
+			errors,
+			criticals,
+			serversExpected,
+			serversListening,
+			healthy: !(serversExpected && measured && serversListening.length === 0),
+			remediation: this.bootRemediationHint(modulesSkipped, manifestEntries, serversExpected) ?? void 0
+		};
+	}
+	/**
+	* Nombre de composants qui retiennent la mise en service — `0` = disponible.
+	*
+	* C'est ce que lit la sonde `/readyz`, et c'est pour elle que ce membre est un
+	* ENTIER déjà calculé : une comparaison, aucune allocation, aucun `await`,
+	* aucune vérification déclenchée. Une sonde qui interrogerait la base tomberait
+	* avec elle ; celle-ci lit un verdict que le contributeur a posé lui-même.
+	*
+	* @returns le nombre de contributeurs non prêts (`0` quand personne n'est inscrit)
+	*/
+	/**
+	* Signature du dernier état publié sur le disque — `null` tant que rien ne
+	* l'a été. Sert UNIQUEMENT à ne pas réécrire un fichier identique.
+	*/
+	#readinessPublished = null;
+	get readinessBlocked() {
+		return this.readiness === null ? 0 : this.readiness.blocked;
+	}
+	/**
+	* Ce processus a-t-il le droit de recevoir du trafic ?
+	*
+	* **La règle de mise en service, en UN seul endroit.** Elle est lue par la
+	* sonde `/readyz` (que le kubelet interroge) ET par le champ `ready` du plan
+	* d'administration (que lit un exploitant) : deux vérités sur la
+	* disponibilité, c'en est une de trop — quelqu'un qui voit `ready: true` d'un
+	* côté pendant que l'orchestrateur reçoit 503 de l'autre cherche au mauvais
+	* endroit. Les deux ont divergé (`booted` contre `postReady`), et l'écart ne
+	* s'est vu qu'en production, où la fin du cycle de démarrage arrive assez tard
+	* pour ouvrir une fenêtre de plusieurs secondes.
+	*
+	* Deux conditions, et rien d'autre :
+	*
+	* - **le cycle de démarrage est TERMINÉ** (`postReady`) — `booted` ne suffit
+	*   pas : les écouteurs de `onPostReady` montent encore des choses dont une
+	*   requête a besoin ;
+	* - **aucun composant ne retient la mise en service** — un entier déjà
+	*   calculé par eux ({@link Kernel.setReadiness}), jamais une vérification
+	*   déclenchée ici : une sonde ne doit tomber avec RIEN.
+	*
+	* Ce que ce getter ne connaît pas, volontairement : l'ARRÊT. Le drain
+	* appartient au transport, qui bascule sa propre sonde à 503 avant même de
+	* commencer à drainer — et `/livez`, lui, doit rester vert pendant ce
+	* temps, sans quoi un redémarrage casserait l'arrêt gracieux en cours.
+	*
+	* @returns `true` si le processus peut servir du trafic.
+	*/
+	get servable() {
+		return this.postReady === true && this.readinessBlocked === 0;
+	}
+	/**
+	* Pose le verdict de disponibilité d'un composant nommé — un schéma de base en
+	* retard, un cache froid, un service tiers muet. Tant qu'un seul contributeur
+	* répond `false`, `/readyz` rend **503** et l'orchestrateur n'envoie pas de
+	* trafic ; le processus reste VIVANT (`/livez` inchangé), car un état externe
+	* ne se répare pas en redémarrant le processus.
+	*
+	* Le verdict doit être DÉJÀ CALCULÉ : ce n'est pas une vérification que la
+	* sonde déclenchera, c'est un booléen que le composant met à jour à son propre
+	* rythme. Dès qu'il repose `true`, le processus redevient disponible tout seul
+	* — sans redéploiement, ce qui est toute la raison d'être du mécanisme.
+	*
+	* **`blocking: false` publie l'état SANS retenir le trafic.** Un composant
+	* réglé pour tolérer sa propre panne (« journalise et sers quand même ») doit
+	* pouvoir le dire sans disparaître du registre : c'est sa présence, et non la
+	* rétention, qui apprend au noyau qu'un état EXTERNE est en cours et qu'un
+	* échec de démarrage ne doit donc pas être fatal
+	* ({@link Kernel.isBootErrorFatal}). Sans cette distinction, affaiblir la
+	* sonde faisait perdre la tolérance du démarrage — au moment précis où l'on
+	* cherchait de l'air.
+	*
+	* Idempotent par nom : réenregistrer le même nom remplace son verdict.
+	*
+	* @param name - nom du contributeur, qui apparaîtra au journal (`"drizzle:schema"`)
+	* @param ready - `false` retient la mise en service, `true` la libère
+	* @param reason - ce qui retient, en clair (journalisé ; ignoré si `ready`)
+	*/
+	setReadiness(name, ready, reason, blocking = true) {
+		if (this.readiness === null) this.readiness = new ReadinessRegistry();
+		if (this.readiness.set(name, ready, reason, blocking)) this.logReadinessFlip();
+		this.publishReadinessState();
+	}
+	/**
+	* Retire un contributeur du registre — sa voix ne compte plus. Geste d'un
+	* module qui s'arrête ; le registre est LIBÉRÉ quand le dernier part, pour que
+	* la sonde retrouve exactement le coût qu'elle avait avant toute inscription.
+	*
+	* @param name - nom du contributeur, tel que passé à {@link Kernel.setReadiness}
+	*/
+	clearReadiness(name) {
+		if (this.readiness === null) return;
+		const flipped = this.readiness.clear(name);
+		if (this.readiness.size === 0) this.readiness = null;
+		if (flipped) this.logReadinessFlip();
+		this.publishReadinessState();
+	}
+	/**
+	* Restitue l'état de chaque contributeur — pour un diagnostic (journal,
+	* `status`, console d'administration), jamais pour la sonde.
+	*
+	* @returns un contributeur par inscription, triés par nom ; vide si aucun
+	*/
+	readinessReport() {
+		return this.readiness === null ? [] : this.readiness.report();
+	}
+	/**
+	* Publie sur le disque QUI retient la mise en service — le canal que lit
+	* `nodefony status`.
+	*
+	* **Pourquoi un fichier plutôt que la sonde** : le détail existe déjà sur
+	* `livez`, mais réservé à un appelant authentifié, et cette route est publique
+	* en production. Le système de fichiers est la vraie frontière « local », il
+	* répond même quand la boucle d'événements ne répond plus, et il n'ouvre
+	* aucune surface publique. Détail : {@link readinessStateFile}.
+	*
+	* **N'écrit que si l'état a CHANGÉ.** En régime établi — un contributeur qui
+	* repose le même verdict toutes les quinze secondes — ce mécanisme ne touche
+	* pas le disque. La signature est une chaîne courte, composée hors du chemin
+	* d'une requête : `setReadiness` n'est appelé qu'au démarrage et au rythme
+	* propre de chaque contributeur.
+	*/
+	publishReadinessState() {
+		const contributors = this.readinessReport();
+		const signature = contributors.map((c) => `${c.name}\u0000${c.ready ? 1 : 0}\u0000${c.reason ?? ""}`).join("
");
+		if (signature === this.#readinessPublished) return;
+		this.#readinessPublished = signature;
+		if (contributors.length === 0) {
+			clearReadinessState(this.path);
+			return;
+		}
+		writeReadinessState(this.path, contributors);
+	}
+	/**
+	* Dit au journal ce qui vient de basculer. Appelé UNIQUEMENT quand le verdict
+	* agrégé change (jamais à chaque pose de verdict identique) : un pod retenu
+	* plusieurs heures ne doit pas noyer son propre journal, et un exploitant qui
+	* voit un pod jamais disponible doit trouver ici le NOM de ce qui le retient —
+	* le corps de la sonde, lui, reste une constante pré-allouée.
+	*/
+	logReadinessFlip() {
+		const retenant = this.readiness === null ? [] : this.readiness.report().filter((c) => !c.ready);
+		if (retenant.length === 0) {
+			this.log("Mise en service libérée — /readyz rend de nouveau 200", "INFO");
+			return;
+		}
+		const details = retenant.map((c) => c.reason ? `${c.name} (${c.reason})` : c.name).join(", ");
+		this.log(`Mise en service RETENUE — /readyz rend 503 : ${details}`, "CRITIC");
+	}
+	/**
+	* Compte les WARNING (severity 4) et les ERROR-et-pire (severity 0-3 :
+	* EMERGENCY/ALERT/CRITIC/ERROR) présents dans le ring buffer syslog. Pendant le
+	* boot, le ring ne contient QUE des logs de boot → le compte est le « journal
+	* du boot ». Borné par la capacité du ring (compte plancher, jamais gonflé).
+	*
+	* @returns compteurs `{ warnings, errors }`.
+	*/
+	countBootLogIssues() {
+		let warnings = 0;
+		let errors = 0;
+		let criticals = null;
+		const ring = this.syslog?.ringStack;
+		if (ring) {
+			for (const pdu of ring) if (pdu.severity === 4) warnings++;
+			else if (pdu.severity >= 0 && pdu.severity <= 3) {
+				errors++;
+				if (criticals === null) criticals = [];
+				if (criticals.length < MAX_BOOT_CRITICALS) criticals.push(this.condenseBootMessage(pdu));
+			}
+		}
+		return {
+			warnings,
+			errors,
+			criticals
+		};
+	}
+	/**
+	* Une entrée de journal ramenée à ce qui tient dans un bilan.
+	*
+	* Le message brut porte parfois une pile entière : la première ligne dit ce
+	* qui s'est passé, le reste appartient au journal. Le module émetteur est
+	* conservé — c'est lui qui répond à « QUI a crié ? », la question qu'un
+	* compte seul laissait entière.
+	*
+	* @param pdu - l'entrée du journal.
+	* @returns une ligne, bornée.
+	*/
+	condenseBootMessage(pdu) {
+		const premiere = (String(pdu.payload ?? "").split("\n")[0] ?? "").trim();
+		const message = premiere.length > MAX_BOOT_CRITICAL_LENGTH ? `${premiere.slice(0, 199)}…` : premiere;
+		return `${pdu.moduleName ? `${String(pdu.moduleName)} : ` : ""}${message}`;
+	}
+	/**
+	* Déclare une ligne de détail à afficher SOUS une phase de boot (canal NEUTRE
+	* dev-only : le `BootReporter` la rend ; le core ne connaît pas son contenu).
+	* Un adapter ORM/frontend/… l'appelle à son hook de phase pour que le boot
+	* RACONTE ce qu'il met en place — sans coupler le core au domaine du module.
+	*
+	* @param phase - libellé de la phase (cf `BootReporter` PHASES, ex. « Services & ORM »).
+	* @param line - ligne lisible (ex. « drizzle → sqlite (./var/app.db) »).
+	*/
+	reportBootLine(phase, line) {
+		const map = this.bootLines ??= /* @__PURE__ */ new Map();
+		const lines = map.get(phase);
+		if (lines) lines.push(line);
+		else map.set(phase, [line]);
+	}
+	/**
+	* REMPLACE les lignes de détail d'une phase (vs {@link reportBootLine} qui
+	* AJOUTE). Pour un producteur idempotent invoqué plusieurs fois qui reconstruit
+	* la liste complète à chaque appel (ex. le wiring ORM, déclenché par N drivers,
+	* itère tout le registre → « dernier gagne »).
+	*
+	* @param phase - libellé de la phase.
+	* @param lines - liste complète des lignes (remplace l'existant ; vide = efface).
+	*/
+	setBootLines(phase, lines) {
+		if (!lines.length) {
+			this.bootLines?.delete(phase);
+			return;
+		}
+		(this.bootLines ??= /* @__PURE__ */ new Map()).set(phase, [...lines]);
+	}
+	/**
+	* Lignes de détail déclarées pour une phase de boot (vide si aucune).
+	*
+	* @param phase - libellé de la phase.
+	* @returns lignes dans l'ordre de déclaration.
+	*/
+	getBootLines(phase) {
+		return this.bootLines?.get(phase) ?? [];
+	}
+	/**
+	* Action corrective suggérée d'après les raisons d'échec — surfacée dans le
+	* verdict (écran + log). Heuristique : un `import()` qui échoue (« Cannot find
+	* package/module ») pointe presque toujours un `dist/` périmé après pull/merge.
+	*
+	* Le manifeste VIDE est traité en premier parce qu'il ne produit aucune raison
+	* d'échec : rien n'ayant été tenté, `skipped` est vide et l'heuristique
+	* suivante n'a rien à lire. C'est précisément l'état qui laissait le diagnostic
+	* muet — il faut donc le nommer ici, à défaut de pouvoir le déduire.
+	*
+	* Le manifeste vide n'est signalé que sous un profil SERVEUR : une commande
+	* batch ou un test qui boote sans manifeste est un cas nominal, et une
+	* remédiation posée là serait un faux diagnostic recopié partout où le rapport
+	* est lu.
+	*
+	* @param skipped - modules ignorés.
+	* @param manifestEntries - entrées déclarées au manifeste `config.modules`.
+	* @param serversExpected - le profil d'exécution attendait-il des serveurs.
+	* @returns une phrase d'action, ou `null`.
+	*/
+	bootRemediationHint(skipped, manifestEntries, serversExpected) {
+		if (serversExpected && manifestEntries === 0) return "la configuration LUE ne déclare aucun module (`modules: []`) ⇒ vérifier `nodefony.config` et l'exécutable employé (`nodefony inspect config` dit la config effective et sa provenance)";
+		if (skipped.some((f) => /Cannot find package|Cannot find module|ERR_MODULE_NOT_FOUND/i.test(f.reason))) return "dist périmé probable ⇒ npm run clean && npm run build";
+		return null;
+	}
+	/**
+	* Log structuré du verdict de boot — émis **toujours** (prod incluse), donc
+	* indépendant du `BootReporter` (qui n'existe qu'en dev). En non-TTY/prod c'est
+	* la seule trace écran ; en dev TTY animé le sink est muté → va au backplane,
+	* et le `BootReporter` rend le verdict joli (✓/⚠/⛔).
+	*
+	* @param report - verdict à logger.
+	*/
+	logBootVerdict(report) {
+		const skipped = report.modulesSkipped;
+		if (!report.healthy) {
+			const reasons = skipped.map((f) => `${f.module}: ${f.reason}`).join(" · ");
+			this.log(`BOOT ÉCHEC — profil serveur mais aucun serveur en écoute · manifeste : ${report.manifestEntries} module(s) déclaré(s), ${report.modulesLoaded.length} chargé(s)` + (skipped.length ? ` · ${skipped.length} module(s) en échec : ${reasons}` : "") + (report.remediation ? ` — ${report.remediation}` : ""), "CRITIC");
+			return;
+		}
+		if (skipped.length) {
+			this.log(`BOOT dégradé — ${report.modulesLoaded.length} module(s) chargé(s), ${skipped.length} en échec (fail-soft) : ` + skipped.map((f) => `${f.module} (${f.reason})`).join(" · "), "WARNING");
+			return;
+		}
+		const urls = report.serversListening.map((s) => s.url).join(", ");
+		const gated = report.modulesGated.length ? `, ${report.modulesGated.length} ignoré(s) (policy/when)` : "";
+		const journal = report.warnings || report.errors ? ` · journal : ${report.errors} ERROR, ${report.warnings} WARNING` : "";
+		this.log(`BOOT ok — ${report.modulesLoaded.length} module(s)${gated}, ${report.serversListening.length} serveur(s) en écoute` + (urls ? ` (${urls})` : "") + journal, "NOTICE");
+		const logCfg = this.options.log;
+		if (shouldWarnPerPodView(isInKubernetes(), getActiveLogDriver()?.name, Boolean(logCfg?.loki?.url || logCfg?.opensearch?.url))) this.log(`Kubernetes détecté + log.queryDriver="${getActiveLogDriver()?.name}" (vue PAR POD) : la relecture des logs ne couvre que CE pod. En multi-pod (replicas > 1), configure log.queryDriver="loki"|"opensearch" (+ URL) pour une vue globale.`, "NOTICE", "SYSLOG");
+	}
+	/**
+	* Émet une phase de **lifecycle de boot** de façon GARDÉE (cf
+	* `Event.emitAsyncGuarded`) : chaque hook de module est isolé par try/catch +
+	* timeout ; un module qui throw ou se fige ne gèle/ne tue plus tout le boot. La
+	* politique (propager vs fail-soft) est tranchée par {@link isBootErrorFatal}
+	* d'après les tags `owner`/`critical` posés par `Module.setEvents()`.
+	*
+	* Remplace `fireAsync` **uniquement** dans la chaîne boot (`onPreRegister` →
+	* `onPostReady`). Le hot path HTTP/WS garde `emitAsync` nu (aucun timer/alloc).
+	*
+	* @param event - phase lifecycle à émettre.
+	* @param args - arguments passés aux hooks (typiquement `this`).
+	* @returns le {@link IGuardedEmitResult} (results / errors / stopped).
+	* @throws l'erreur d'un module critique en production (interrompt le boot).
+	*/
+	async fireLifecycle(event, ...args) {
+		this.log(`${colorLogEvent()} ${event} [guarded]`, "DEBUG");
+		const warnMs = this.bootWarnMs();
+		let fatalError = null;
+		let hasFatal = false;
+		const bootTimeout = this.bootTimeoutMs();
+		const result = await super.emitAsyncGuarded(event, {
+			timeoutMs: (listener) => isUnboundedListener(listener) ? 0 : bootTimeout,
+			warnMs,
+			onListenerError: (error, info) => {
+				const { owner, critical, name } = readListenerTags(info.listener);
+				if (this.isBootErrorFatal(error, owner ?? name, critical, info.timedOut, "lifecycle")) {
+					fatalError = error;
+					hasFatal = true;
+					return true;
+				}
+			},
+			onListenerSlow: (info) => {
+				const { owner, name } = readListenerTags(info.listener);
+				this.log(`boot lifecycle: hook "${owner ?? name ?? "(anonyme)"}" lent (${Math.round(info.durationMs)}ms ≥ ${warnMs}ms) sur ${event}`, "NOTICE");
+			}
+		}, ...args);
+		if (hasFatal) throw fatalError instanceof Error ? fatalError : new Error(String(fatalError));
+		return result;
+	}
+	/**
+	* Initialise un service **sous garde de boot** (timeout + politique de criticité
+	* via {@link guardInitialize}) si le service expose le hook `init`. Point
+	* d'entrée commun à {@link addKernelService} (service kernel, `critical=true`) et
+	* à {@link Module.addService} (service de module, criticité = celle du module
+	* porteur), pour que les deux chemins d'init partagent la même résilience.
+	*
+	* @remarks Avant 2026-05-29 les services de module passaient par un `await` NU
+	*   (aucun timeout) : un `init` qui pend (ex. `redis` = connexion réseau)
+	*   gelait le boot indéfiniment. Désormais borné comme les services kernel.
+	*
+	* @param serviceInit - instance du service ; ne fait rien si `init` absent.
+	* @param owner - propriétaire passé au hook : le {@link Module} ou ce {@link Kernel}.
+	* @param critical - criticité transmise à {@link isBootErrorFatal}.
+	*/
+	async guardServiceInitialize(serviceInit, owner, critical) {
+		if (!serviceInit.init) return;
+		this.log(`SERVICE INITIALIZE : ${serviceInit.name}`, "DEBUG");
+		const init = serviceInit.init.bind(serviceInit);
+		await this.guardInitialize(() => init(owner), serviceInit.name, critical);
+	}
+	/**
+	* Applique la politique de criticité du boot à l'échec d'un service déclaré via
+	* `@services([...])` — **construction (`new`) comprise**, pas seulement `init`.
+	* Pendant symétrique de {@link guardServiceInitialize} pour le chemin décorateur.
+	*
+	* @remarks Le `catch` du décorateur `@services` avalait auparavant TOUT échec
+	*   (`log(e, "ERROR")` et rien d'autre) : il n'atteignait ni cette politique —
+	*   donc jamais fatal, **même en production** — ni le {@link getBootReport}, si
+	*   bien qu'un boot amputé d'un service critique se déclarait « UP ». Un service
+	*   qu'on ne peut pas CONSTRUIRE doit suivre exactement la règle de celui qu'on
+	*   ne peut pas INITIALISER.
+	*
+	* @param error - l'échec remonté par `addService`/`loadService`.
+	* @param serviceName - nom lisible (pour le log + le BootReport).
+	* @param critical - criticité du module porteur ({@link Module.critical}).
+	* @returns `true` si l'échec est fatal → l'appelant **doit** propager.
+	*/
+	serviceBootErrorFatal(error, serviceName, critical) {
+		return this.isBootErrorFatal(error, serviceName, critical, false, "init");
+	}
+	/**
+	* Exécute un `initialize()` (module ou service kernel) sous garde de boot :
+	* borné par {@link bootTimeoutMs} et soumis à {@link isBootErrorFatal}. Un
+	* `initialize` qui se fige (connexion réseau qui pend) ne gèle plus le boot.
+	*
+	* @param run - thunk qui lance l'`initialize` (déjà lié à son instance).
+	* @param owner - nom du module/service (pour le log).
+	* @param critical - criticité (module → `Module.critical` ; service kernel → `true`).
+	*/
+	async guardInitialize(run, owner, critical) {
+		try {
+			await withTimeout(Promise.resolve(run()), this.bootTimeoutMs(), `initialize ${owner}`);
+		} catch (error) {
+			const timedOut = error instanceof TimeoutError;
+			if (this.isBootErrorFatal(error, owner, critical, timedOut, "init")) throw error;
+		}
+	}
+	checkPath(myPath) {
+		if (!myPath) return null;
+		if (path.isAbsolute(myPath)) return myPath;
+		return path.resolve(this.path, myPath);
+	}
+	sendMessage(message, handle, options, callback) {
+		if (process.send) return process.send({
+			type: "process:msg",
+			data: message
+		}, handle, options, callback);
+		throw new Error(`process.send not found `);
+	}
+	memoryUsage(message, severity = "DEBUG") {
+		const { memory } = this.stats();
+		for (const ele in memory) switch (ele) {
+			case "rss":
+				this.log(`${message || ele} ( Resident Set Size ) PID ( ${this.pid} ) : ${CliKernel.niceBytes(memory[ele])}`, severity, `MEMORY ${ele}`);
+				break;
+			case "heapTotal":
+				this.log(`${message || ele} ( Total Size of the Heap ) PID ( ${this.pid} ) : ${CliKernel.niceBytes(memory[ele])}`, severity, `MEMORY ${ele}`);
+				break;
+			case "heapUsed":
+				this.log(`${message || ele} ( Heap actually Used ) PID ( ${this.pid} ) : ${CliKernel.niceBytes(memory[ele])}`, severity, `MEMORY ${ele}`);
+				break;
+			case "external": this.log(`${message || ele} PID ( ${this.pid} ) : ${CliKernel.niceBytes(memory[ele])}`, severity, `MEMORY ${ele}`);
+		}
+	}
+	stats() {
+		return { memory: process.memoryUsage() };
+	}
+	interfacesFilter(filters) {
+		if (filters) {
+			let condition = (ele, ele2) => {
+				return ele && ele2;
+			};
+			if (filters.condition && filters.condition === "||") condition = (ele, ele2) => {
+				return ele || ele2;
+			};
+			const interfaces = {};
+			for (const myinterface in this.interfaces) {
+				interfaces[myinterface] = [];
+				for (const infos of this.interfaces[myinterface]) {
+					let matchType = false;
+					let matchFamily = false;
+					for (const filter in filters) switch (filter) {
+						case "type":
+							if (filters["type"] === "external") {
+								if (!infos.internal) matchType = true;
+							}
+							if (filters["type"] === "local") {
+								if (infos.internal) matchType = true;
+							}
+							break;
+						case "family": if (filters["family"] === infos.family) matchFamily = true;
+					}
+					if (condition(matchType, matchFamily)) interfaces[myinterface].push(infos);
+				}
+			}
+			return interfaces;
+		}
+		return this.interfaces;
+	}
+	getNetworkInterfaces() {
+		const nets = os.networkInterfaces();
+		const devices = {};
+		Object.entries(nets).forEach(([name, ni]) => {
+			if (!ni) return;
+			devices[name] = ni;
+		});
+		return devices;
+	}
+	getNetwork() {
+		return {
+			external: this.interfacesFilter({ type: "external" }),
+			local: this.interfacesFilter({
+				type: "local",
+				condition: "=="
+			}),
+			ipv4: this.interfacesFilter({ family: "IPv4" }),
+			ipv6: this.interfacesFilter({ family: "IPv6" }),
+			interfaces: this.interfaces
+		};
+	}
+	getFirstExternalInterface(family) {
+		const filter = {
+			type: "external",
+			family: family || "IPv4",
+			condition: "&&"
+		};
+		const res = this.interfacesFilter(filter);
+		const ele = [];
+		for (const myinterface in res) for (const info of res[myinterface]) ele.push(info);
+		return ele[0] || void 0;
+	}
+	/**
+	* Shutdown propre du kernel — fire `"onTerminate"` puis `CliKernel.quit(code)` sur next tick.
+	*
+	* Le drain complet (`fireAsync("onTerminate")` : bascule readiness → close WS
+	* 1001 → drain HTTP → cleanup services) est borné par la deadline GLOBALE
+	* `shutdownDeadline` (défaut 15 s, < grace period orchestrateur) : un listener
+	* qui pend (SSE ouvert, store bloqué, module tiers) force la sortie code 1 —
+	* jamais un process zombie qui attend le SIGKILL externe. `0` = filet désactivé.
+	*
+	* @param code - exit code Unix (0 = succès, 1+ = erreur).
+	* @param quiet - muselle l'AFFICHAGE (le log « terminate : N ») — jamais le
+	*   drain : une sortie voulue par l'utilisateur (Ctrl+C d'un menu) n'a pas à
+	*   ressembler à un événement système.
+	* @returns Promise résolue avec `this` (ou rejected si `quit()` throw).
+	*/
+	async terminate(code, quiet) {
+		if (code === void 0) code = typeof process.exitCode === "number" ? process.exitCode : 0;
+		if (this.terminating) return this.terminating;
+		this.terminating = this.doTerminate(code, quiet);
+		return this.terminating;
+	}
+	/** Le shutdown lui-même — protégé de la ré-entrance par {@link terminate}. */
+	async doTerminate(code, quiet) {
+		if (this.parkTimer) {
+			clearInterval(this.parkTimer);
+			this.parkTimer = null;
+		}
+		if (!quiet) this.log(`terminate : ${code}`);
+		const drain = this.fireAsync("onTerminate", this, code).catch((e) => {
+			this.log(e, "ERROR");
+			return SHUTDOWN_DRAIN_ERROR;
+		});
+		const deadlineMs = this.options.shutdownDeadline ?? DEFAULT_SHUTDOWN_DEADLINE;
+		let raced;
+		if (deadlineMs > 0) {
+			let deadlineTimer = null;
+			raced = await Promise.race([drain, new Promise((resolve) => {
+				deadlineTimer = setTimeout(() => resolve(SHUTDOWN_DEADLINE), deadlineMs);
+				deadlineTimer.unref();
+			})]);
+			if (deadlineTimer !== null) clearTimeout(deadlineTimer);
+		} else raced = await drain;
+		if (raced === SHUTDOWN_DEADLINE) {
+			this.log(`shutdown deadline exceeded (${deadlineMs} ms) — forcing exit, onTerminate listeners still pending`, "CRITIC");
+			code = 1;
+		} else if (raced === SHUTDOWN_DRAIN_ERROR) code = 1;
+		return new Promise((resolve, reject) => {
+			process.nextTick(() => {
+				this.log(`NODEFONY Kernel Life Cycle Terminate CODE : ${code}`, "DEBUG");
+				try {
+					CliKernel.quit(code);
+					return resolve(this);
+				} catch (e) {
+					this.log(e, "ERROR");
+					return reject(e);
+				}
+			});
+		});
+	}
+};
+//#endregion
+export { CONSOLE_RUN_PROFILE, Events, FORCE_DEV_MODULES_ENV, FORCE_DEV_MODULES_TTL_ENV, FORCE_DEV_MODULES_TTL_MAX_MS, FORCE_DEV_MODULES_TTL_MS, Kernel as default, resolveDevModulesTtlMs };