nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/kernel/commands/ClusterCommand.js

@@ -0,0 +1,58 @@
+import Command from "../../command/Command.js";
+import { loadClusterConfig, resolveTopology } from "../../service/cluster/topology.js";
+import { launchTopology } from "./runtimeLauncher.js";
+import cluster from "node:cluster";
+//#region src/kernel/commands/ClusterCommand.ts
+const options = {
+	helpGroup: "LANCER",
+	showBanner: false,
+	kernelEvent: "onPostReady"
+};
+/**
+* Commande `nodefony cluster` — démarre le serveur en mode cluster sans PM2.
+*
+* Remplace l'ancien `nodefony staging`/`preprod` (retiré 2026-05-25 — fusionné dans
+* le runtime prod « 2 molettes » : topologie = `cluster.workers`, env = `NODE_ENV`) :
+* - **cgroup-aware** — `--workers N` explicite, sinon quota CPU cgroup (conteneur),
+*   sinon `os.availableParallelism()`. Plus jamais `os.cpus().length` (bug conteneur).
+* - **respawn backoff** — un worker mort est re-forké avec backoff exponentiel (anti crash-loop).
+* - **graceful shutdown** — SIGTERM/SIGINT draine les workers (SIGKILL après timeout).
+*
+* Topologie = source unique {@link resolveTopology} : `--workers` > `NF_WORKERS`
+* > config app `cluster.workers` > défaut 1. **`workers:1` = VRAI mono-process** (zéro
+* machinerie cluster, un seul Kernel) ; `>= 2` → master (superviseur + gateway IPC) +
+* N workers (chacun un seul Kernel).
+*
+* Régime de déploiement : ON pour container multi-cœurs / VPS / bare-metal ; OFF
+* (1 process/pod) pour petit pod k8s + HPA. Cf `project_cluster_backplane_vision`.
+*/
+var Cluster = class extends Command {
+	constructor(cli) {
+		super("cluster", "démarre N workers isolés, relancés s'ils tombent", cli, options);
+		this.addOption("-w, --workers <number>", "Number of worker processes to fork (default: config cluster.workers / NF_WORKERS / 1)");
+		this.addOption("--detach", "spawn détaché + attente readiness (ports) + exit 0/69");
+		this.addOption("--wait <sec>", "plafond d'attente readiness (défaut 120)");
+		this.addOption("--health <path>", "GET de santé post-boot (best-effort)");
+		this.addOption("--log <file>", "log du runtime détaché (défaut tmp/)");
+	}
+	async onKernelStart(opts) {
+		this.cli.environment = "production";
+		process.env.NF_MODE_START = "cluster";
+		const cfgWorkers = await loadClusterConfig();
+		const topo = resolveTopology({
+			flag: opts?.workers,
+			config: cfgWorkers ?? void 0
+		});
+		await launchTopology({
+			cli: this.cli,
+			topo,
+			log: (msg, severity) => this.log(msg, severity)
+		});
+	}
+	async generate() {
+		process.title = cluster.isWorker ? `nodefony worker ${cluster.worker?.id ?? "?"} [cluster]` : "nodefony server";
+		return this.cli?.kernel;
+	}
+};
+//#endregion
+export { Cluster as default };

package/dist/node/kernel/commands/CompletionCommand.js

@@ -0,0 +1,31 @@
+import Command from "../../command/Command.js";
+import { COMPLETION_SHELLS, runCompletionCommand } from "../../cli/completion.js";
+//#region src/kernel/commands/CompletionCommand.ts
+const options = {
+	helpGroup: "AGENTS ET OUTILLAGE",
+	showBanner: false,
+	kernelEvent: "onStart"
+};
+/**
+* Commande `nodefony completion [install|uninstall] <shell>` — imprime le script de
+* complétion à sourcer (bash / zsh / fish), ou l'installe dans le rc du shell (bloc
+* marqué idempotent, réversible par `uninstall`).
+*
+* En pratique l'invocation directe est interceptée par le fast-path STANDALONE de
+* `CliKernel.start` (0 boot — cf `cli/completion.ts`) ; cette classe existe pour la
+* surface commander (help, menu interactif `start`) et route vers la MÊME logique
+* (une seule source : `runCompletionCommand`).
+*/
+var Completion = class extends Command {
+	constructor(cli) {
+		super("completion", `script de complétion du shell (${COMPLETION_SHELLS.join(" | ")})`, cli, options);
+		this.addArgument("[action]", "install | uninstall (default: print script)");
+		this.addArgument("[shell]", `target shell: ${COMPLETION_SHELLS.join(", ")} (default: $SHELL)`);
+	}
+	async generate() {
+		runCompletionCommand(process.argv);
+		return this;
+	}
+};
+//#endregion
+export { Completion as default };

