nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/types/types/IMcpTool.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Contrat d'un outil **Model Context Protocol** — défini dans le CORE.
+ *
+ * Vit ici, et non dans le module qui sert la porte HTTP, pour la raison qui
+ * gouverne déjà {@link IAdminApi} : un outil peut être produit par n'importe
+ * quel niveau de la pile — un module métier d'application, un adapter ORM, un
+ * futur module IA — et le contrat doit donc résider au plus bas niveau commun.
+ * Un contrat logé dans un module `policy: "dev"` obligerait toute application
+ * voulant déclarer un outil à dépendre d'un paquet qui disparaît en production.
+ *
+ * Séparation des rôles :
+ *  - Ce fichier = **producteur**. Un module déclare *quels* outils il offre, par
+ *    `getMcpTools()`, sans rien connaître du transport ni du protocole.
+ *  - `mcp/server.ts` (core) = **protocole**. Il reçoit des outils déjà résolus.
+ *  - Un controller de module = **transport**. Il traduit HTTP ↔ JSON-RPC.
+ */
+/**
+ * Ce que rend un outil — du contenu, et l'aveu d'un échec métier.
+ *
+ * Un échec métier se dit par `isError`, jamais par une exception : le protocole
+ * réserve ses erreurs aux fautes de protocole. La distinction compte pour
+ * l'agent — une erreur de protocole signifie « tu t'y prends mal », un `isError`
+ * signifie « ta demande est recevable, voici pourquoi elle n'aboutit pas » ;
+ * c'est la seconde qu'il peut corriger seul.
+ */
+export interface IMcpToolResult {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: boolean;
+}
+/**
+ * Ce que le transport a pu ÉTABLIR de l'appelant — jamais ce qu'il prétend.
+ *
+ * La spec autorise le catalogue à varier selon l'autorisation présentée, et
+ * pose la condition qui rend cela sûr : « credentials are **per-request input,
+ * not connection state** ». D'où cet objet, construit à CHAQUE requête par la
+ * porte, et jamais mémorisé entre deux.
+ *
+ * ⚠️ **Une porte qui n'authentifie pas rend un appelant anonyme** — pas une
+ * autorisation implicite. Tant que le rôle *resource server* n'est pas branché,
+ * `authenticated` est `false` et `scopes` est vide : les outils qui exigent
+ * quoi que ce soit sont retenus, jamais servis par défaut.
+ */
+export interface IMcpCaller {
+    /**
+     * Une identité a-t-elle été PROUVÉE (jeton validé) ?
+     *
+     * `false` par défaut, et c'est le seul défaut sûr : le jour où quelqu'un
+     * branche une porte authentifiée en oubliant de poser ce drapeau, les outils
+     * protégés restent invisibles — l'inverse aurait ouvert.
+     */
+    authenticated: boolean;
+    /** Scopes réellement accordés par le serveur d'autorisation. */
+    scopes: readonly string[];
+    /**
+     * Rôles Nodefony de cet appelant — ce sur quoi le plan d'administration
+     * tranche.
+     *
+     * Posés par la PORTE, qui seule connaît sa configuration : une porte non
+     * protégée (module de développement, bornée par son périmètre et ses gardes
+     * de transport) accorde le rôle d'opérateur et l'ÉNONCE ; une porte protégée
+     * les dérive du jeton ({@link rolesFromScopes}) et n'accorde rien d'autre.
+     *
+     * Champ **obligatoire** : le compilateur force chaque porte à décider. Il l'a
+     * été après avoir constaté l'inverse — la lecture d'administration fabriquait
+     * un administrateur, donc tout porteur d'un jeton d'audience valide, même
+     * sans aucun droit, obtenait tout.
+     */
+    roles: readonly string[];
+    /** Sujet du jeton (`sub`), pour l'audit et pour filtrer les données rendues. */
+    subject?: string;
+}
+/** Un outil tel que `tools/list` le publie — sans son implémentation. */
+export interface IMcpToolDefinition {
+    /**
+     * Identifiant d'appel. Forme admise : `[a-zA-Z0-9_-]{1,64}`.
+     *
+     * Ce nom ne reste pas dans le serveur — il voyage jusque dans le contexte du
+     * modèle. Un nom hors forme n'échoue pas franchement : il produit des appels
+     * que rien ne résout.
+     */
+    name: string;
+    /**
+     * ⭐ **Le premier critère de déclenchement de l'outil**, avant toute
+     * considération technique. Un modèle n'appelle pas ce qu'il ne comprend pas :
+     * dire ce que l'outil REND et QUAND s'en servir, pas seulement son nom.
+     */
+    description: string;
+    /** Schéma JSON des arguments attendus. */
+    inputSchema: Record<string, unknown>;
+}
+/**
+ * Un outil exécutable : ce que `tools/list` publie, plus ce qui répond.
+ *
+ * C'est le contrat qu'un module implémente pour ajouter un outil à la porte MCP
+ * de son application. Le handler ne reçoit QUE les arguments de l'agent : tout
+ * ce dont il a besoin par ailleurs (services, kernel, connexions) est capturé
+ * par fermeture au moment de la déclaration — le déclarant est un module, il a
+ * déjà tout sous la main.
+ *
+ * @example
+ * ```ts
+ * import { Module, mcpText, type IMcpTool } from "nodefony";
+ *
+ * class Shop extends Module {
+ *   getMcpTools(): IMcpTool[] {
+ *     return [{
+ *       name: "shop_stock",
+ *       description:
+ *         "Stock réel d'une référence produit. À utiliser avant de proposer " +
+ *         "une commande — la réponse vient de la base, pas d'un cache.",
+ *       inputSchema: {
+ *         type: "object",
+ *         properties: { sku: { type: "string", description: "Référence" } },
+ *         required: ["sku"],
+ *       },
+ *       handler: async (args) => mcpText(await this.stock(String(args.sku))),
+ *     }];
+ *   }
+ * }
+ * ```
+ */
+export interface IMcpTool extends IMcpToolDefinition {
+    /**
+     * Scopes OAuth exigés — **tous**, pas au moins un.
+     *
+     * Absent = outil public, servi à qui atteint la porte. Présent, l'outil est
+     * **retenu** tant que l'appelant ne les présente pas : il n'apparaît pas dans
+     * `tools/list` ET n'est pas appelable en le nommant — un catalogue filtré qui
+     * resterait appelable ne serait qu'un rideau.
+     *
+     * La spec le permet explicitement (`server/tools`) : le jeu d'outils « MAY
+     * vary by the authorization presented on the request — for example, returning
+     * only the tools the caller's granted scopes permit ». Elle interdit en
+     * revanche de le faire varier PAR CONNEXION : c'est pourquoi la décision se
+     * prend sur les identifiants de la requête, jamais sur un état retenu.
+     */
+    scopes?: readonly string[];
+    /**
+     * Exige une identité prouvée, sans scope particulier.
+     *
+     * Utile quand l'outil filtre lui-même ce qu'il rend selon
+     * {@link IMcpCaller.subject} — « mes commandes », « mes tâches ». Déclarer
+     * des {@link IMcpTool.scopes} l'implique déjà.
+     */
+    requiresAuth?: boolean;
+    /**
+     * Implémentation. Un échec métier se rend en `isError`, pas en exception.
+     *
+     * Le second paramètre porte l'appelant ÉTABLI : un outil authentifié doit
+     * pouvoir borner ce qu'il rend à son sujet, et pas seulement décider s'il
+     * répond. Un handler qui l'ignore reste parfaitement valide.
+     */
+    handler: (args: Record<string, unknown>, caller: IMcpCaller) => IMcpToolResult | Promise<IMcpToolResult>;
+}

