nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/types/kernel/adminPlane/executeAdmin.d.ts

@@ -0,0 +1,99 @@
+import type { IAdminEndpoint, IAdminRequest, IAdminResponse } from "../../types/IAdminApi.js";
+/**
+ * Issue d'un endpoint d'administration, sous la forme que TOUTES les portes
+ * reçoivent — succès comme échec.
+ *
+ * C'est volontairement la forme d'une réponse HTTP sans en être une : les
+ * producteurs raisonnent déjà en `{status, body}` (un 404 qui joint le plan de
+ * la page, un 400 qui nomme les valeurs valides), et chaque porte décide
+ * ensuite de l'emballage — JSON pour HTTP, `RpcError` pour le
+ * pont WS-RPC, texte pour la CLI et le serveur MCP.
+ */
+export interface IAdminExecution {
+    /** Statut résolu du handler (200 par défaut). */
+    status: number;
+    /** En-têtes que le producteur a joints, s'il en a joint. */
+    headers?: IAdminResponse["headers"];
+    /** La donnée, ou le corps d'erreur **que le producteur a préparé**. */
+    body: unknown;
+}
+/**
+ * Verdict d'une porte posée AVANT le handler — aujourd'hui l'idempotence des
+ * mutations, demain ce que le transport exigera.
+ *
+ * Soit la porte tranche seule (`shortCircuit` : rejeu mémorisé, 409 concurrent,
+ * 400 clé requise), soit elle laisse passer en demandant à être rappelée à
+ * l'issue (`onSuccess` mémorise, `onFailure` libère).
+ */
+export interface IAdminGateVerdict {
+    /** Réponse immédiate : le handler n'est pas appelé. */
+    shortCircuit?: IAdminExecution;
+    /** Appelé après un handler qui a rendu sa réponse. */
+    onSuccess?: (execution: IAdminExecution) => void | Promise<void>;
+    /** Appelé après un handler qui a levé — l'appel reste réessayable. */
+    onFailure?: () => void | Promise<void>;
+}
+/**
+ * Porte optionnelle évaluée entre le RBAC et le handler.
+ *
+ * Le paramètre qui la porte est **obligatoire et nullable** dans
+ * {@link IAdminExecuteInput} : `null` est un choix qu'on lit dans le code
+ * d'appel (« cette porte ne lit que des GET »), là où un paramètre absent
+ * serait un oubli qu'aucune relecture ne rattrape.
+ */
+export type AdminGate = (request: IAdminRequest) => IAdminGateVerdict | Promise<IAdminGateVerdict>;
+/** Ce dont l'exécution a besoin — aucun transport, aucun conteneur. */
+export interface IAdminExecuteInput {
+    /** L'endpoint résolu par l'appelant (par nom de route, ou par chemin). */
+    endpoint: IAdminEndpoint;
+    /** La requête projetée : params, query, corps, identité, rôles. */
+    request: IAdminRequest;
+    /**
+     * Rôle exigé, déjà résolu par
+     * {@link resolveAdminRole} — passé plutôt que recalculé pour que
+     * la porte HTTP puisse honorer le rôle **monté** avec sa route.
+     */
+    requiredRole: string;
+    /** Porte d'idempotence, ou `null` quand l'appelant n'en pose aucune. */
+    gate: AdminGate | null;
+    /**
+     * Notification d'une panne serveur (le handler a levé autre chose qu'une
+     * erreur cliente). Le cœur ne journalise pas à la place de l'appelant : la
+     * route HTTP veut un `ERROR` dans le syslog, la CLI veut une trace à l'écran,
+     * un harnais de test veut relever l'exception telle quelle.
+     */
+    onServerError?: (error: Error) => void;
+}
+/**
+ * Normalise ce qu'un handler a rendu : donnée brute, ou enveloppe.
+ *
+ * Discrimination volontairement étroite — enveloppe **si et seulement si**
+ * `body` est présent AVEC `status` ou `headers`. Un objet métier qui posséderait
+ * un champ `body` (une réponse de webhook, un message stocké) n'en est pas une.
+ *
+ * @param result - le retour du handler, tel quel.
+ * @returns l'issue normalisée, statut 200 par défaut.
+ */
+export declare function normalizeAdminResult(result: unknown): IAdminExecution;
+/**
+ * Exécute un endpoint du plan d'administration — **la porte unique**, sans HTTP.
+ *
+ * ⭐ **Une source, plusieurs portes.** Le data plane est un ensemble de
+ * fonctions `IAdminRequest → donnée` ; ce qui les entoure (autorisation,
+ * idempotence des mutations, normalisation du retour, traduction des erreurs)
+ * est une règle unique, et elle vit ici. La route HTTP montée par le broker, le
+ * pont WS-RPC, la commande `inspect` et le serveur MCP appellent tous cette
+ * fonction : ils ne se distinguent que par la façon de RÉSOUDRE l'endpoint (par
+ * nom de route côté framework, par couple namespace/chemin côté cœur) et par
+ * l'emballage de l'issue.
+ *
+ * Ce que la duplication précédente coûtait, concrètement : le producteur de
+ * `module/{name}/docs/{slug}` joint au refus d'une section inconnue le plan de
+ * la page (les titres réels). La seconde implémentation ne gardait que le
+ * statut — un agent lisait « introuvable » et concluait que la PAGE n'existait
+ * pas, alors que seul le nom de section était faux.
+ *
+ * @param input - endpoint, requête, rôle exigé, porte éventuelle.
+ * @returns l'issue, succès comme échec, **corps du producteur préservé**.
+ */
+export declare function executeAdminEndpoint(input: IAdminExecuteInput): Promise<IAdminExecution>;