package/dist/node/kernel/commands/CreateCommand.js

@@ -0,0 +1,45 @@
+import Command from "../../command/Command.js";
+import { CREATE_TYPES, runCreateCommand } from "../../cli/create.js";
+//#region src/kernel/commands/CreateCommand.ts
+const options = {
+	helpGroup: "GÉNÉRER ET CONSTRUIRE",
+	showBanner: false,
+	kernelEvent: "onStart"
+};
+/**
+* Commande `nodefony create <type> <name>` — scaffold d'un projet Nodefony depuis
+* les templates shippés (`templates/<type>/`).
+*
+* En pratique l'invocation directe est interceptée par le fast-path STANDALONE de
+* `CliKernel.start` (0 boot — cas nominal : `npx nodefony create app mon-app` HORS
+* de tout projet) ; cette classe existe pour la surface commander (help, complétion)
+* et route vers la MÊME logique (une seule source : `runCreateCommand`).
+*/
+var Create = class extends Command {
+	constructor(cli) {
+		super("create", "engendre une application, un module, une entité…", cli, options);
+		this.addArgument("<type>", CREATE_TYPES.join(" | ")).choices([...CREATE_TYPES]);
+		this.addArgument("[name]", "project name (kebab-case — asked if omitted)");
+		this.addOption("--dir <path>", "target directory (default: ./<name>)");
+		this.addOption("-f, --force", "allow a non-empty target directory");
+		this.addOption("--preset <preset>", "complete (default) | minimal");
+		this.addOption("--frontend <fw>", "none (default) | react | vue | angular");
+		this.addOption("-y, --yes", "accept spec defaults (skip interactive mode)");
+		this.addOption("--link", "wire nodefony deps as file: links to a local checkout (framework dev)");
+		this.addOption("--no-link", "force registry versions (skip link question)");
+		this.addOption("--id <kind>", "entity primary key: uuid7 (default) | uuid4 | serial");
+		this.addOption("--soft-delete", "entity: add deletedAt column");
+		this.addOption("--no-timestamps", "entity: drop createdAt/updatedAt");
+		this.addOption("--no-controller", "entity: skip the REST/WS controller");
+		this.addOption("--no-tests", "entity: skip the generated tests");
+		this.addOption("--connector <name>", "entity: ORM connector (default: default)");
+		this.addOption("--dialect <d>", "entity: sqlite | postgres | mysql (default: from config)");
+		this.addOption("--fields <spec>", "entity: \"title:string content:text\" (else positional)");
+	}
+	async generate() {
+		await runCreateCommand(process.argv);
+		return this;
+	}
+};
+//#endregion
+export { Create as default };

package/dist/node/kernel/commands/DevCommand.js