package/dist/types/types/IModule.d.ts

@@ -0,0 +1,73 @@
+import type { IService } from "./IService.js";
+import type { IKernel } from "./IKernel.js";
+import type { JSONObject } from "./globals.js";
+import type { IMcpTool } from "./IMcpTool.js";
+/**
+ * Constructeur générique de controller — équivalent au type historique
+ * `TypeController<T>` mais exposé via le contract public IModule.
+ * Permet aux consommateurs (framework, http, security) de typer leurs
+ * controllers sans que le core dépende de @nodefony/framework.
+ */
+export type IControllerConstructor<T = unknown> = new (...args: any[]) => T;
+export interface PackageJson {
+    name: string;
+    version: string;
+    description?: string;
+    main?: string;
+    module?: string;
+    types?: string;
+    scripts?: Record<string, string>;
+    repository?: {
+        type: string;
+        url: string;
+    };
+    keywords?: string[];
+    author?: string;
+    license?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    [key: string]: unknown;
+}
+/**
+ * Contrat public d'un module nodefony.
+ * Module.ts implémente cette interface.
+ *
+ * Types Rollup/RollupWatcher/Controller typés unknown — dépendances externes
+ * non disponibles ici sans créer des imports circulaires ou des couplages forts.
+ */
+export interface IModule extends IService {
+    path: string;
+    isApp: boolean;
+    package?: PackageJson;
+    onKernelRegister?(): Promise<this>;
+    onKernelBoot?(): Promise<this>;
+    onKernelReady?(): Promise<this>;
+    init?(kernel?: IKernel): Promise<this>;
+    addService(service: unknown, ...args: any[]): Promise<IService>;
+    loadService(service: string, ...args: unknown[]): Promise<IService>;
+    getDependencies(): string[];
+    getController<T = unknown>(name: string): IControllerConstructor<T>;
+    getControllers<T = unknown>(): Record<string, IControllerConstructor<T>>;
+    getServiceNames(): string[];
+    /**
+     * Outils que ce module ajoute à la porte MCP de l'application.
+     *
+     * Optionnel et **lu à la demande** — jamais au boot : un serveur MCP les
+     * ramasse au moment de servir `tools/list`, ce qui ne coûte rien tant que
+     * personne n'appelle, et rend la liste toujours fraîche. Le module capture par
+     * fermeture ce dont ses handlers ont besoin (`this`, ses services).
+     *
+     * Une déclaration qui lève, rend autre chose qu'un tableau, porte un nom hors
+     * forme ou déjà pris est ÉCARTÉE avec un motif journalisé — jamais en silence,
+     * sinon son auteur chercherait la faute dans un handler jamais appelé.
+     */
+    getMcpTools?(): IMcpTool[];
+    configSchema(): unknown | null;
+    getPackageJson(cwd?: string): Promise<PackageJson>;
+    getModuleName(): string | undefined;
+    getModuleVersion(): string | undefined;
+    install(force?: boolean): Promise<number | Error>;
+    outdated(): Promise<number | Error>;
+    loadJson(url: string, cwd?: string): Promise<JSONObject>;
+}