package/dist/types/kernel/bootReport.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Rapport de boot — **vérité unique** sur le résultat du démarrage du Kernel,
+ * calculé une fois à `onPostReady` et consommé par N canaux (rendu écran dev via
+ * `BootReporter`, log structuré prod, code de sortie pour l'orchestrateur/superviseur,
+ * canal RPC dev, futur endpoint Studio `/nodefony/kernel/api/boot`).
+ *
+ * Objectif : **plus aucun boot qui meurt en silence**. Un profil serveur qui finit
+ * sans aucun serveur en écoute est un échec VISIBLE (`healthy=false`), pas un
+ * « arrêt propre (code 0) » trompeur.
+ */
+/**
+ * Un module ignoré ou en échec **non fatal** pendant le boot (fail-soft). Agrégé
+ * par le Kernel pour expliquer, en une ligne par module, pourquoi le boot est
+ * dégradé — au lieu de N WARNING enterrés dans le JSONL.
+ */
+export interface IBootFailure {
+    /** Nom du module/service en échec (tag `owner`, ou nom d'entrée du manifeste). */
+    module: string;
+    /** Message d'erreur condensé (1ʳᵉ ligne). */
+    reason: string;
+    /**
+     * Étape du boot où l'échec s'est produit :
+     * - `load` — `import()` du module (manifeste) a throw (ex. « Cannot find package »).
+     * - `lifecycle` — un hook `onKernelRegister`/`Boot`/`Ready` a throw/timeout.
+     * - `init` — l'`initialize()` d'un service/module a throw/timeout.
+     */
+    phase: "load" | "lifecycle" | "init";
+    /** `true` si l'échec est un dépassement du timeout de boot. */
+    timedOut?: boolean;
+}
+/**
+ * Un module du manifeste **volontairement NON chargé** par le gating
+ * `policy`/`when` de `config.modules`. Ce n'est PAS un échec (cf {@link IBootFailure})
+ * — mais un gating silencieux se lit comme un module perdu : le bilan de boot
+ * l'affiche AVEC sa raison pour que le dev sache pourquoi son module manque.
+ */
+export interface IBootModuleGated {
+    /** Nom d'entrée du manifeste (`config.modules`). */
+    module: string;
+    /** Raison lisible du non-chargement (ex. `policy "dev" — runtime production`). */
+    reason: string;
+}
+/** Un serveur réseau réellement en écoute à la fin du boot. */
+export interface IBootServerInfo {
+    /** Nom de service interne (`http` | `https` | `websocket` | `websocket-secure`). */
+    type: string;
+    /** Scheme d'URL court et conventionnel (`http` | `https` | `ws` | `wss`). */
+    scheme: string;
+    /** Port d'écoute effectif. */
+    port: number;
+    /** Adresse de bind (`127.0.0.1`, `0.0.0.0`…), si connue. */
+    address?: string;
+    /** URL complète d'accès (`scheme://host:port`) — cliquable au terminal. */
+    url: string;
+}
+/**
+ * Verdict agrégé du dernier boot. `healthy=false` ⇒ le boot est raté ou dégradé de
+ * façon bloquante (typiquement : profil serveur attendu mais 0 serveur en écoute).
+ */
+export interface IBootReport {
+    /** Durée approximative du boot (ms). */
+    durationMs: number;
+    /** Modules effectivement chargés et enregistrés. */
+    modulesLoaded: string[];
+    /**
+     * Nombre d'entrées DÉCLARÉES au manifeste `config.modules`, avant tout gating.
+     *
+     * Distinct de `modulesLoaded` (ce qui a été chargé), de `modulesSkipped` (ce qui
+     * a échoué) et de `modulesGated` (ce qui a été écarté à dessein) : c'est ce que
+     * la configuration LUE demandait. Un manifeste à `0` alors que le profil attend
+     * des serveurs est un état muet — aucune de ces trois listes ne le contient, et
+     * rien n'a été tenté. Vécu : une application dont le manifeste résolu était vide
+     * bootait avec son seul module local puis échouait sur « aucun serveur en
+     * écoute », un diagnostic qui ne menait nulle part.
+     */
+    manifestEntries: number;
+    /** Modules ignorés/échoués en fail-soft (avec la raison). */
+    modulesSkipped: IBootFailure[];
+    /** Modules volontairement non chargés (gating `policy`/`when`) — pas des échecs. */
+    modulesGated: IBootModuleGated[];
+    /**
+     * Logs `WARNING` émis pendant le boot (comptés dans le ring buffer syslog ;
+     * figés à `onPostReady`, comptage à la volée tant que le boot est en cours).
+     */
+    warnings: number;
+    /** Logs `ERROR` et pire (`CRITIC`/`ALERT`/`EMERGENCY`) émis pendant le boot. */
+    errors: number;
+    /**
+     * Les PREMIERS de ces messages, condensés — `null` quand il n'y en a aucun.
+     *
+     * `errors: 1` sans un mot était le cas le plus frustrant du bilan : le
+     * lecteur savait qu'il s'était passé quelque chose, pas quoi. Alloué
+     * seulement s'il y a matière.
+     */
+    criticals: string[] | null;
+    /** `true` si le profil d'exécution attendait des serveurs réseau. */
+    serversExpected: boolean;
+    /** Serveurs réellement en écoute. */
+    serversListening: IBootServerInfo[];
+    /**
+     * Verdict global : `false` si un profil serveur a fini sans aucun serveur en
+     * écoute (garde-fou 0-serveur). Les modules ignorés seuls ne rendent PAS le boot
+     * `unhealthy` (dégradé mais vivant) — seul le 0-serveur attendu est bloquant.
+     */
+    healthy: boolean;
+    /**
+     * Action corrective suggérée d'après les raisons d'échec (ex. « dist périmé ⇒
+     * npm run clean && npm run build » quand un `import()` échoue). `undefined` si
+     * aucune heuristique ne matche. Source unique partagée par le log et l'écran.
+     */
+    remediation?: string;
+}