@@ -0,0 +1,99 @@
+import Command from "../../command/Command.js";
+import BootReporter from "../../service/dev/BootReporter.js";
+//#region src/kernel/commands/DevCommand.ts
+const options = {
+	helpGroup: "LANCER",
+	showBanner: false,
+	kernelEvent: "onPostReady"
+};
+/** Variable d'env distinguant le serveur enfant du process superviseur parent. */
+const CHILD_ENV = "NF_DEV_CHILD";
+/**
+* `true` si l'invocation demande un mode développement SANS superviseur.
+*
+* Lu sur `argv` et non sur les options analysées, comme `--detach` : ce choix décide
+* de la topologie du process, donc il se tranche AVANT que Commander n'ait rendu la
+* main. Fonction PURE (l'argv est passé) — elle s'éprouve sans lancer de serveur.
+*
+* @param args - `process.argv` ou son équivalent de test.
+*/
+function isWatchDisabled(args) {
+	return args.includes("--no-watch");
+}
+/**
+* Commande `nodefony development` — serveur en mode dev (front Vite/HMR + auto-restart).
+*
+* **Invariant non négociable : `development` = TOUJOURS 1 process.** La molette
+* topologie (`cluster.workers` / `--workers` / `NF_WORKERS`) est **ignorée** en
+* dev : Vite exige un process maître unique (conflit port HMR si N workers spawnaient
+* chacun leur Vite). Le multi-process se règle uniquement sur le runtime prod
+* (`nodefony cluster`). Cf décision « 2 molettes » 2026-05-24.
+*
+* Le seul « 2ᵉ process » en dev est le couple superviseur/enfant du {@link DevSupervisor}
+* (auto-restart au changement de source backend) — ce n'est PAS du cluster.
+*/
+var Dev = class extends Command {
+	#reporter = null;
+	constructor(cli) {
+		super("development", "démarre en développement, rechargement automatique", cli, options);
+		this.alias("dev");
+		this.addOption("--detach", "spawn détaché + attente readiness (ports) + exit 0/69");
+		this.addOption("--wait <sec>", "plafond d'attente readiness (défaut 120)");
+		this.addOption("--health <path>", "GET de santé post-boot (best-effort)");
+		this.addOption("--log <file>", "log du runtime détaché (défaut tmp/)");
+		this.addOption("--no-watch", "développement SANS superviseur : un seul process, aucun rechargement automatique");
+	}
+	/**
+	* Boot de rêve dev : checklist animée par phase (spinner + ✓/✗) à la place du mur
+	* de logs. Branché AVANT `loadApp` (gros import) pour couvrir le gap de feedback.
+	* **Enfant supervisé uniquement** (`NF_DEV_CHILD=1`) : le superviseur parent
+	* ne boote pas de serveur → aucun affichage. Animation TTY non-debug ; debug/non-TTY
+	* → marqueurs statiques + logs bruts (cf {@link BootReporter}).
+	*/
+	async onKernelPreStart() {
+		if (process.env[CHILD_ENV] !== "1" && !isWatchDisabled(process.argv)) return;
+		const kernel = this.kernel;
+		if (!kernel) return;
+		this.#reporter = new BootReporter(kernel, {
+			debug: Boolean(kernel.debug),
+			tty: kernel.isTTY
+		});
+		this.#reporter.attach();
+	}
+	async onKernelStart() {
+		this.cli.environment = "development";
+		process.env.NF_MODE_START = "development";
+		if (process.env[CHILD_ENV] === "1" || isWatchDisabled(process.argv)) {
+			this.kernel?.once("onReady", () => {
+				process.title = "nodefony-dev-server";
+			});
+			this.cli.setRunProfile({
+				servers: true,
+				lifetime: "longrunning",
+				interactive: false
+			});
+			return;
+		}
+		this.cli.setRunProfile({
+			servers: false,
+			lifetime: "longrunning",
+			interactive: false
+		});
+		const { default: DevSupervisor } = await import("../../service/dev/DevSupervisor.js");
+		await new DevSupervisor({
+			cwd: process.cwd(),
+			childEnvKey: CHILD_ENV
+		}).start();
+		await this.kernel.park();
+	}
+	async generate() {
+		try {
+			return this.cli?.kernel;
+		} catch (e) {
+			this.log(e, "ERROR");
+			throw e;
+		}
+	}
+};
+//#endregion
+export { Dev as default, isWatchDisabled };

package/dist/node/kernel/commands/DoctorCommand.js