package/dist/types/types/IModuleManifest.d.ts

@@ -0,0 +1,49 @@
+import type { TypeKernelOptions } from "../kernel/Kernel.js";
+/**
+ * Politique de chargement d'un module.
+ *
+ * - `mandatory` : socle — toujours chargé, non gatable (ex. http, framework, security, studio).
+ * - `optional`  : chargé sauf si une condition `when` le filtre (valeur par défaut).
+ * - `dev`       : chargé UNIQUEMENT hors production (outillage, démo, Studio dev).
+ *
+ * La politique **filtre** ; elle ne **réordonne jamais** — l'ordre de chargement
+ * reste l'ordre du tableau du manifeste (cf {@link IModuleManifest}).
+ */
+export type ModulePolicy = "mandatory" | "optional" | "dev";
+/**
+ * Entrée détaillée d'un manifeste de modules.
+ *
+ * @see project_module_loading_architecture (mémoire IA) pour la décision d'archi.
+ */
+export interface IModuleManifestEntry {
+    /** Nom du package/module à charger (résolu par `import()` dynamique). */
+    name: string;
+    /** Politique de chargement. Défaut : `"optional"`. */
+    policy?: ModulePolicy;
+    /**
+     * Garde de chargement évaluée sur la config fusionnée du kernel. Renvoie `false`
+     * → le module est ignoré (non importé = 0 coût boot/mémoire). Ex. ne charger
+     * `@nodefony/drizzle` que si `config.orm?.driver === "drizzle"`.
+     */
+    when?: (config: TypeKernelOptions) => boolean;
+    /**
+     * Config colocalisée du module (forme `use(name, config)`). Le Kernel la
+     * deep-merge sous la config DEFAULT du module à `onPreRegister`, avant la
+     * validation Zod du module. Remplace les clés legacy `module-<nom>`.
+     */
+    config?: Record<string, unknown>;
+}
+/**
+ * Manifeste déclaratif des modules d'une application Nodefony, exposé via
+ * `config.modules`. Le Kernel en est le **seul orchestrateur** : il lit cette
+ * liste, la filtre (policy + `when` + environnement) et charge les modules en
+ * série à `onPreRegister`.
+ *
+ * **Liste ORDONNÉE** : la position dans le tableau = ordre (= priorité) de
+ * chargement. Choix volontaire — l'ordre porte des invariants réels (realtime
+ * après framework, frontend avant ses consumers, documentation avant studio).
+ * `policy`/`when` ne font que filtrer ; ils ne réordonnent pas.
+ *
+ * Une `string` nue équivaut à `{ name, policy: "optional" }`.
+ */
+export type IModuleManifest = (string | IModuleManifestEntry)[];