package/dist/types/kernel/checks/deep.d.ts

@@ -0,0 +1,122 @@
+import { type IOutdatedSummary } from "../../cli/outdated.js";
+/** La borne à appliquer à une étape, à défaut la borne générale. */
+export declare function timeoutForStep(step: string): number;
+/**
+ * Ce qu'un étage profond ANNONCE pendant qu'il travaille.
+ *
+ * `--deep` lance des scripts qui prennent des minutes. Sans un mot, la commande
+ * paraît bloquée — et un utilisateur qui croit un outil bloqué l'interrompt,
+ * puis cesse de s'en servir. L'annonce n'est donc pas un confort : c'est ce qui
+ * rend l'étage utilisable.
+ *
+ * Deux évènements par script, `start` puis `done` : le premier dit CE QUI est
+ * en cours (la seule information utile pendant l'attente), le second ce qu'il a
+ * donné et en combien de temps.
+ */
+export interface IDeepProgress {
+    /** Le nom du script, ou `outdated` pour l'interrogation du registre. */
+    step: string;
+    phase: "start" | "done";
+    /** Renseignés sur `done` seulement. */
+    outcome?: IVerifyStepResult["outcome"] | "ok" | "unavailable";
+    ms?: number;
+}
+/** Ce qui reçoit les annonces — `undefined` quand personne n'écoute. */
+export type DeepReporter = (event: IDeepProgress) => void;
+/** Le verdict d'un script déclaré par le projet, une fois lancé. */
+export interface IVerifyStepResult {
+    /** Le nom du script, tel qu'il figure dans `scripts` du manifeste. */
+    step: string;
+    /**
+     * Ce qui s'est passé.
+     *
+     * `absent` n'est PAS un échec de cet étage : c'est le contrôle « les gardes
+     * du projet sont-elles armées ? » qui en répond, et le dire deux fois ferait
+     * compter un manquement pour deux.
+     */
+    outcome: "passed" | "failed" | "absent" | "timeout";
+    /** La première ligne utile de la sortie, quand il a échoué. */
+    detail?: string;
+    /** Durée d'exécution, en millisecondes. */
+    ms: number;
+}
+/** Ce que l'étage profond a pu établir — et ce qu'il n'a PAS pu. */
+export interface IDeepResult {
+    steps: IVerifyStepResult[];
+    /** Le résumé des paquets en retard, ou `null` si le registre n'a pas répondu. */
+    outdated: IOutdatedSummary | null;
+    /** Pourquoi le registre n'a rien dit — vide quand il a répondu. */
+    outdatedReason: string;
+}
+/**
+ * Les scripts que le manifeste déclare, parmi ceux qu'on sait lancer.
+ *
+ * On ne lance QUE ce que le projet déclare : inventer une commande qu'il n'a
+ * pas (`npx tsc`, par exemple) reviendrait à juger une application sur un
+ * outillage qu'elle n'a pas choisi.
+ *
+ * @param projectRoot - racine de l'application.
+ * @param steps - les noms de scripts à chercher, dans l'ordre d'exécution.
+ * @returns les noms présents, et ceux qui manquent.
+ */
+export declare function declaredSteps(projectRoot: string, steps: readonly string[]): {
+    present: string[];
+    missing: string[];
+};
+/**
+ * La première ligne qui NOMME l'échec, en sautant l'annonce de l'exécuteur.
+ *
+ * 🔴 Un script lancé par `npm run` reçoit d'abord `npm notice run <app> <nom>`.
+ * Retenir cette ligne explique l'échec par le nom du script, jamais par la
+ * cause — et le rapport devient inutile sans qu'on s'en aperçoive : il a
+ * l'apparence d'une explication. Le bruit est donc sauté sur les DEUX flux
+ * avant de se rabattre sur l'un d'eux.
+ *
+ * @param stderr - canal d'erreur du script.
+ * @param stdout - sa sortie standard.
+ * @returns la ligne utile, bornée, ou une chaîne vide s'il s'est tu.
+ */
+export declare function firstUsefulLine(stderr: string, stdout: string): string;
+/**
+ * Lance les scripts déclarés, dans l'ordre, et rend leur verdict.
+ *
+ * L'ordre compte : `typecheck` avant `test`, parce qu'un type faux fait échouer
+ * la suite pour une raison qui n'a rien à voir avec elle, et qu'on veut lire la
+ * cause d'abord.
+ *
+ * @param projectRoot - racine de l'application.
+ * @param steps - les scripts à lancer, dans l'ordre.
+ * @param run - l'exécuteur, injecté pour que la logique s'éprouve sans lancer
+ *   quoi que ce soit : une fonction qui appelle `spawnSync` en dur ne se teste
+ *   que sur la machine qui l'exécute, c'est-à-dire nulle part.
+ * @returns un verdict par script demandé.
+ */
+export declare function runVerifySteps(projectRoot: string, steps: readonly string[], run?: (step: string) => IStepRun | Promise<IStepRun>, report?: DeepReporter): Promise<IVerifyStepResult[]>;
+/** Ce que rend l'exécution d'un script : son verdict brut, avant jugement. */
+export interface IStepRun {
+    status: number | null;
+    stderr: string;
+    stdout: string;
+    ms: number;
+}
+/**
+ * Le résumé des paquets en retard, via la MÊME agrégation que `nodefony outdated`.
+ *
+ * `aggregateOutdated` est appelée, jamais recopiée : elle porte le classement
+ * par sévérité (majeure / mineure / correctif) et le regroupement par paquet.
+ * Une seconde implémentation ici divergerait au premier ajustement, et les deux
+ * passeraient leurs propres tests.
+ *
+ * @param projectRoot - racine de l'application.
+ * @param run - l'exécuteur, injecté pour l'épreuve.
+ * @returns le résumé, ou la raison de son absence.
+ */
+export declare function readOutdated(projectRoot: string, run?: () => IOutdatedRun | Promise<IOutdatedRun>, report?: DeepReporter): Promise<{
+    summary: IOutdatedSummary | null;
+    reason: string;
+}>;
+/** Ce que rend l'interrogation du registre. */
+export interface IOutdatedRun {
+    stdout: string;
+    failed: boolean;
+}