@@ -0,0 +1,115 @@
+import Command from "../../command/Command.js";
+import { readTargetProvision } from "../checks/gating.js";
+import { collectLiveReport, liveNotRun } from "../checks/live.js";
+import { attachLive, collectDoctorReport, parseDoctorArgv, renderDoctorReport, reporterProgression, runDoctorCommand } from "../checks/runDoctor.js";
+import { localOperatorCaller } from "../adminPlane/adminCaller.js";
+//#region src/kernel/commands/DoctorCommand.ts
+const options = {
+	helpGroup: "COMPRENDRE",
+	quietBoot: true,
+	showBanner: false,
+	kernelEvent: "onPostReady"
+};
+/**
+* Commande `nodefony doctor` — contrôle la cohérence des paquets de l'application.
+*
+* Elle répond à une question qu'aucun test applicatif ne pose : **ce que mes
+* modules importent, est-ce qu'ils le déclarent ?** Tant qu'on développe, la
+* réponse n'a aucune importance — npm hisse tout à la racine du projet, donc un
+* import non déclaré se résout quand même. Elle en prend le jour où le module
+* part ailleurs : l'installation n'amène pas ce qui n'est pas déclaré, et un
+* outil de construction ne peut pas ordonner ce qu'on ne lui a pas dit.
+*
+* **Exécutée en « standalone » (zéro boot).** L'enregistrement ici sert au help
+* (`nodefony --help`) ; l'exécution réelle est interceptée par le fast-path de
+* {@link CliKernel.start} AVANT toute construction de Kernel — le contrôle ne
+* lit que des fichiers. Le `generate()` ci-dessous n'est qu'un FILET.
+*
+* Un projet déclare ses exceptions dans son `package.json`, clé
+* `nodefony.doctor` (`typeCycles`, `typesUnreachable`) : un cycle de types
+* légitime existe, et un contrôle qu'on ne peut pas satisfaire est un contrôle
+* qu'on apprend à ignorer.
+*
+* @example
+* ```bash
+* nodefony doctor          # sortie lisible, sort en erreur si un manquement
+* nodefony doctor --json   # même chose, exploitable par un script de CI
+* nodefony doctor --strict # un contrôle SAUTÉ échoue aussi (défaut sous `CI`)
+* nodefony doctor --live   # DEMANDE en plus à l'application (boot, 0 port)
+* nodefony doctor --env production   # ce qui manquera LÀ-BAS, depuis ce poste
+* ```
+*/
+var Check = class extends Command {
+	constructor(cli) {
+		super("doctor", "ce qui ne va pas dans cette application", cli, options);
+		this.addOption("--json", "Machine-readable output");
+		this.addOption("--strict", "Un contrôle SAUTÉ fait échouer (actif d'office si `CI` est posé)");
+		this.addOption("--no-strict", "Tolère un contrôle sauté même en intégration continue");
+		this.addOption("--deep", "tout : lance typecheck/lint/test, interroge npm, et demande à l'application (implique --live)");
+		this.addOption("--live", "Demande aussi à l'application démarrée (migrations, cohérence des zones)");
+		this.addOption("--no-live", "S'en tient aux fichiers : aucun démarrage, même si un script le demande");
+		this.addOption("--env <name>", "Dit ce qui manquera dans CET environnement (ex. production), depuis ce poste", [
+			"production",
+			"development",
+			"preprod",
+			"staging"
+		]);
+		this.addOption("--cwd <path>", "Start directory (the app root is resolved from it)");
+	}
+	async generate(opts) {
+		const argv = [];
+		if (opts?.json) argv.push("--json");
+		if (opts?.strict) argv.push("--strict");
+		if (opts?.noStrict) argv.push("--no-strict");
+		if (opts?.live) argv.push("--live");
+		if (opts?.deep) argv.push("--deep");
+		if (opts?.env) argv.push("--env", opts.env);
+		if (opts?.cwd) argv.push("--cwd", opts.cwd);
+		if (!opts?.live) {
+			await this.terminate(await runDoctorCommand(argv));
+			return this;
+		}
+		const parsed = parseDoctorArgv(argv);
+		if ("error" in parsed) {
+			await this.terminate(await runDoctorCommand(argv));
+			return this;
+		}
+		const debut = Date.now();
+		const report = await collectDoctorReport(parsed.cwd, parsed.targetEnv, parsed.deep, reporterProgression(parsed.json));
+		const complete = attachLive(report, await this.readLive(parsed.cwd, parsed.targetEnv));
+		await this.terminate(renderDoctorReport(complete, parsed, Date.now() - debut));
+		return this;
+	}
+	/**
+	* Interroge l'application que ce processus vient de démarrer.
+	*
+	* 🔴 **Ne lève jamais.** Le rapport statique est celui dont on a besoin quand
+	* l'application va mal : une exception ici l'emporterait tout entier, au pire
+	* moment. Un étage 2 impossible devient donc un état d'exécution lisible —
+	* ce qui a manqué, et le geste qui le rendrait possible.
+	*
+	* @returns ce que l'application a dit, ou la raison de son silence
+	*/
+	async readLive(start, targetEnv) {
+		const broker = this.kernel?.container?.get("adminBroker");
+		if (!broker) return liveNotRun("l'application a démarré, mais sans plan d'administration : aucun producteur ne peut être interrogé", "vérifie que `@nodefony/framework` est bien chargé");
+		try {
+			const kernel = this.kernel;
+			return await collectLiveReport(broker, localOperatorCaller(), {
+				targetEnv,
+				manifest: kernel?.options?.modules,
+				config: kernel?.options,
+				readTarget: readTargetProvision({
+					execPath: process.execPath,
+					binPath: process.argv[1] ?? "",
+					cwd: kernel?.path ?? start,
+					env: process.env
+				})
+			});
+		} catch (e) {
+			return liveNotRun(`l'interrogation de l'application a échoué — ${e.message}`);
+		}
+	}
+};
+//#endregion
+export { Check as default };