package/dist/types/types/IPage.d.ts

@@ -0,0 +1,119 @@
+/**
+ * **LE contrat de pagination unique de Nodefony.** Tous les stores, toutes les API
+ * (présents et futurs) paginent avec ce type — c'est un standard de développement,
+ * jamais une pagination maison au cas par cas.
+ *
+ * Une requête HTTP se traduit en `IPageQuery` par `parsePageQuery(source)` — une
+ * fonction **pure**, agnostique de la provenance (query string aujourd'hui, corps
+ * d'une requête `QUERY` demain). C'est le seul traducteur : un data plane qui
+ * relit `request.query` lui-même refabrique un dialecte.
+ *
+ * Deux modes, **un seul vocabulaire** :
+ * - **offset** (`offset`) — navigation par page directe, pour les backends qui la
+ *   font nativement (SQL `LIMIT/OFFSET`, Mongo `skip/limit`, fichier, mémoire).
+ * - **curseur** (`cursor`) — navigation « après ce jeton », pour les backends sans
+ *   offset fiable (Redis `SCAN`) ou les flux ordonnés (journal d'audit). Un seul des
+ *   deux est utilisé selon ce que le store sait faire ; le store le déclare.
+ *
+ * Les **filtres spécifiques** à un store (rôle, catégorie d'audit, critère ORM…) ne
+ * vivent pas ici : chaque store **étend** ce type (`interface XQuery extends
+ * IPageQuery { … }`), pour que le socle reste un contrat pur et partagé.
+ */
+export interface IPageQuery {
+    /** Taille de page — obligatoire (jamais « tout »). */
+    limit: number;
+    /**
+     * Décalage depuis le début de la collection filtrée (mode **offset**). Défaut `0`.
+     * Mutuellement exclusif avec {@link IPageQuery.cursor} : un backend n'expose qu'un mode.
+     */
+    offset?: number;
+    /**
+     * Jeton de page (mode **curseur**) : ne renvoyer que les éléments situés « après »
+     * lui dans l'ordre du store. Obtenu du {@link IPage.nextCursor} de la page précédente.
+     */
+    cursor?: string;
+    /**
+     * Tri : couples `[champ, sens]`. Format **tableau** (une clé d'objet inconnue serait
+     * silencieusement ignorée). Champs autorisés = définis par le store.
+     */
+    order?: Array<[string, "ASC" | "DESC"]>;
+    /**
+     * Renvoyer le total exact ({@link IPage.total}) ou non. `true` par défaut.
+     * `false` = mode « Slice » : on saute le `COUNT` coûteux, {@link IPage.hasNext} suffit.
+     */
+    withTotal?: boolean;
+    /**
+     * Recherche plein-texte best-effort — le **champ** ciblé et la sémantique (préfixe /
+     * sous-chaîne / casse) sont définis par chaque store et documentés côté store.
+     */
+    q?: string;
+    /**
+     * **RÉSERVÉ multi-tenant** — slot du contrat pour le scoping par tenant, appliqué
+     * **au niveau du store** le jour du chantier tenant.
+     *
+     * @remarks ⚠️ **Non appliqué aujourd'hui** : le passer n'a aucun effet de filtrage.
+     *   Présent dès maintenant pour ne pas re-changer la signature d'un contrat public
+     *   propagé à tous les stores plus tard.
+     */
+    tenantId?: string | null;
+}
+/**
+ * **Une capacité de tri se DÉCLARE** — le socle commun à tout ce qui rend des
+ * pages triables (stores de sessions, de jetons, d'endpoints, dépôts
+ * d'utilisateurs…).
+ *
+ * Cette interface existe pour qu'il n'y ait **qu'une** forme à connaître : le
+ * nom de la propriété, sa nullabilité et sa sémantique sont écrits ici une fois,
+ * au lieu d'être redéclarés — et de diverger — dans chaque contrat de store.
+ *
+ * Le mécanisme, identique pour toutes les ressources :
+ * 1. le store **déclare** ce qu'il sait trier, en vocabulaire public ;
+ * 2. le data plane le **demande** et le passe en allowlist à `parsePageQuery` ;
+ * 3. tout `?order=` hors de cette liste est refusé en **400** — jamais accepté
+ *    puis ignoré en silence.
+ *
+ * D'où la conséquence utile : **le refus est gratuit**. Un backend qui ne sait
+ * pas trier (un `SCAN` Redis n'a aucun ordre global) laisse simplement la
+ * propriété absente, et rien de plus n'est à écrire pour que le tri y soit
+ * refusé. Les capacités PEUVENT donc être inégales d'un backend à l'autre —
+ * elles sont alors annoncées, jamais simulées.
+ *
+ * ⚠️ Là où un backend compose du SQL à la main, cette liste est **aussi une
+ * garde de sécurité** : un nom de colonne ne se lie pas en paramètre, il se
+ * concatène. Voir `pickOrder`, qui l'applique.
+ */
+export interface ISortableSource {
+    /**
+     * Champs triables, en **noms publics** (ceux de l'URL), ou absent si ce
+     * backend ne sait pas trier.
+     */
+    readonly sortableFields?: readonly string[];
+}
+/**
+ * Une **page** de résultats — la sortie unique de toute pagination Nodefony.
+ *
+ * `total` présent = mode **Page** (on a compté) ; absent = mode **Slice**. `hasNext`
+ * est fiable dans les deux cas. `nextCursor` n'est posé que par les backends **curseur**.
+ *
+ * @typeParam T - type des éléments de la page.
+ */
+export interface IPage<T> {
+    /** Les éléments de la page (au plus `limit`). */
+    items: T[];
+    /**
+     * Total exact de la collection filtrée — présent si {@link IPageQuery.withTotal}
+     * n'est pas `false` **et** que le backend sait compter à coût raisonnable.
+     */
+    total?: number;
+    /** Taille de page demandée (écho de {@link IPageQuery.limit}). */
+    limit: number;
+    /** Décalage de cette page (mode offset ; absent en mode curseur). */
+    offset?: number;
+    /** `true` s'il existe au moins un élément au-delà de cette page. */
+    hasNext: boolean;
+    /**
+     * Jeton de la page suivante (mode **curseur**) — à repasser en
+     * {@link IPageQuery.cursor}. `null` = fin. Absent = pagination par offset.
+     */
+    nextCursor?: string | null;
+}