package/dist/types/kernel/checks/freshness.d.ts

@@ -0,0 +1,49 @@
+/** Un écart entre ce qui est écrit et ce qui s'exécutera. */
+export interface IFreshnessFinding {
+    kind: "dist-stale" | "dist-missing" | "node-below-engines" | "framework-stale" | "framework-missing";
+    /** Phrase actionnable : le constat, et le geste qui le répare. */
+    message: string;
+    /** Fichier qui porte le constat, relatif à la racine (si pertinent). */
+    file?: string;
+}
+/** Ce que le contrôle a regardé — et ce qu'il n'a PAS pu regarder. */
+export interface IFreshnessResult {
+    findings: IFreshnessFinding[];
+    /**
+     * `true` quand aucun `dist/` n'existe ET qu'aucune source n'a été trouvée :
+     * il n'y a rien à comparer, et le silence ne vaut pas quitus.
+     */
+    notComparable: boolean;
+}
+/** La version majeure exigée par `engines.node`, ou `null` si non déclarée. */
+export declare function requiredNodeMajor(engines: unknown): number | null;
+/**
+ * Confronte les sources au build, et la version de Node au plancher déclaré.
+ *
+ * @param projectRoot - racine de l'application.
+ * @param nodeVersion - version du runtime (injectée : une fonction qui lit
+ *   `process.version` ne s'éprouve que sur la version qu'elle décrit).
+ * @returns les écarts, et si la comparaison a pu avoir lieu.
+ */
+export declare function checkFreshness(projectRoot: string, nodeVersion?: string): IFreshnessResult;
+/**
+ * Les paquets `@nodefony/*` LIÉS dont le build manque ou date d'avant les sources.
+ *
+ * Le runtime charge le `dist/` d'un paquet, jamais ses sources — exactement
+ * comme pour l'application. La différence est le coût du symptôme : un paquet
+ * du framework périmé fait répondre 404 à une route pourtant écrite, ou lever
+ * « does not provide an export named … » au démarrage, sans que rien ne
+ * désigne la cause. C'est la panne la plus fréquente de ce framework, et la
+ * seule que `doctor` ne voyait pas — il ne regardait que le `dist/` de
+ * l'application.
+ *
+ * ⚠️ Ne regarde QUE les paquets liés (cf {@link estLie}), et n'accuse que dans
+ * le sens sûr : sources plus récentes que le build. Un cache peut restaurer un
+ * `dist/` daté du futur sans que son contenu corresponde ; l'inverse reste
+ * toujours vrai.
+ *
+ * @param projectRoot - racine de l'application (celle qui porte `node_modules`).
+ * @returns les paquets à rebâtir, avec le geste — vide quand tout est à jour,
+ *   qu'il n'y a pas de `node_modules`, ou que rien n'est lié.
+ */
+export declare function checkFrameworkBuild(projectRoot: string): IFreshnessFinding[];