package/dist/node/kernel/commands/EnvCommand.js

@@ -0,0 +1,52 @@
+import Command from "../../command/Command.js";
+import { runEnvCommand } from "../../cli/env.js";
+//#region src/kernel/commands/EnvCommand.ts
+const options = {
+	helpGroup: "COMPRENDRE",
+	quietBoot: true,
+	showBanner: false,
+	kernelEvent: "onRegister"
+};
+/**
+* Commande `nodefony env` — l'environnement de l'application, en entier.
+*
+* Elle répond aux quatre questions qu'on se pose toujours ensemble, et dont
+* aucune n'avait de réponse ailleurs que dans le code du framework : **quels
+* fichiers `.env` sont lus et dans quel ORDRE**, **quelles variables
+* l'application déclare**, **quelle valeur est effective et d'où elle vient**,
+* et **ce qui est ignoré** — une valeur masquée par un fichier plus prioritaire,
+* ou une variable `NF_` mal orthographiée, qui n'a aucun effet et ne le dit
+* jamais.
+*
+* **Exécutée en « standalone » (zéro boot).** L'enregistrement ici sert au help
+* (`nodefony --help`) ; l'exécution réelle est interceptée par le fast-path de
+* {@link CliKernel.start}. C'est délibéré : on cherche une variable
+* d'environnement précisément quand l'application NE démarre pas. Une commande
+* de diagnostic qui exige un boot réussi est muette au seul moment où elle sert.
+*
+* Sort en 78 (`EX_CONFIG`) si une variable REQUISE manque — un script s'arrête
+* là plutôt que de lancer un démarrage voué à l'échec.
+*
+* @example
+* ```bash
+* nodefony env           # cascade, variables, provenance, ce qui est ignoré
+* nodefony env --json    # même rapport, pour un script ou un agent
+* ```
+*/
+var Env = class extends Command {
+	constructor(cli) {
+		super("env", "les variables d'environnement et leur provenance", cli, options);
+		this.addOption("-j, --json", "sortie JSON (scriptable)");
+		this.addOption("--example", "Dérive .env.example du catalogue env.ts (ADR-0006)");
+		this.addOption("--check", "Avec --example : vérifie sans écrire, sort en erreur si le fichier diverge");
+		this.addOption("--env <name>", "Évalue les exigences sous CET environnement (ex. production), depuis ce poste");
+		this.addOption("--cwd <path>", "Point de départ (la racine de l'app est résolue en remontant)");
+	}
+	async generate(opts) {
+		const code = await runEnvCommand(opts?.json ? ["env", "--json"] : ["env"]);
+		await this.terminate(code);
+		return this;
+	}
+};
+//#endregion
+export { Env as default };

package/dist/node/kernel/commands/GitHooksCommand.js

@@ -0,0 +1,47 @@
+import Command from "../../command/Command.js";
+import { runGitHooksCommand } from "../../cli/gitHooks.js";
+//#region src/kernel/commands/GitHooksCommand.ts
+const options = {
+	helpGroup: "AGENTS ET OUTILLAGE",
+	quietBoot: true,
+	showBanner: false,
+	kernelEvent: "onRegister"
+};
+/**
+* Commande `nodefony git:hooks` — hooks git natifs (`core.hooksPath`), zéro
+* dépendance.
+*
+* **Exécutée en « standalone » (zéro boot).** L'enregistrement ici sert au help
+* (`nodefony --help`) et à la complétion ; l'exécution réelle est interceptée
+* par le fast-path de {@link CliKernel.start} AVANT toute construction de
+* Kernel — la commande n'écrit que deux fichiers et une clé de config. Le
+* `generate()` ci-dessous n'est qu'un FILET.
+*
+* @example
+* ```bash
+* nodefony git:hooks            # pose .githooks/ + core.hooksPath
+* nodefony git:hooks --dry-run  # le plan, sans rien écrire ni configurer
+* ```
+*/
+var GitHooks = class extends Command {
+	constructor(cli) {
+		super("git:hooks", "pose les hooks git : contrôles au commit et au push", cli, options);
+		this.addOption("--dry-run", "Le plan, sans rien écrire ni configurer");
+		this.addOption("--json", "Sortie exploitable par un script");
+		this.addOption("--cwd <path>", "Point de départ (la racine de l'app est résolue en remontant)");
+	}
+	async generate(opts) {
+		const argv = [
+			"node",
+			"nodefony",
+			"git:hooks"
+		];
+		if (opts?.dryRun) argv.push("--dry-run");
+		if (opts?.json) argv.push("--json");
+		if (opts?.cwd) argv.push("--cwd", opts.cwd);
+		await this.terminate(runGitHooksCommand(argv));
+		return this;
+	}
+};
+//#endregion
+export { GitHooks as default };