package/dist/types/types/IService.d.ts

@@ -0,0 +1,62 @@
+import type { IContainer } from "./IContainer.js";
+import type { DynamicParam } from "../Container.js";
+import type Event from "../Event.js";
+import type { EventDefaultInterface } from "../Event.js";
+import type Pdu from "../syslog/Pdu.js";
+import type { Severity, Msgid, Message, Pci } from "../syslog/Pdu.js";
+import type Syslog from "../syslog/Syslog.js";
+import type { SyslogDefaultSettings, conditionsInterface } from "../syslog/Syslog.js";
+import type { IKernel } from "./IKernel.js";
+import type { DebugType, EnvironmentType } from "./globals.js";
+export type EventListener = (...args: any[]) => void;
+export interface DefaultOptionsService extends EventDefaultInterface {
+    events?: {
+        nbListeners: number;
+    };
+    syslog?: SyslogDefaultSettings;
+}
+/**
+ * Contrat public de tout service nodefony.
+ * Kernel, Module, Controller, adapters ORM — tous implémentent IService.
+ */
+export interface IService {
+    readonly name: string;
+    readonly options: DefaultOptionsService;
+    readonly container: IContainer | null;
+    readonly kernel: IKernel | null;
+    readonly syslog: Syslog | null;
+    /** undefined si notificationsCenter=false passé au constructeur, ou après clean() */
+    readonly notificationsCenter: Event | undefined;
+    getName(): string;
+    initSyslog(environment?: EnvironmentType, debug?: DebugType, options?: conditionsInterface): ReturnType<Syslog["init"]> | null;
+    clean(syslog?: boolean): void;
+    log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): Pdu;
+    logger(pci: Pci, ...args: unknown[]): void;
+    trace(pci: Pci, ...args: unknown[]): void;
+    get<T>(name: string): T | null;
+    set<T>(name: string, obj: T): void;
+    remove(name: string): boolean;
+    has(name: string): boolean;
+    getParameters(name: string): DynamicParam | null;
+    setParameters<T>(name: string, ele: T): DynamicParam | null;
+    on(eventName: string | symbol, listener: EventListener): this;
+    once(eventName: string | symbol, listener: EventListener): this;
+    off(eventName: string | symbol, listener: EventListener): this;
+    emit(eventName: string | symbol, ...args: unknown[]): boolean;
+    fire(eventName: string | symbol, ...args: unknown[]): boolean;
+    emitAsync(eventName: string | symbol, ...args: unknown[]): Promise<unknown>;
+    fireAsync(eventName: string | symbol, ...args: unknown[]): Promise<unknown>;
+    addListener(eventName: string | symbol, listener: EventListener): this;
+    removeListener(eventName: string | symbol, listener: EventListener): this;
+    removeAllListeners(eventName?: string | symbol): this;
+    prependListener(eventName: string | symbol, listener: EventListener): this;
+    prependOnceListener(eventName: string | symbol, listener: EventListener): this;
+    listen(eventName: string | symbol, listener: EventListener): (...args: unknown[]) => boolean;
+    settingsToListen(localSettings: EventDefaultInterface, context: object): void;
+    eventNames(): (string | symbol)[];
+    listenerCount(eventName: string | symbol, listener?: EventListener): number;
+    listeners(eventName: string | symbol): EventListener[];
+    rawListeners(eventName: string | symbol): EventListener[];
+    getMaxListeners(): number;
+    setMaxListeners(n: number): this;
+}