package/dist/types/kernel/checks/gating.d.ts

@@ -0,0 +1,134 @@
+import { type IModuleGated } from "../moduleGating.js";
+import type { GateConfig } from "../moduleGating.js";
+import type { IExecution } from "./report.js";
+/** Ce qu'un boot rend d'un service : son nom, et le module qui le porte. */
+export interface IProvidedService {
+    name: string;
+    module: string;
+}
+/** Une brique que l'environnement visé fera disparaître. */
+export interface IGatingFinding {
+    kind: "service-lost";
+    /** La phrase telle qu'elle s'affiche. */
+    message: string;
+    /** Le service perdu — porté pour que le JSON reste exploitable. */
+    service: string;
+    /** Le ou les modules qui le fournissaient ici. */
+    providers: string[];
+}
+/** Ce que l'étage 2 a constaté du gating, et ce qu'il n'a PAS pu regarder. */
+export interface IGatingResult {
+    findings: IGatingFinding[];
+    /** Les modules que l'environnement visé écarte — INFO, jamais un verdict. */
+    gated: IModuleGated[];
+    execution: IExecution;
+}
+/** Le résultat d'un boot console visant un environnement. */
+export type ITargetProvision = {
+    ok: true;
+    services: IProvidedService[];
+} | {
+    ok: false;
+    reason: string;
+    short: string;
+    unlock?: string;
+};
+/** Ce dont la famille a besoin pour travailler — tout est INJECTÉ. */
+export interface IGatingInput {
+    /** L'environnement visé (`production`), ou `null` si l'on ne vise rien. */
+    targetEnv: string | null;
+    /** Le manifeste `config.modules` de l'application démarrée. */
+    manifest: unknown;
+    /** La config fusionnée, sur laquelle chaque `when()` est évalué. */
+    config: GateConfig;
+    /** Les services vus ICI, tels que l'application démarrée les déclare. */
+    here: IProvidedService[];
+    /**
+     * Ce que l'environnement visé fournit — le VERDICT d'un boot, jamais la
+     * façon de l'obtenir.
+     *
+     * Injecté pour que la comparaison soit éprouvable sans démarrer quoi que ce
+     * soit : une famille qui lance elle-même un processus ne se teste que dans un
+     * environnement où ce processus aboutit, c'est-à-dire nulle part en
+     * intégration continue.
+     */
+    readTarget: (env: string) => Promise<ITargetProvision>;
+}
+/**
+ * L'état d'exécution quand aucun environnement n'est visé.
+ *
+ * Une seule rédaction, parce que deux chemins y mènent — la commande sans
+ * `--env`, et la famille appelée sans cible — et que deux formulations du même
+ * fait finiraient par se contredire.
+ */
+export declare const NO_TARGET: IExecution;
+/**
+ * Les services que l'environnement visé ne fournira plus.
+ *
+ * Fonction PURE : c'est un DIFF de deux listes, rien de plus. Un service encore
+ * présent là-bas ne lève rien, quel que soit le module qui le porte — un défaut
+ * du framework qui reprend la main est exactement le cas sain que ce contrôle
+ * ne doit pas signaler.
+ *
+ * @param here - les services de l'application telle qu'elle tourne ici.
+ * @param there - les services de l'application dans l'environnement visé.
+ * @param targetEnv - le nom de l'environnement visé, pour la phrase rendue.
+ * @returns un manquement par service perdu, dans l'ordre alphabétique.
+ */
+export declare function lostServices(here: readonly IProvidedService[], there: readonly IProvidedService[], targetEnv: string): IGatingFinding[];
+/**
+ * Confronte ce que l'application fournit ICI à ce qu'elle fournira LÀ-BAS.
+ *
+ * Ne lève jamais : un boot cible impossible devient un état d'exécution
+ * lisible. C'est la doctrine de tout l'étage 2 — le rapport statique est celui
+ * dont on a besoin quand l'application va mal, et une exception l'emporterait
+ * au pire moment.
+ *
+ * @param input - l'environnement visé, le manifeste, et les deux vues.
+ * @returns les briques perdues, les modules écartés, et l'état d'exécution.
+ */
+export declare function checkGating(input: IGatingInput): Promise<IGatingResult>;
+/** Ce qu'il faut pour lancer le boot cible — injecté, jamais lu ici. */
+export interface ITargetBootInput {
+    /** L'interpréteur à relancer (`process.execPath`). */
+    execPath: string;
+    /** Le binaire `nodefony` en cours (`process.argv[1]`). */
+    binPath: string;
+    /** La racine de l'application. */
+    cwd: string;
+    /** L'environnement du processus courant, dont la cible hérite. */
+    env: Record<string, string | undefined>;
+    /** Délai au-delà duquel on renonce (défaut : 120 s). */
+    timeoutMs?: number;
+}
+/** Le délai au-delà duquel un boot cible qui n'a pas répondu est abandonné. */
+export declare const TARGET_BOOT_TIMEOUT_MS = 120000;
+/**
+ * Demande à un boot console visant `env` ce qu'il fournit.
+ *
+ * `nodefony inspect services --json` et rien d'autre : c'est le producteur que
+ * la console d'administration et `inspect` lisent déjà, et le dépôt interdit
+ * d'en écrire une seconde version. Le sous-processus n'ouvre aucun port (profil
+ * console) — il cohabite donc avec un serveur de développement en marche.
+ *
+ * ⚠️ Les deux étiquettes sont posées ENSEMBLE (`NODE_ENV` et `NF_ENV`) : le
+ * mode d'exécution décide du gating `policy`, l'environnement de déploiement
+ * décide des surcharges de configuration et des `when()`. N'en poser qu'une
+ * ferait diagnostiquer un environnement qui n'existe nulle part.
+ *
+ * @param input - de quoi relancer le binaire courant.
+ * @returns ce que l'environnement visé fournit, ou la raison de son silence.
+ */
+/**
+ * L'environnement du boot cible, dérivé de celui d'ici.
+ *
+ * Extrait pour être ÉPROUVÉ : la seule autre façon de constater ce qu'un
+ * sous-processus reçoit est de le démarrer, c'est-à-dire de ne le vérifier que
+ * là où il aboutit.
+ *
+ * @param env - l'environnement du processus courant.
+ * @param target - l'environnement visé.
+ * @returns l'environnement à donner au boot cible.
+ */
+export declare function targetEnvironment(env: Record<string, string | undefined>, target: string): Record<string, string | undefined>;
+export declare function readTargetProvision(input: ITargetBootInput): (env: string) => Promise<ITargetProvision>;