package/dist/node/kernel/commands/InspectCommand.js

@@ -0,0 +1,153 @@
+import "../../cli/sysexits.js";
+import Command from "../../command/Command.js";
+import { shouldColorize, usableWidth } from "../checks/report.js";
+import { INSPECT_SUBJECTS, readAdminSubject } from "../inspect/adminSubjects.js";
+import { localOperatorCaller } from "../adminPlane/adminCaller.js";
+import { renderTable } from "../../cli/tableReport.js";
+//#region src/kernel/commands/InspectCommand.ts
+/**
+* `kernelEvent: "onPostReady"` — et pas `onReady`, malgré les apparences.
+*
+* Le plan d'administration est monté PAR un écouteur de `onReady`
+* (`Framework.onKernelReady`). Or l'action d'une commande intégrée est branchée
+* avant que le moindre module n'existe : à `onReady`, elle passerait donc AVANT
+* celui qui peuple le registre, et ne trouverait rien à inspecter. La phase
+* suivante est la première où le registre est garanti complet.
+*
+* Aucun serveur n'écoute pour autant : le profil console (`servers: false`, le
+* défaut) est respecté par `Kernel.initServers`.
+*/
+const options = {
+	helpGroup: "COMPRENDRE",
+	quietBoot: true,
+	showBanner: false,
+	kernelEvent: "onPostReady"
+};
+/**
+* Traduit un échec de lecture en code de sortie POSIX.
+*
+* La lecture (`readAdminSubject`) dit POURQUOI ; c'est à chaque porte de le
+* dire dans son vocabulaire — un code `sysexits` ici, un code JSON-RPC pour le
+* serveur MCP. La table des sujets, elle, n'est écrite qu'une fois.
+*/
+const EXIT_BY_FAILURE = {
+	"unknown-subject": 64,
+	"missing-target": 64,
+	"producer-missing": 69,
+	"endpoint-missing": 69,
+	"handler-failed": 70,
+	"not-found": 66,
+	forbidden: 77
+};
+/**
+* `nodefony inspect <sujet> [--json]` — lit l'état RÉEL de l'application, sans
+* serveur ni session.
+*
+* Pourquoi cette commande existe : l'état d'une application (ses routes, ses
+* services, sa configuration effective) est déjà exposé par le plan
+* d'administration — mais derrière HTTP, un rôle d'administrateur et un serveur
+* qui tourne. Trois obstacles pour qui travaille dans un terminal, et zéro pour
+* qui lit le code : on répond donc en devinant à partir des sources, alors que
+* la vérité est calculable en une seconde.
+*
+* Le contrôle d'accès du plan d'administration protège le RÉSEAU. Ici, il n'y a
+* pas de réseau : celui qui lance la commande a déjà le disque et la
+* configuration. La redaction, elle, s'applique quand même — elle vit DANS les
+* producteurs, pas dans le transport, donc un secret n'est pas plus lisible par
+* cette porte que par l'autre.
+*
+* 🔴 **La réponse dépend du MODE, et c'est pour cela qu'elle l'annonce.** Les
+* modules `policy:"dev"` ne sont pas chargés en production : la MÊME application
+* rend 136 routes en production et 354 en développement. Un nombre lu sans son
+* mode ne veut rien dire — mesuré, un agent a rapporté le compte d'une app en
+* marche pendant qu'un contrôle mesurait la même app bootée à froid dans l'autre
+* mode, et les deux avaient raison. L'environnement est donc écrit à côté du
+* total en rendu humain, et sur la sortie d'ERREUR en `--json` — jamais dans le
+* flux, qui doit rester parsable tel quel.
+*
+* @example
+* ```bash
+* nodefony inspect routes --json | jq '.[] | select(.methods[] == "POST")'
+* nodefony inspect module http --json
+* ```
+*/
+var Inspect = class extends Command {
+	constructor(cli) {
+		super("inspect", "l'état réel de l'app : routes, services, config", cli, options);
+		this.addArgument("[sujet]", `sujet : ${Object.keys(INSPECT_SUBJECTS).join(" | ")}`).choices(Object.keys(INSPECT_SUBJECTS));
+		this.addArgument("[cible]", "paramètre du sujet (ex : le nom d'un module)");
+		this.addOption("-j, --json", "sortie JSON (scriptable)");
+	}
+	async generate(subjectArg, target, opts = {}) {
+		let subject;
+		try {
+			subject = await this.askArgument(subjectArg, {
+				name: "sujet",
+				message: "Que veux-tu inspecter ?",
+				choices: Object.keys(INSPECT_SUBJECTS),
+				...opts.json ? { isTTY: false } : {}
+			});
+		} catch (e) {
+			this.log(e.message, "ERROR");
+			process.exitCode = 1;
+			return this;
+		}
+		const broker = this.kernel?.container?.get("adminBroker");
+		const read = await readAdminSubject(broker, subject, localOperatorCaller(), target);
+		if (!read.ok) {
+			const hint = read.reason === "missing-target" ? ` : nodefony inspect ${subject} <${INSPECT_SUBJECTS[subject]?.param}>` : "";
+			const why = read.cause ? ` — ${read.cause}` : "";
+			this.log(`${read.message}${why}${hint}`, "ERROR");
+			if (read.body !== void 0 && read.body !== null) this.log(JSON.stringify(read.body, null, 2), "ERROR");
+			await this.terminate(EXIT_BY_FAILURE[read.reason]);
+			return this;
+		}
+		if (opts.json) {
+			process.stderr.write(`environnement : ${this.currentEnvironment()}\n`);
+			process.stdout.write(`${JSON.stringify(read.data, null, 2)}\n`);
+		} else this.renderHuman(subject, read.data);
+		await this.terminate(0);
+		return this;
+	}
+	/**
+	* Rendu lisible par défaut — un tableau de lignes devient un tableau.
+	*
+	* Volontairement sommaire : le format qui compte est `--json`, celui qu'on
+	* enchaîne. Le rendu humain sert à répondre « qu'est-ce qu'il y a là-dedans »
+	* sans ouvrir un autre outil, pas à remplacer la console d'administration.
+	*/
+	/**
+	* Le mode MOTEUR sous lequel cette lecture a été faite.
+	*
+	* Sans kernel — cas qui ne devrait pas se produire ici, la commande booted —
+	* on le DIT plutôt que de deviner : une valeur inventée serait pire que pas
+	* de valeur, puisqu'elle serait crue.
+	*
+	* @returns le nom de l'environnement, ou `"inconnu"`
+	*/
+	currentEnvironment() {
+		return this.kernel?.environment ?? "inconnu";
+	}
+	renderHuman(subject, payload) {
+		if (Array.isArray(payload)) {
+			if (payload.length === 0) {
+				process.stdout.write(`${subject} : aucun (environnement : ${this.currentEnvironment()})\n`);
+				return;
+			}
+			const out = process.stdout;
+			const lines = renderTable(payload, {
+				width: usableWidth(out.columns),
+				color: shouldColorize(process.env, Boolean(this.kernel?.isTTY))
+			});
+			out.write(`${lines.join("\n")}\n\n`);
+			process.stdout.write(`${payload.length} ${subject} (environnement : ${this.currentEnvironment()})\n`);
+			return;
+		}
+		console.dir(payload, {
+			depth: 4,
+			colors: true
+		});
+	}
+};
+//#endregion
+export { Inspect as default };

package/dist/node/kernel/commands/InstallCommand.js

@@ -0,0 +1,20 @@
+import Command from "../../command/Command.js";
+//#region src/kernel/commands/InstallCommand.ts
+const optionsCommand = {
+	helpGroup: "GÉNÉRER ET CONSTRUIRE",
+	showBanner: false,
+	kernelEvent: "onRegister"
+};
+var Install = class extends Command {
+	constructor(cli) {
+		super("install", "installe les dépendances puis construit le projet", cli, optionsCommand);
+		this.addOption("-f, --force", "Force Install");
+	}
+	async generate(options) {
+		const modules = this.kernel?.getModules();
+		if (modules) for (const moduleName in modules) await modules[moduleName].install(options?.force);
+		return this;
+	}
+};
+//#endregion
+export { Install as default };