package/dist/types/types/ISyslog.d.ts

@@ -0,0 +1,58 @@
+import type Pdu from "../syslog/Pdu.js";
+import type { Severity, Msgid, Message, Pci } from "../syslog/Pdu.js";
+import type { DebugType, EnvironmentType } from "./globals.js";
+import type { ITransport } from "./ITransport.js";
+import type { SyslogDefaultSettings, conditionsInterface, CallbackFunction, WrapperResult } from "../syslog/Syslog.js";
+export interface ISyslog {
+    settings: SyslogDefaultSettings;
+    readonly ringStack: Pdu[];
+    /** Capacité MAX du ring buffer (plafond `maxStack`). */
+    readonly bufferCapacity: number;
+    /** `true` si les Pdu sont stockés dans le ring (relecture mémoire active). */
+    readonly ringEnabled: boolean;
+    /** Active/désactive le stockage mémoire (ring) à chaud — outil avancé. */
+    setRingEnabled(enabled: boolean): boolean;
+    /** `true` si la diffusion temps réel (`nodefony:syslog`) est active. */
+    readonly streamEnabled: boolean;
+    /** Active/désactive la diffusion temps réel à chaud (onglet Live). */
+    setStreamEnabled(enabled: boolean): boolean;
+    burstPrinted: number;
+    missed: number;
+    invalid: number;
+    valid: number;
+    /** Cumul monotone des logs de sévérité 0–3 (ERROR/CRITIC/ALERT/EMERGENCY). */
+    errorTotal: number;
+    /** Sous-ensemble CRITIQUE (sévérité 0–2 : CRITIC/ALERT/EMERGENCY). */
+    criticTotal: number;
+    start: number;
+    async: boolean;
+    init(environment: EnvironmentType, debug?: DebugType, options?: conditionsInterface): void;
+    clean(): this;
+    reset(): this;
+    clearLogStack(): void;
+    log(payload: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): Pdu;
+    error(data: Pci): Pdu;
+    warn(data: Pci): Pdu;
+    info(data: Pci): Pdu;
+    debug(data: Pci): Pdu;
+    trace(data: Pci, ...args: unknown[]): Pdu;
+    print(...args: Pci[]): Pdu;
+    logMultiple(severity: Severity, ...args: Pci[]): Pdu;
+    pushStack(pdu: Pdu): number;
+    getLogStack(start?: number, end?: number, condition?: conditionsInterface): Pdu[] | Pdu;
+    getLogs(conditions: conditionsInterface, stack?: Pdu[] | null): Pdu[];
+    logToJson(conditions: conditionsInterface, stack?: Pdu[] | null): string;
+    loadStack(stack: Pdu[] | string, doEvent?: boolean, beforeConditions?: ((pdu: Pdu, stackItem: Pdu) => void) | null): Pdu[];
+    filter(conditions: conditionsInterface, callback: CallbackFunction): void;
+    listenWithConditions(conditions: conditionsInterface, callback: CallbackFunction): void;
+    addTransport(transport: ITransport): this;
+    removeTransport(transport: ITransport): this;
+    /** Liste polymorphe des transports d'écriture (axe WRITE) + état `enabled`. */
+    listTransports(): {
+        name: string;
+        enabled: boolean;
+    }[];
+    /** Active/désactive un transport d'écriture à chaud, par nom (dev/diagnostic). */
+    setTransportEnabled(name: string, enabled: boolean): boolean;
+}
+export type { WrapperResult };