package/dist/types/kernel/checks/guards.d.ts

@@ -0,0 +1,57 @@
+/** Une garde décrochée. */
+export interface IGuardFinding {
+    kind: "lint-not-blocking" | "lint-missing" | "rule-disabled" | "rule-missing" | "typecheck-missing" | "verify-missing" | "verify-broken";
+    message: string;
+    file: string;
+}
+/** Ce que le contrôle a pu constater. */
+export interface IGuardResult {
+    findings: IGuardFinding[];
+    /** Les gardes effectivement CONSTATÉES en place — le compte du sommaire. */
+    armed: number;
+    /**
+     * Le NOM de chacune — sans quoi « 5 gardes armées » ne dit rien.
+     *
+     * Un compte seul se lit comme un quitus : le lecteur ne sait ni ce qui est
+     * gardé, ni ce qui ne l'est pas, et n'a aucun moyen de vérifier que la garde
+     * qu'il croyait posée en fait partie. Les noms sont hétérogènes par nature —
+     * des scripts du manifeste et des règles du linter — et c'est précisément ce
+     * qu'il faut montrer : le chiffre agrégeait deux choses sans le dire.
+     */
+    armedNames: string[];
+    /** `true` si la configuration du linter n'a pas pu être lue. */
+    linterUnreadable: boolean;
+    /** `true` si le manifeste n'a pas pu être lu. */
+    manifestUnreadable: boolean;
+}
+/**
+ * Les règles dont la désactivation retire un filet, et pourquoi.
+ *
+ * Nommées ici plutôt que devinées : ce sont celles que le projet a choisies et
+ * que sa doctrine cite (« 0 `any`, 0 `@ts-ignore` »). Une liste dérivée de la
+ * configuration ne dirait rien — c'est justement l'absence qu'on cherche.
+ */
+export declare const REQUIRED_RULES: readonly {
+    name: string;
+    why: string;
+    /**
+     * La catégorie oxlint qui l'active SANS déclaration — constatée en exécutant
+     * `oxlint` catégorie par catégorie, jamais déduite d'une documentation. Un
+     * projet qui active cette catégorie a la garde, même sans nommer la règle :
+     * l'ignorer ferait crier `doctor` sur une configuration saine.
+     */
+    category: string;
+}[];
+/** Ce que la chaîne `verify` doit enchaîner pour mériter son nom. */
+export declare const VERIFY_STEPS: readonly string[];
+export interface IGuardCheckOptions {
+    /** Racine du projet — c'est elle qui porte le manifeste et la configuration. */
+    projectRoot: string;
+}
+/**
+ * Constate que les gardes du projet sont armées.
+ *
+ * @param options - la racine du projet.
+ * @returns les gardes décrochées, et le nombre de celles qui tiennent.
+ */
+export declare function checkGuards(options: IGuardCheckOptions): IGuardResult;