package/dist/types/types/ITransport.d.ts

@@ -0,0 +1,5 @@
+import type Pdu from "../syslog/Pdu.js";
+export interface ITransport {
+    readonly name: string;
+    send(pdu: Pdu): Promise<void>;
+}

package/dist/types/types/globals.d.ts

@@ -0,0 +1,47 @@
+export interface nodefonyOptions {
+    [key: string]: any;
+}
+declare global {
+    interface Error {
+        /**
+         * Sérialisation JSON d'une erreur — POSÉE AU RUNTIME par `Error.ts` sur
+         * `Error.prototype`, donc présente sur toute erreur qui traverse Nodefony.
+         *
+         * Déclarée **optionnelle**, et c'est délibéré : la rendre obligatoire
+         * augmente le type standard `Error` de tout le graphe, et rend alors
+         * **incompilable toute classe tierce qui écrit `implements Error`** — elle
+         * n'a aucune raison de connaître une méthode de Nodefony. Constaté sur
+         * `HttpErrorResponse` d'`@angular/common` (TS2420), qui suffisait à rendre
+         * `@angular/*` inutilisable dans un graphe de types Nodefony. Le seul
+         * appelant du dépôt passe déjà par `nodefonyError`, qui la déclare en
+         * propre : l'obligation ne servait personne et coûtait l'interopérabilité.
+         */
+        toJSON?(): Record<string, any>;
+    }
+}
+/**
+ * Modes MOTEUR du kernel — l'axe qui pilote l'optimisation du runtime.
+ *
+ * `staging` n'en fait pas partie : un staging tourne « comme la production »
+ * (mêmes optimisations) et se distingue par son axe de DÉPLOIEMENT, pas par son
+ * moteur. Cet axe-là est `APP_ENV`/`NF_ENV` (string libre : `staging`,
+ * `canary`, `prod-eu`…), lu par `loadEnv` (→ `.env.staging`) et exposé par
+ * `ConfigContext.appEnv` — il reste entier.
+ *
+ * `test` n'en fait pas partie non plus : c'est une valeur de `NODE_ENV` que le
+ * kernel normalise en `runtimeEnv` (→ `ConfigContext.isTest`), jamais un mode moteur.
+ */
+declare enum environment {
+    dev,
+    development,
+    prod,
+    production
+}
+export type EnvironmentType = keyof typeof environment;
+export type DebugType = boolean | string | string[];
+type JSONArray = Array<JSONValue>;
+type JSONValue = string | number | boolean | JSONObject | JSONArray;
+export interface JSONObject {
+    [x: string]: JSONValue;
+}
+export {};