nodefony 7.0.2 → 10.0.0-alpha.2

package/bin/nodefony

@@ -1,87 +1,2185 @@
 #!/usr/bin/env node
- //--inspect-brk
-"use strict;";
-const path = require("path");
-const fs = require("fs");
-
-const nodefony = function () {
-  let error = [];
-  try {
-    fs.lstatSync(path.resolve(".core"));
-    return require(path.resolve("src", "nodefony"));
-  } catch (e) {
-    if (e && e.name && e.name === "nodefonyError") {
-      throw e;
-    }
-    error.push(e);
-  }
-  try {
-    let res = require(path.resolve(process.cwd(), "node_modules", "nodefony"));
-    let ret = null;
-    try {
-      ret = require("nodefony");
-    } catch (e) {
-      if (e && e.name && e.name === "nodefonyError") {
-        throw e;
-      }
-      error.push(e);
-    }
-    if (ret && (ret.version !== res.version)) {
-      res.warning = `Module nodefony global = ${ret.version}\nModule nodefony local = ${res.version}`;
-    }
-    return res;
-  } catch (e) {
-    if (e && e.name && e.name === "nodefonyError") {
-      throw e;
-    }
-    error.push(e);
-  }
-  try {
-    return require("nodefony");
-  } catch (e) {
-    if (e && e.name && e.name === "nodefonyError") {
-      throw e;
-    }
-    error.push(e);
-  }
-  try {
-    return require(path.resolve(__dirname, ".."));
-  } catch (e) {
-    if (e && e.name && e.name === "nodefonyError") {
-      throw e;
-    }
-    error.push(e);
-  }
-  try {
-    const globalPath = path.resolve(process.argv[1], '..', '..', 'lib', 'node_modules');
-    return require(path.resolve(globalPath, "nodefony"));
-  } catch (e) {
-    error.push(e);
-    console.trace(error);
-    throw new Error("Module nodefony not found try npm -g install nodefony");
-  }
-}();
-
-const isElectronDev = function () {
-  return process.mainModule.filename.indexOf('app.asar') === -1;
-};
-
-if (nodefony.isElectron) {
-  if (!isElectronDev()) {
-    process.chdir(nodefony.isElectron.app.getAppPath());
-  }
-  nodefony.isElectron.app.on('ready', () => {
-    try {
-      return new nodefony.cliStart();
-    } catch (e) {
-      throw e;
-    }
-  });
-  module.exports = nodefony.isElectron;
-} else {
-  try {
-    module.exports = new nodefony.cliStart();
-  } catch (e) {
-    throw e;
-  }
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { exit } from "node:process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { inspect, styleText } from "node:util";
+import { EventEmitter } from "node:events";
+//#region src/cli/projectRoot.ts
+/**
+* Racine du PROJET Nodefony courant (app générée / app utilisateur) : remonte
+* depuis `from` jusqu'au premier dossier portant `nodefony.config.ts` +
+* `package.json`.
+*
+* Deux consommateurs, une seule définition de « où commence l'app » :
+* - les scaffolds IN-PROJECT (`create controller|module|entity`) — par
+*   opposition à `create app` qui crée un dossier neuf ;
+* - le **lanceur** (`bin/nodefony`), qui délègue au CLI de l'app quand il en
+*   trouve un (cf `../bin/resolveLocalCli`).
+*
+* Vit ici (module sans dépendance, `node:fs`/`node:path` seuls) et pas dans
+* `scaffold/engine.ts` : le bundle du binaire importerait alors `eta` et tout le
+* moteur de templates, payés à CHAQUE invocation du CLI.
+*
+* @param from - dossier de départ (typiquement `process.cwd()`).
+* @returns racine absolue, ou `null` hors projet.
+*/
+function findProjectRoot(from) {
+	let dir = path.resolve(from);
+	for (;;) {
+		if (existsSync(path.join(dir, "nodefony.config.ts")) && existsSync(path.join(dir, "package.json"))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
 }
+//#endregion
+//#region src/config/reservedEnv.ts
+/**
+* Le catalogue des variables réservées, indexé par nom.
+*
+* Ajouter une entrée ici est OBLIGATOIRE dès qu'un code du framework écrit une
+* `NF_*` dans l'environnement d'un process : sans elle, la variable ressort en
+* « inconnue » chez tout utilisateur qui lance la commande au mauvais moment.
+*/
+const RESERVED_ENV = Object.freeze({
+	NF_CLI_DELEGATED: {
+		name: "NF_CLI_DELEGATED",
+		role: "posée par le lanceur du CLI quand il passe la main au `nodefony` du projet (garde anti-boucle)"
+	},
+	NF_CLI_DEBUG: {
+		name: "NF_CLI_DEBUG",
+		role: "trace la décision du lanceur du CLI sur la sortie d'erreur"
+	},
+	NF_MODE_START: {
+		name: "NF_MODE_START",
+		role: "posée par la commande de démarrage — le mode par lequel l'application a été lancée"
+	},
+	NF_CLUSTER: {
+		name: "NF_CLUSTER",
+		role: "posée par le maître de grappe dans chaque worker"
+	},
+	NF_MCP_TOKEN: {
+		name: "NF_MCP_TOKEN",
+		role: "jeton d'accès au serveur MCP de l'application, lu par le client de l'agent (`nodefony ai:mcp --auth`)"
+	},
+	NF_ENV: {
+		name: "NF_ENV",
+		role: "environnement de déploiement quand il diffère du mode runtime (`APP_ENV` gagne)"
+	},
+	NF_START: {
+		name: "NF_START",
+		role: "point d'entrée que le Kernel démarre, quand il ne doit pas être celui du projet"
+	},
+	NF_WORKERS: {
+		name: "NF_WORKERS",
+		role: "nombre de workers de la grappe (`nodefony cluster -w N`, en variable)"
+	},
+	NF_CLUSTER_PROBE: {
+		name: "NF_CLUSTER_PROBE",
+		role: "coupe la sonde du maître de grappe quand elle vaut `0`"
+	},
+	NF_POD_NAME: {
+		name: "NF_POD_NAME",
+		role: "nom du pod, dont se dérive l'identité d'origine du backplane temps réel"
+	},
+	NF_INSTANCE_ID: {
+		name: "NF_INSTANCE_ID",
+		role: "identifiant d'instance rendu par le plan d'administration (défaut : le pid)"
+	},
+	NF_DEV_CHILD: {
+		name: "NF_DEV_CHILD",
+		role: "posée par le superviseur de développement dans l'application qu'il relance"
+	},
+	NF_DEV_PORTS: {
+		name: "NF_DEV_PORTS",
+		role: "ports que le superviseur de développement doit libérer, imposés par l'opérateur"
+	},
+	NF_BOOT_TIMEOUT_MS: {
+		name: "NF_BOOT_TIMEOUT_MS",
+		role: "délai au-delà duquel un démarrage est déclaré perdu"
+	},
+	NF_BOOT_WARN_MS: {
+		name: "NF_BOOT_WARN_MS",
+		role: "délai au-delà duquel un démarrage lent est signalé"
+	},
+	NF_KERNEL_TRACE_FILE: {
+		name: "NF_KERNEL_TRACE_FILE",
+		role: "fichier où le Kernel écrit sa trace de démarrage (diagnostic)"
+	},
+	NF_NO_TTY: {
+		name: "NF_NO_TTY",
+		role: "force le rendu non interactif, quel que soit le terminal"
+	},
+	NF_PERF_PROBE: {
+		name: "NF_PERF_PROBE",
+		role: "arme la sonde de performance du pipeline HTTP"
+	},
+	NF_ORM_FLOW: {
+		name: "NF_ORM_FLOW",
+		role: "arme la sonde de flux de l'ORM"
+	},
+	NF_ORM_HEARTBEAT_MS: {
+		name: "NF_ORM_HEARTBEAT_MS",
+		role: "période du battement de cœur qui surveille les connecteurs de l'ORM"
+	},
+	NF_REALTIME_DRIVER: {
+		name: "NF_REALTIME_DRIVER",
+		role: "pilote du backplane temps réel (mémoire, Redis…)"
+	},
+	NF_REALTIME_BACKPLANE_SECRET: {
+		name: "NF_REALTIME_BACKPLANE_SECRET",
+		role: "secret qui scelle les enveloppes du backplane temps réel"
+	},
+	NF_REALTIME_BACKPLANE_NAMESPACE: {
+		name: "NF_REALTIME_BACKPLANE_NAMESPACE",
+		role: "espace de noms du backplane — ce qui cloisonne deux applications sur un même bus"
+	}
+});
+//#endregion
+//#region src/bin/resolveLocalCli.ts
+/** Variable de garde : le CLI délégué ne délègue pas à son tour (anti-boucle). */
+const DELEGATED_ENV = RESERVED_ENV.NF_CLI_DELEGATED.name;
+/** Trace la décision du lanceur sur stderr quand la variable vaut `1`. */
+const DEBUG_ENV = RESERVED_ENV.NF_CLI_DEBUG.name;
+/** Lit un `package.json` — `null` si absent ou illisible (jamais de throw). */
+function readPackageJson(dir) {
+	try {
+		return JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+	} catch {
+		return null;
+	}
+}
+/** Chemin déclaré par le champ `bin` d'un package.json (forme string ou map). */
+function binEntry(pkg) {
+	const bin = pkg.bin;
+	if (typeof bin === "string") return bin;
+	if (bin && typeof bin === "object") {
+		const entry = bin.nodefony;
+		if (typeof entry === "string") return entry;
+	}
+	return null;
+}
+/** `realpath` tolérant — retombe sur le chemin brut si la cible n'existe pas. */
+function realOrSelf(p) {
+	try {
+		return realpathSync(p);
+	} catch {
+		return p;
+	}
+}
+/**
+* Décide quel CLI Nodefony doit réellement s'exécuter : **celui de l'application**
+* dès qu'on se trouve dans un projet, sinon celui qu'on a lancé.
+*
+* Pourquoi cette règle : le binaire installé en global (`npm i -g nodefony`) est
+* la porte d'entrée du framework (c'est lui qui fait `create app`), mais sa version
+* dérive de celle des applications déjà générées. Exécuter le CLI global **dans**
+* une app reviendrait à piloter cette app avec un autre framework que celui de ses
+* `node_modules` : configs, scaffolds et commandes de module peuvent diverger.
+* La version qui fait autorité est donc toujours celle de l'application — comme le
+* wrapper d'un projet (`gradlew`, `mvnw`) prime sur l'outil de la machine.
+*
+* Fonction PURE (aucun effet de bord, aucun `process`) : les entrées sont passées
+* explicitement pour que la décision soit testable sans lancer de binaire.
+*
+* @param input.cwd - dossier courant, point de départ de la recherche du projet.
+* @param input.selfDir - racine du paquet `nodefony` en train de s'exécuter.
+* @param input.env - environnement (lu pour la garde anti-boucle).
+* @returns la décision : `delegate` = chemin du binaire à charger, ou `null` pour soi.
+*/
+function resolveLocalCli(input) {
+	if ((input.env ?? {})[DELEGATED_ENV]) return {
+		delegate: null,
+		reason: "already-delegated"
+	};
+	const projectRoot = findProjectRoot(input.cwd);
+	if (!projectRoot) return {
+		delegate: null,
+		reason: "no-project"
+	};
+	const localPkgDir = path.join(projectRoot, "node_modules", "nodefony");
+	const localPkg = existsSync(localPkgDir) ? readPackageJson(localPkgDir) : null;
+	if (!localPkg) return {
+		delegate: null,
+		reason: "no-local-cli",
+		detail: `${localPkgDir} absent`
+	};
+	if (realOrSelf(localPkgDir) === realOrSelf(input.selfDir)) return {
+		delegate: null,
+		reason: "same-package"
+	};
+	const rel = binEntry(localPkg);
+	if (!rel) return {
+		delegate: null,
+		reason: "local-cli-broken",
+		projectRoot,
+		detail: `le paquet nodefony de ${projectRoot} ne déclare aucun binaire (champ "bin")`
+	};
+	const localBin = path.resolve(localPkgDir, rel);
+	if (!existsSync(localBin)) return {
+		delegate: null,
+		reason: "local-cli-broken",
+		projectRoot,
+		detail: `le CLI du projet est déclaré mais absent : ${localBin} (paquet non construit ? \`npm install\` / \`npm run build\`)`
+	};
+	const version = (pkg) => typeof pkg?.version === "string" ? pkg.version : null;
+	return {
+		delegate: localBin,
+		reason: "local-cli",
+		projectRoot,
+		selfVersion: version(readPackageJson(input.selfDir)),
+		localVersion: version(localPkg)
+	};
+}
+//#endregion
+//#region src/colors.ts
+const VALID = /* @__PURE__ */ new Set([
+	"reset",
+	"bold",
+	"dim",
+	"italic",
+	"underline",
+	"inverse",
+	"strikethrough",
+	"black",
+	"red",
+	"green",
+	"yellow",
+	"blue",
+	"magenta",
+	"cyan",
+	"white",
+	"gray",
+	"blackBright",
+	"redBright",
+	"greenBright",
+	"yellowBright",
+	"blueBright",
+	"magentaBright",
+	"cyanBright",
+	"whiteBright",
+	"bgBlack",
+	"bgRed",
+	"bgGreen",
+	"bgYellow",
+	"bgBlue",
+	"bgMagenta",
+	"bgCyan",
+	"bgWhite",
+	"bgGray"
+]);
+/** Séquence ANSI de remise à zéro — exposée brute par `clc.reset` (parité cli-color). */
+const RESET = "\x1B[0m";
+/**
+* Construit une `ColorFn` figée pour la liste de styles donnée. Le Proxy ne
+* piège QUE l'accès de propriété (chaînage) — l'appel forward directement vers
+* la fonction cible (aucun surcoût de trap à l'invocation, hot path préservé).
+*/
+function make(styles) {
+	const apply = (s) => {
+		const str = String(s);
+		if (styles.length === 0) return str;
+		try {
+			return styleText(styles, str, { validateStream: false });
+		} catch {
+			return str;
+		}
+	};
+	return new Proxy(apply, { get(target, prop, receiver) {
+		if (prop === "reset") return RESET;
+		if (typeof prop === "string" && VALID.has(prop)) return make([...styles, prop]);
+		return Reflect.get(target, prop, receiver);
+	} });
+}
+const clc = make([]);
+//#endregion
+//#region src/kernel/checks/report.ts
+/**
+* L'ordre de lecture des familles — celui du sommaire ET du détail.
+*
+* L'ordre n'est pas cosmétique : la fraîcheur d'abord, parce qu'un build en
+* retard rend faux tout ce qui suit ; puis ce qui empêche de démarrer, qui
+* explique souvent le reste.
+*/
+const FAMILIES = [
+	"freshness",
+	"readiness",
+	"envCatalog",
+	"envTracked",
+	"deps",
+	"wiring",
+	"surface",
+	"dialect",
+	"guards",
+	"migrations",
+	"firewall",
+	"gating",
+	"verify",
+	"outdated"
+];
+/**
+* Les SOUS-RÈGLES de `readiness` — des contrôles à part entière, mais qui ne
+* sont pas des familles.
+*
+* Elles ont besoin de leur propre état d'exécution (leur silence peut ne rien
+* prouver : catalogue illisible, pas de dépôt git), sans quoi elles seraient
+* affichées en vert alors qu'elles n'ont rien regardé. Mais les compter comme
+* familles gonflerait le bilan de contrôles que le sommaire n'affiche pas.
+*
+* Une seule liste, dont TOUT le reste se dérive : quand la deuxième sous-règle
+* est arrivée, la condition `f !== "envCatalog"` était écrite en dur à trois
+* endroits — le compteur du bilan, le filtre du sommaire, et le dédoublonnage
+* des contrôles sautés.
+*/
+const SUBRULES = ["envCatalog", "envTracked"];
+/** `true` si cette famille est une sous-règle de `readiness`. */
+function isSubrule(family) {
+	return SUBRULES.includes(family);
+}
+FAMILIES.filter((f) => !isSubrule(f));
+//#endregion
+//#region src/Tools.ts
+const ObjProto = Object.prototype;
+const _toString = ObjProto.toString;
+const hasOwn = ObjProto.hasOwnProperty;
+const fnToString = hasOwn.toString;
+const ObjectFunctionString = fnToString.call(Object);
+const getProto = Object.getPrototypeOf;
+/** Alias direct de `Array.isArray` — exporté pour usage cohérent dans les modules. */
+const isArray = Array.isArray;
+/**
+* Vérifie qu'un objet est un "plain object" — `{}` ou `Object.create(null)`.
+*
+* Rejette les instances de classes, les `Array`, `Date`, `RegExp`, etc.
+* Implémentation alignée sur jQuery.isPlainObject (compatible cross-realm).
+*
+* @param obj - valeur à tester.
+* @returns `true` si l'objet vient directement de `Object` ou n'a pas de prototype.
+*/
+const isPlainObject = (obj) => {
+	if (!obj || _toString.call(obj) !== "[object Object]") return false;
+	const proto = getProto(obj);
+	if (!proto) return true;
+	const Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
+	return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
+};
+/**
+* Fusionne plusieurs objets dans une cible — API compatible `jQuery.extend`.
+*
+* Mode `shallow` (défaut) : copie les clés du dernier au premier source.
+* Mode `deep` (1er arg `true`) : récurse dans les plain objects et arrays.
+* Sécurité : ignore `__proto__`, `constructor`, `prototype` (anti prototype pollution).
+*
+* @param args - `[target, ...sources]` ou `[true, target, ...sources]` pour deep.
+* @returns la cible mutée (ou objet vide si appel à un seul argument).
+*
+* @example
+* ```ts
+* extend({ a: 1 }, { b: 2 });               // { a: 1, b: 2 }
+* extend(true, { a: { x: 1 } }, { a: { y: 2 } }); // { a: { x: 1, y: 2 } }
+* ```
+*/
+const extend = (...args) => {
+	let options, name, src, copy, copyIsArray = false, clone, target = args[0] || {}, i = 1, deep = false;
+	const { length } = args;
+	if (typeof target === "boolean") {
+		deep = target;
+		target = args[i] || {};
+		i++;
+	}
+	if (typeof target !== "object" && typeof target !== "function") target = {};
+	if (i === length) {
+		target = {};
+		i--;
+	}
+	for (; i < length; i++) if ((options = args[i]) != null) for (name in options) {
+		if (!hasOwn.call(options, name)) continue;
+		copy = options[name];
+		if (name === "__proto__" || name === "constructor" || name === "prototype" || target === copy) continue;
+		if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
+			src = target[name];
+			if (copyIsArray && !isArray(src)) clone = [];
+			else if (!copyIsArray && !isPlainObject(src)) clone = {};
+			else clone = src;
+			copyIsArray = false;
+			target[name] = extend(deep, clone, copy);
+		} else if (copy !== void 0) target[name] = copy;
+	}
+	return target;
+};
+globalThis.Buffer;
+//#endregion
+//#region src/Event.ts
+const regListenOn = /^on(.*)$/;
+/** Sentinelle de rejet interne au timeout d'{@link Event.emitAsyncGuarded} (jamais exposée). */
+const timeoutSentinel = Symbol("nodefony.emitAsyncGuarded.timeout");
+/**
+* Bus d'événements Nodefony — extension de Node.js {@link EventEmitter} avec
+* deux ajouts maison : `emitAsync` (await tous les listeners en séquence) et
+* `settingsToListen` (mapping config → listeners via convention `onXxx`).
+*
+* Utilisé par {@link Service} comme `notificationsCenter`. Une seule instance
+* peut être partagée entre plusieurs services — chaque service track ses
+* propres listeners pour les retirer proprement à `clean()`.
+*
+* @example Bus dédié
+* ```ts
+* const bus = new Event({ onReady: () => console.log("ready!") }, this);
+* bus.fire("onReady");
+* ```
+*
+* @example Bus partagé entre services
+* ```ts
+* const sharedBus = new Event();
+* new ServiceA(name, container, sharedBus);
+* new ServiceB(name, container, sharedBus);
+* ```
+*/
+var Event = class extends EventEmitter {
+	/**
+	* @param settings - objet de config dont les clés `onXxx` sont auto-bindées
+	*   comme listeners (via {@link settingsToListen}).
+	* @param context - `this` à bind sur les listeners auto-enregistrés.
+	* @param options - `nbListeners` surcharge la limite d'abonnés de Node.js ;
+	*   absent, c'est celle de Node qui s'applique (10), et le dépassement
+	*   signale une fuite probable. La valeur `0` vaut **illimité**, comme dans
+	*   `setMaxListeners` — un bus dont on SAIT qu'il portera beaucoup d'abonnés
+	*   se déclare ainsi, au lieu de subir un avertissement qui n'annonce rien.
+	*/
+	constructor(settings, context, options) {
+		super();
+		if (options?.nbListeners !== void 0) this.setMaxListeners(options.nbListeners);
+		if (settings) this.settingsToListen(settings, context);
+	}
+	/**
+	* Parcourt `localSettings` et enregistre chaque clé matchant `/^on(.*)$/`
+	* comme listener — convention héritée des composants WebComponent / config
+	* Nodefony historique. Utile pour wirer des hooks via config plate.
+	*
+	* @param localSettings - objet plat ; les clés `onReady`, `onClose`, etc.
+	*   sont prises comme noms d'événements ET comme listeners.
+	* @param context - si fourni, le listener est bindé sur ce contexte.
+	*/
+	settingsToListen(localSettings, context) {
+		for (const i of Object.keys(localSettings)) {
+			const res = regListenOn.exec(i);
+			if (!res) continue;
+			if (context) {
+				this.listen(context, res[0], localSettings[i]);
+				continue;
+			}
+			this.on(res[0], localSettings[i]);
+		}
+	}
+	/**
+	* Bind `listener` sur `context` puis l'enregistre. Renvoie une fonction
+	* dispatcher qui ré-émet l'événement avec ses propres args (façon trigger).
+	*
+	* @returns dispatcher `(...args) => this.emit(eventName, ...args)` — pratique
+	*   pour exposer un trigger sans donner accès au bus complet.
+	*/
+	listen(context, eventName, listener) {
+		if (typeof listener === "function") this.addListener(eventName, listener.bind(context));
+		return (...args) => this.emit(eventName, ...args);
+	}
+	/** Alias `emit` — émission synchrone (API EventEmitter standard). */
+	fire(eventName, ...args) {
+		return super.emit(eventName, ...args);
+	}
+	/**
+	* Émet et attend chaque listener en séquence (`await Reflect.apply` un par
+	* un). Différent de `emit` qui appelle synchroniquement sans attendre les
+	* Promises retournées.
+	*
+	* @returns tableau des valeurs résolues par chaque listener (ordre d'append),
+	*   ou `false` si aucun listener n'est attaché.
+	* @remarks Séquentiel par design — si tu veux Promise.all, fais un wrapper
+	*   au-dessus. La séquence garantit l'ordre prévisible des side-effects.
+	*/
+	async emitAsync(eventName, ...args) {
+		if (this.listenerCount(eventName) === 0) return false;
+		const handlers = this.rawListeners(eventName);
+		const result = [];
+		for (const handler of handlers) {
+			const r = Reflect.apply(handler, this, args);
+			result.push(r != null && typeof r.then === "function" ? await r : r);
+		}
+		return result;
+	}
+	/** Alias `emitAsync`. */
+	async fireAsync(eventName, ...args) {
+		return this.emitAsync(eventName, ...args);
+	}
+	/**
+	* Variante **gardée** de {@link emitAsync} : émet les listeners en SÉRIE (ordre
+	* préservé) mais isole chacun par un `try/catch` + un `timeout` optionnel, et
+	* COLLECTE les échecs au lieu de laisser le premier rejet faire sauter les
+	* suivants (ou un listener figé geler tout le reste).
+	*
+	* Ne décide d'AUCUNE politique (log, criticité, propagation) : c'est l'appelant
+	* qui tranche via `onListenerError` (continuer / arrêter) et `onListenerSlow`.
+	* Cette séparation MÉCANIQUE / POLITIQUE permet de réutiliser la garde hors boot
+	* en toute connaissance de cause.
+	*
+	* 🚨 **Coût** : quand `timeoutMs > 0`, 1 timer + 1 Promise de course PAR listener.
+	* Réservé au **boot / lifecycle / jobs** (cf `Kernel.fireLifecycle`) — appelé
+	* ≪ 1×/process. **JAMAIS dans le hot path HTTP/WS** : celui-ci garde `emitAsync`
+	* nu (aucun timer, aucune alloc par requête).
+	*
+	* @param eventName - événement à émettre.
+	* @param options - garde (timeout/seuil de lenteur) + callbacks de politique.
+	* @param args - arguments passés à chaque listener.
+	* @returns `{ results, errors, stopped }` (cf {@link IGuardedEmitResult}).
+	*/
+	async emitAsyncGuarded(eventName, options = {}, ...args) {
+		const results = [];
+		const errors = [];
+		if (this.listenerCount(eventName) === 0) return {
+			results,
+			errors,
+			stopped: false
+		};
+		const handlers = this.rawListeners(eventName);
+		const timeoutOption = options.timeoutMs ?? 0;
+		const perListener = typeof timeoutOption === "function";
+		const warnMs = options.warnMs ?? 0;
+		const measure = warnMs > 0;
+		for (let index = 0; index < handlers.length; index += 1) {
+			const handler = handlers[index];
+			const timeoutMs = perListener ? timeoutOption(handler, index) : timeoutOption;
+			const startedAt = measure ? Date.now() : 0;
+			let timedOut = false;
+			try {
+				const call = Promise.resolve(Reflect.apply(handler, this, args));
+				let value;
+				if (timeoutMs > 0) {
+					call.catch(() => {});
+					let timer;
+					try {
+						value = await Promise.race([call, new Promise((_, reject) => {
+							timer = setTimeout(() => {
+								timedOut = true;
+								reject(timeoutSentinel);
+							}, timeoutMs);
+							timer.unref?.();
+						})]);
+					} finally {
+						if (timer) clearTimeout(timer);
+					}
+				} else value = await call;
+				results.push(value);
+				if (measure && options.onListenerSlow) {
+					const durationMs = Date.now() - startedAt;
+					if (durationMs >= warnMs) options.onListenerSlow({
+						index,
+						listener: handler,
+						timedOut: false,
+						durationMs
+					});
+				}
+			} catch (caught) {
+				const durationMs = measure ? Date.now() - startedAt : 0;
+				const error = timedOut ? /* @__PURE__ */ new Error(`listener timeout après ${timeoutMs}ms`) : caught;
+				errors.push({
+					index,
+					error,
+					timedOut
+				});
+				if (options.onListenerError?.(error, {
+					index,
+					listener: handler,
+					timedOut,
+					durationMs
+				}) === true) return {
+					results,
+					errors,
+					stopped: true
+				};
+			}
+		}
+		return {
+			results,
+			errors,
+			stopped: false
+		};
+	}
+};
+//#endregion
+//#region src/syslog/Pdu.ts
+var SysLogSeverity = /* @__PURE__ */ function(SysLogSeverity) {
+	SysLogSeverity[SysLogSeverity["EMERGENCY"] = 0] = "EMERGENCY";
+	SysLogSeverity[SysLogSeverity["ALERT"] = 1] = "ALERT";
+	SysLogSeverity[SysLogSeverity["CRITIC"] = 2] = "CRITIC";
+	SysLogSeverity[SysLogSeverity["ERROR"] = 3] = "ERROR";
+	SysLogSeverity[SysLogSeverity["WARNING"] = 4] = "WARNING";
+	SysLogSeverity[SysLogSeverity["NOTICE"] = 5] = "NOTICE";
+	SysLogSeverity[SysLogSeverity["INFO"] = 6] = "INFO";
+	SysLogSeverity[SysLogSeverity["DEBUG"] = 7] = "DEBUG";
+	return SysLogSeverity;
+}(SysLogSeverity || {});
+const sysLogSeverity$1 = [
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7
+];
+const translateSeverity = function(severity = "INFO") {
+	if (typeof severity === "number") {
+		if (sysLogSeverity$1[severity] !== void 0) return sysLogSeverity$1[severity];
+		else throw new Error(`Not a valid nodefony syslog severity: ${severity}`);
+	} else if (SysLogSeverity[severity] !== void 0) return SysLogSeverity[severity];
+	else throw new Error(`Not a valid nodefony syslog severity: ${severity}`);
+};
+const sysLogSeverityObj = Object.entries(SysLogSeverity).reduce((acc, [key, value]) => {
+	acc[key] = value;
+	return acc;
+}, {});
+const severityNameMap = new Map(Object.entries(SysLogSeverity).filter(([, v]) => typeof v === "number").map(([k, v]) => [v, k]));
+const _gBuffer = globalThis.Buffer;
+const PID = globalThis.process?.pid ?? 0;
+const fastTypeOf = (value) => {
+	if (value === null) return null;
+	const t = typeof value;
+	if (t !== "object") return t;
+	if (Array.isArray(value)) return "array";
+	if (value instanceof Date) return "date";
+	if (value instanceof RegExp) return "RegExp";
+	if (value instanceof Error) return "Error";
+	if (_gBuffer?.isBuffer(value)) return "buffer";
+	return "object";
+};
+/**
+* Process Data Unit — entrée de log unitaire conforme RFC 5424.
+*
+* Une instance représente un événement de log dans le pipeline Syslog.
+* Stockée dans le `CircularBuffer` (O(1)) et diffusée aux transports
+* via l'event `onLog` du {@link Syslog}.
+*
+* @example
+* ```ts
+* const pdu = new Pdu("user logged in", "INFO", "AUTH", "USER_LOGIN", "user@example.com");
+* pdu.severity;      // 6
+* pdu.severityName;  // "INFO"
+* pdu.payload;       // "user logged in"
+* ```
+*
+* @remarks `pdu.severity` est numérique (RFC 5424) pour comparaisons rapides.
+*   `pdu.severityName` est la string (`"INFO"`, `"CRITIC"` — pas `"CRITICAL"`).
+*/
+let guid = 0;
+var Pdu = class Pdu {
+	payload;
+	uid;
+	severity;
+	timeStamp;
+	severityName;
+	typePayload;
+	moduleName;
+	msgid;
+	msg;
+	status;
+	/** PID du process émetteur (= procid RFC 5424). Constant, capturé au chargement du module. */
+	pid;
+	/**
+	* Identifiant de la requête en cours (corrélation log↔requête).
+	*
+	* Présent UNIQUEMENT si le Pdu est créé dans une bulle `RequestContext` active
+	* (ALS Node) ET que {@link Pdu.requestIdProvider} a été branché côté Node — voir
+	* `src/index.ts` (barrel Node uniquement, isomorphisme préservé : le bundle
+	* client/browser ne branche pas, le provider reste `null` → 0 alloc, 0 lecture).
+	*
+	* Combiné à `pid` (procid RFC 5424), permet la corrélation **complète** :
+	* `pid` = quel worker, `requestId` = quelle requête. Voyage dans ring buffer +
+	* `nodefony:syslog` + transports JSON (champ public sérialisé naturellement).
+	*/
+	requestId;
+	/**
+	* Provider injectable du `requestId` courant (ALS). Branché par le barrel
+	* Node (`src/index.ts`) sur `RequestContext.getRequestId`. Reste `null` côté
+	* browser/debugbar (le bundle client n'importe pas `node:async_hooks`) et
+	* pendant les phases boot pré-Kernel (cohérent : pas de requête en cours).
+	*
+	* Coût : 1 test de référence par Pdu (~5 ns) quand `null` ; ~50-100 ns quand
+	* branché (lecture ALS + accès propriété). Pas d'alloc supplémentaire si
+	* `requestId` est `undefined` (le champ reste non-défini sur l'instance).
+	*/
+	static requestIdProvider = null;
+	/**
+	* Construit un Pdu prêt à être publié dans le pipeline Syslog.
+	*
+	* @param pci - payload (string, Error, objet — typé `unknown`, narrower côté lecteur).
+	* @param severity - niveau RFC 5424 (string `"INFO"` ou numérique `6`). Défaut `"INFO"`.
+	* @param moduleName - nom du module/service qui a produit le log. Défaut `"nodefony"`.
+	* @param msgid - catégorie de message (`"AUTH"`, `"ROUTER"`, etc.). Défaut `""`.
+	* @param msg - détail libre optionnel. Défaut `""`.
+	* @param date - timestamp (number, Date, ou string parsable). Défaut `Date.now()`.
+	* @throws Si `severity` n'est pas une valeur valide de {@link SysLogSeverity}.
+	*/
+	constructor(pci, severity, moduleName = "nodefony", msgid = "", msg = "", date) {
+		if (date === void 0) this.timeStamp = Date.now();
+		else if (typeof date === "number") this.timeStamp = date;
+		else if (date instanceof Date) this.timeStamp = date.getTime();
+		else this.timeStamp = new Date(date).getTime();
+		this.uid = ++guid;
+		this.severity = translateSeverity(severity);
+		const sName = severityNameMap.get(this.severity);
+		if (sName === void 0) throw new Error(`Invalid severity value: ${this.severity}`);
+		this.severityName = sName;
+		this.typePayload = fastTypeOf(pci);
+		this.payload = pci;
+		this.moduleName = moduleName;
+		this.msgid = msgid;
+		this.msg = msg;
+		this.status = "NOTDEFINED";
+		this.pid = PID;
+		this.requestId = Pdu.requestIdProvider !== null ? Pdu.requestIdProvider() : void 0;
+	}
+	/**
+	* Map bidirectionnelle des sévérités RFC 5424 (`{ INFO: 6, 6: "INFO", ... }`).
+	*
+	* @returns dictionnaire `{ severityName: severityValue }` plus enum reverse.
+	*/
+	static sysLogSeverity() {
+		return sysLogSeverityObj;
+	}
+	/**
+	* Convertit une sévérité numérique ou string en son nom canonique.
+	*
+	* @param severity - valeur numérique (`6`) ou string (`"INFO"` ou `"6"`).
+	* @returns nom canonique (`"INFO"`) ou `undefined` si invalide.
+	*/
+	static severityToString(severity) {
+		const numericSeverity = typeof severity === "string" ? parseInt(severity, 10) : severity;
+		if (!isNaN(numericSeverity) && SysLogSeverity[numericSeverity] !== void 0) return SysLogSeverity[numericSeverity];
+		const severityKey = Pdu.severityToString(SysLogSeverity[severity]);
+		return severityKey !== void 0 ? severityKey : void 0;
+	}
+	/**
+	* Retourne le timestamp formaté `HH:MM:SS GMT±HHMM (TZ Name)`.
+	*
+	* @returns time string lisible par humain.
+	*/
+	getDate() {
+		return new Date(this.timeStamp).toTimeString();
+	}
+	/**
+	* Sérialise le Pdu en string mono-ligne pour transport console/file.
+	*
+	* @returns ligne formatée `TimeStamp:... Log:... ModuleName:... SeverityName:... MessageID:... UID:... Message:...`.
+	*/
+	toString() {
+		return `TimeStamp:${this.getDate()}  Log:${this.payload}  ModuleName:${this.moduleName}  SeverityName:${this.severityName}  MessageID:${this.msgid}  UID:${this.uid}  Message:${this.msg}`;
+	}
+	/**
+	* Réhydrate un Pdu existant à partir d'une string JSON — mute uniquement les
+	* clés déjà présentes sur l'instance (filtre `key in this`).
+	*
+	* @param str - JSON sérialisé d'un Pdu.
+	* @returns objet parsé (ou `null` si JSON vide). Mute l'instance courante au passage.
+	*/
+	parseJson(str) {
+		const json = JSON.parse(str);
+		Object.entries(json).forEach(([key, value]) => {
+			if (key in this) this[key] = value;
+		});
+		return json;
+	}
+};
+//#endregion
+//#region src/syslog/logColor.ts
+/** Combinaisons `cli-color` réellement utilisées par les loggers Nodefony. */
+const KEYS = [
+	"cyan",
+	"magenta",
+	"red",
+	"green",
+	"yellow",
+	"blue",
+	"blackBright",
+	"yellowBold",
+	"redBold",
+	"cyanBold",
+	"blueBrightBold",
+	"cyanBgBlue",
+	"cyanBgBlack"
+];
+const identity = (s) => s;
+/** Implémentation colorée (TTY) — résolue 1× à l'import (chaînage figé). */
+const COLORS = {
+	cyan: clc.cyan,
+	magenta: clc.magenta,
+	red: clc.red,
+	green: clc.green,
+	yellow: clc.yellow,
+	blue: clc.blue,
+	blackBright: clc.blackBright,
+	yellowBold: clc.yellow.bold,
+	redBold: clc.red.bold,
+	cyanBold: clc.cyan.bold,
+	blueBrightBold: clc.blueBright.bold,
+	cyanBgBlue: clc.cyan.bgBlue,
+	cyanBgBlack: clc.cyan.bgBlack
+};
+/**
+* Helper de couleur partagé — référence STABLE, propriétés mutées par
+* {@link setLogColor}. Les call-sites font `logColor.cyan("URL")`.
+*/
+const logColor = { ...COLORS };
+let _enabled = false;
+/**
+* Active/désactive la couleur ANSI des logs — à appeler **une fois au boot**.
+* Swap les fonctions des slots ; aucun coût par log ensuite.
+*
+* @param enabled - `true` = couleur (TTY interactif), `false` = brut (pipe/fichier).
+*/
+function setLogColor(enabled) {
+	_enabled = enabled;
+	for (const k of KEYS) logColor[k] = enabled ? COLORS[k] : identity;
+}
+/** `true` si la couleur ANSI est active (gate boot-time). */
+function isLogColorEnabled() {
+	return _enabled;
+}
+/**
+* Applique les conventions d'environnement couleur PAR-DESSUS un signal `isTTY`
+* **déjà résolu** — au boot on passe `Kernel.isTTY` (qui honore déjà `NF_NO_TTY`),
+* sans re-lire `process.stdout`. Conventions :
+*
+* - **`NO_COLOR`** (no-color.org) : présent **et non vide** → couleur OFF, quelle
+*   que soit sa valeur. Priorité absolue (refus explicite de l'utilisateur).
+* - **`FORCE_COLOR`** : non vide et ≠ `"0"` → couleur ON (override pipe/non-TTY,
+*   ex. CI qui veut des logs colorés capturés).
+* - sinon → couleur = `isTTY`.
+*
+* Isomorphe : `env` lu via `globalThis.process` (navigateur : pas de `process`).
+*
+* @param isTTY - signal TTY déjà résolu (ex. `Kernel.isTTY`, NF_NO_TTY-aware).
+*/
+function resolveColorEnabled(isTTY) {
+	const env = globalThis.process?.env ?? {};
+	if (typeof env.NO_COLOR === "string" && env.NO_COLOR !== "") return false;
+	if (typeof env.FORCE_COLOR === "string" && env.FORCE_COLOR !== "" && env.FORCE_COLOR !== "0") return true;
+	return isTTY;
+}
+const _importProc = globalThis.process;
+setLogColor(resolveColorEnabled(_importProc?.env?.NF_NO_TTY ? false : _importProc?.stdout?.isTTY === true));
+//#endregion
+//#region src/syslog/Syslog.ts
+const yellow = (s) => logColor.yellowBold(s);
+const red = (s) => logColor.redBold(s);
+const cyan = (s) => logColor.cyanBold(s);
+const blue = (s) => logColor.blueBrightBold(s);
+const green = (s) => logColor.green(s);
+const _proc = globalThis.process;
+const _stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+let _bufferMode = "auto";
+let _bufferOn = null;
+let _outChunks = null;
+let _outBytes = 0;
+let _flushScheduled = false;
+const FLUSH_BYTES = 65536;
+const _setImmediate = globalThis.setImmediate;
+const _resolveBufferOn = () => {
+	if (_bufferOn !== null) return _bufferOn;
+	_bufferOn = !_setImmediate ? false : _bufferMode === "on" ? true : _bufferMode === "off" ? false : !_proc?.stdout?.isTTY;
+	return _bufferOn;
+};
+const _stdoutSink = {
+	name: "stdout",
+	writeOut(s) {
+		if (_proc?.stdout) _proc.stdout.write(s);
+		else console.log(_stripAnsi(s).replace(/\n$/, ""));
+	},
+	writeErr(s) {
+		if (_proc?.stderr) _proc.stderr.write(s);
+		else console.error(_stripAnsi(s).replace(/\n$/, ""));
+	},
+	flushSync() {},
+	close() {}
+};
+/** Sink `/dev/null` : noop total (bench — mesure du plafond sans I/O de log). */
+const NULL_LOG_SINK = {
+	name: "null",
+	writeOut() {},
+	writeErr() {},
+	flushSync() {},
+	close() {}
+};
+let _sink = _stdoutSink;
+let _sinkMuted = false;
+const _writeStdoutNow = (s) => {
+	if (!_sinkMuted) _sink.writeOut(s);
+};
+const _writeStderrNow = (s) => {
+	if (!_sinkMuted) _sink.writeErr(s);
+};
+const _flushOut = () => {
+	_flushScheduled = false;
+	if (_outChunks && _outChunks.length > 0) {
+		_writeStdoutNow(_outChunks.join(""));
+		_outChunks.length = 0;
+		_outBytes = 0;
+	}
+};
+const _setBufferMode = (mode) => {
+	_flushOut();
+	_bufferMode = mode === true ? "on" : mode === false ? "off" : "auto";
+	_bufferOn = null;
+};
+const _setLogSink = (sink) => {
+	_flushOut();
+	if (_sink !== sink && _sink !== _stdoutSink && _sink !== NULL_LOG_SINK) _sink.close();
+	_sink = sink ?? _stdoutSink;
+};
+const writeOut = (s) => {
+	if (!_resolveBufferOn()) {
+		_writeStdoutNow(s);
+		return;
+	}
+	if (_outChunks === null) _outChunks = [];
+	_outChunks.push(s);
+	_outBytes += s.length;
+	if (_outBytes >= FLUSH_BYTES) {
+		_flushOut();
+		return;
+	}
+	if (!_flushScheduled && _setImmediate) {
+		_flushScheduled = true;
+		_setImmediate(_flushOut);
+	}
+};
+const writeErr = (s) => {
+	if (_outChunks && _outChunks.length > 0) _flushOut();
+	_writeStderrNow(s);
+};
+if (_proc?.on) {
+	const _onExit = () => {
+		_flushOut();
+		_sink.flushSync();
+	};
+	_proc.on("exit", _onExit);
+	_proc.on("beforeExit", _onExit);
+}
+var CircularBuffer = class {
+	buf;
+	head = 0;
+	_size = 0;
+	capacity;
+	constructor(capacity) {
+		this.capacity = capacity;
+		this.buf = new Array(capacity);
+	}
+	push(item) {
+		if (this._size === this.capacity) {
+			this.buf[this.head] = item;
+			this.head = (this.head + 1) % this.capacity;
+		} else {
+			const tail = (this.head + this._size) % this.capacity;
+			this.buf[tail] = item;
+			this._size++;
+		}
+	}
+	get length() {
+		return this._size;
+	}
+	last() {
+		if (this._size === 0) return void 0;
+		return this.buf[(this.head + this._size - 1) % this.capacity];
+	}
+	clear() {
+		this.head = 0;
+		this._size = 0;
+	}
+	toArray() {
+		const result = new Array(this._size);
+		for (let i = 0; i < this._size; i++) result[i] = this.buf[(this.head + i) % this.capacity];
+		return result;
+	}
+};
+const formatDebug = function(debug) {
+	if (typeof debug === "boolean") return debug;
+	if (typeof debug === "string") {
+		if ([
+			"false",
+			"undefined",
+			"null"
+		].includes(debug)) return false;
+		if (debug === "true" || debug === "*") return true;
+		const mytab = debug.split(/,| /);
+		return mytab[0] === "*" ? true : mytab;
+	}
+	if (Array.isArray(debug)) return debug[0] === "*" ? true : debug;
+	return false;
+};
+const conditionOptions = function(environment, debug = false) {
+	debug = formatDebug(debug);
+	let obj;
+	if (environment === "development") obj = { severity: {
+		operator: "<=",
+		data: debug === false ? 6 : 7
+	} };
+	else obj = { severity: {
+		operator: "<=",
+		data: debug ? 7 : 6
+	} };
+	if (typeof debug === "object") obj.msgid = {
+		operator: "==",
+		data: debug
+	};
+	return obj;
+};
+const defaultSettings = {
+	moduleName: "SYSLOG",
+	msgid: "",
+	maxStack: 100,
+	rateLimit: false,
+	burstLimit: 3,
+	defaultSeverity: "DEBUG",
+	checkConditions: "&&",
+	async: false
+};
+const sysLogSeverity = Pdu.sysLogSeverity();
+const operators = {
+	"<": (ele1, ele2) => ele1 < ele2,
+	">": (ele1, ele2) => ele1 > ele2,
+	"<=": (ele1, ele2) => ele1 <= ele2,
+	">=": (ele1, ele2) => ele1 >= ele2,
+	"==": (ele1, ele2) => ele1 == ele2,
+	"===": (ele1, ele2) => ele1 === ele2,
+	"!=": (ele1, ele2) => ele1 !== ele2,
+	RegExp: (ele1, ele2) => ele2.test(ele1)
+};
+const conditionsObj = {
+	severity: (pdu, condition) => {
+		for (const sev in condition.data) if (condition.operator && operators[condition.operator](pdu.severity, condition.data[sev])) return true;
+		return false;
+	},
+	msgid: (pdu, condition) => {
+		if (condition.data instanceof RegExp) return condition.data.test(pdu.msgid);
+		for (const sev in condition.data) if (condition.operator && operators[condition.operator](pdu.msgid, sev)) return true;
+		return false;
+	},
+	date: (pdu, condition) => condition.operator ? operators[condition.operator](pdu.timeStamp, condition.data) : false
+};
+const logicCondition = {
+	"&&": (myConditions, pdu) => {
+		let res = false;
+		for (const ele in myConditions) {
+			res = conditionsObj[ele](pdu, myConditions[ele]);
+			if (!res) break;
+		}
+		return res;
+	},
+	"||": (myConditions, pdu) => {
+		let res = false;
+		for (const ele in myConditions) {
+			res = conditionsObj[ele](pdu, myConditions[ele]);
+			if (res) break;
+		}
+		return res;
+	}
+};
+const checkFormatSeverity = (ele) => {
+	let res;
+	switch (typeof ele) {
+		case "object":
+			if (Array.isArray(ele)) res = ele;
+			else throw new Error(`checkFormatSeverity bad format type: object`);
+			break;
+		case "string":
+			res = ele.split(/,| /);
+			break;
+		case "number":
+			res = [ele];
+			break;
+		default: throw new Error(`checkFormatSeverity bad format type : ${typeof ele}`);
+	}
+	return res;
+};
+const checkFormatDate = function(ele) {
+	if (ele instanceof Date) return ele.getTime();
+	if (typeof ele === "string") return new Date(ele).getTime();
+	throw new Error(`checkFormatDate bad format : ${String(ele)}`);
+};
+const checkFormatMsgId = function(ele) {
+	if (typeof ele === "string") return ele.split(/,| /);
+	if (typeof ele === "number") return [ele];
+	if (ele instanceof RegExp) return ele;
+	if (Array.isArray(ele)) return ele;
+	throw new Error(`checkFormatMsgId bad format ${typeof ele} : ${String(ele)}`);
+};
+const wrapperCondition = function(conditions, callback) {
+	let myFuncCondition = () => false;
+	if (conditions.checkConditions && conditions.checkConditions in logicCondition) {
+		myFuncCondition = logicCondition[conditions.checkConditions];
+		delete conditions.checkConditions;
+	} else if (this.settings.checkConditions) myFuncCondition = logicCondition[this.settings.checkConditions];
+	const Conditions = sanitizeConditions(conditions);
+	if (typeof callback === "function") return (pdu) => {
+		if (myFuncCondition(Conditions, pdu)) callback(pdu);
+	};
+	if (Array.isArray(callback)) {
+		const tab = [];
+		for (const pdu of callback) if (myFuncCondition(Conditions, pdu)) tab.push(pdu);
+		return tab;
+	}
+	throw new Error("Bad wrapper");
+};
+const sanitizeConditions = function(settingsCondition) {
+	if (typeof settingsCondition !== "object" || settingsCondition === null) return false;
+	for (const ele in settingsCondition) {
+		if (!(ele in conditionsObj)) return false;
+		const condi = settingsCondition[ele];
+		if (condi.operator && !(condi.operator in operators)) throw new Error(`Contitions bad operator : ${condi.operator}`);
+		if (condi.data) switch (ele) {
+			case "severity": {
+				if (!condi.operator) condi.operator = "==";
+				const res = checkFormatSeverity(condi.data);
+				condi.data = {};
+				for (let i = 0; i < res.length; i++) {
+					const mySeverity = Pdu.severityToString(res[i]);
+					if (mySeverity) condi.data[mySeverity] = sysLogSeverity[mySeverity];
+					else return false;
+				}
+				break;
+			}
+			case "msgid": {
+				if (!condi.operator) condi.operator = "==";
+				const res = checkFormatMsgId(condi.data);
+				if (Array.isArray(res)) {
+					condi.data = {};
+					for (let i = 0; i < res.length; i++) condi.data[String(res[i])] = "||";
+				} else condi.data = res;
+				break;
+			}
+			case "date": {
+				const res = checkFormatDate(condi.data);
+				if (res) condi.data = res;
+				else return false;
+				break;
+			}
+			default: return false;
+		}
+		else return false;
+	}
+	return settingsCondition;
+};
+const createPDU = function(payload, severity, moduleName, msgid, msg) {
+	return new Pdu(payload, severity || this.settings.defaultSeverity, moduleName, msgid, msg);
+};
+(class Syslog extends Event {
+	settings;
+	_ring;
+	burstPrinted;
+	missed;
+	invalid;
+	valid;
+	/**
+	* Cumul monotone des logs de classe ERREUR (sévérité 0–3 : ERROR/CRITIC/ALERT/EMERGENCY)
+	* acceptés depuis la construction. Compteur entier O(1) bumpé dans le seul point de passage
+	* {@link pushStack} (0 alloc) → sonde « erreurs par worker » de la santé
+	* pod (cf `IInstanceErrorHealth`). Débit dérivé côté lecteur (delta `errorTotal`/ts).
+	*/
+	errorTotal;
+	/** Sous-ensemble CRITIQUE (sévérité 0–2 : CRITIC/ALERT/EMERGENCY). Cumul monotone. */
+	criticTotal;
+	start;
+	_async = false;
+	_transports = [];
+	/**
+	* Transports désactivés à chaud (par `setTransportEnabled`) — **lazy** (`null`
+	* tant qu'aucun toggle). Garde la réf hors de `_transports` pour pouvoir la
+	* remonter. Un transport désactivé est PHYSIQUEMENT retiré de la boucle de fire
+	* → **0 surcoût hot path** (pas de test `enabled` par log). Outil dev/diagnostic.
+	*/
+	_disabledTransports = null;
+	/**
+	* Stockage des Pdu dans le ring buffer (relecture mémoire). `false` = on ne
+	* garde plus rien en mémoire (l'Explorer « mémoire » et `buffered` tombent à 0)
+	* — outil avancé perf/mémoire (très haut débit). Les compteurs (valid/error)
+	* restent comptés. Coût hot path : un test booléen par log.
+	*/
+	_ringEnabled = true;
+	/**
+	* Diffusion temps réel active (bus `nodefony:syslog` Studio). `false` = le pont de
+	* diffusion (`createSyslogBridge`) n'accumule ni ne publie rien → l'onglet Live se
+	* grise. N'affecte NI l'écriture (transports/sink) NI la relecture. Coupé = on
+	* cesse juste de POUSSER en live ; les logs continuent d'être générés et écrits.
+	*/
+	_streamEnabled = true;
+	/**
+	* T2 (profil delta vs Express) — gate d'ENTRÉE par sévérité. `null` (défaut) =
+	* pas de gate (comportement historique : tout Pdu est créé + poussé au ring,
+	* le filtrage de sévérité n'a lieu qu'au LISTENER d'impression — un DEBUG en
+	* prod coûtait createPDU + pushStack pour rien, ~1,7 % du profil CPU/req).
+	* Valeur numérique N = un log de sévérité STRICTEMENT supérieure à N (moins
+	* grave) est court-circuité AVANT toute allocation. Posé par {@link init}
+	* (production sans debug → 6 = DEBUG gaté), **re-résoluble à chaud** via
+	* {@link setSeverityThreshold} (vision « audit à chaud » : élever la
+	* verbosité prod sur une fenêtre bornée sans redémarrer). Une sévérité
+	* INCONNUE (`-1`) passe toujours — c'est `createPDU` qui la refuse, et le
+	* gate ne doit pas transformer une erreur d'usage en silence. Compteur
+	* {@link gated} pour l'introspection.
+	*/
+	_severityThreshold = null;
+	/** Pdu singleton retourné par un log gaté (contrat `log(): Pdu`, 1 alloc lazy). */
+	_gatedPdu = null;
+	/** Nombre de logs court-circuités par le gate de sévérité (T2). */
+	gated = 0;
+	/**
+	* Overrides de seuil PAR MODULE (clé = `msgid` du Pdu, qui vaut le nom du
+	* Service émetteur par défaut — cf `Service.log`). `null` par défaut → 0 coût
+	* sur le hot path tant qu'aucun debug ciblé n'est actif (RÈGLE perf : lazy
+	* null). Posé à chaud par {@link setDebugOverride} (env `NF__DEBUG` au boot,
+	* endpoint admin, toggle Studio) : élève la verbosité d'UN module sous gate
+	* prod sans toucher les autres ni redémarrer. Consulté dans {@link log} APRÈS
+	* le gate global, AVANT toute allocation.
+	*/
+	_debugOverrides = null;
+	/**
+	* Timers d'auto-extinction des overrides (clé = même `msgid`). `null` tant
+	* qu'aucun override temporisé n'est armé. Garde-fou anti-oubli : un debug
+	* ciblé ne reste JAMAIS allumé indéfiniment. Timers `unref` (ne tiennent pas
+	* la boucle d'événements en vie) + purgés par {@link clearDebugOverride} /
+	* {@link reset} (RÈGLE perf : pas de timer sans cleanup).
+	*/
+	_debugOverrideTimers = null;
+	/**
+	* Échéance (epoch ms) de chaque override TEMPORISÉ — pour exposer le « s'éteint
+	* dans X » au panneau Studio. `null` tant qu'aucun override temporisé ; un
+	* override permanent (sans ttl) n'y figure pas. Nettoyé en miroir du timer.
+	*/
+	_debugOverrideExpiry = null;
+	/**
+	* Construit le Syslog avec settings (merge default + override user).
+	*
+	* @param settings - config (`moduleName`, `maxStack`, `rateLimit`, `burstLimit`,
+	*   `defaultSeverity`, `async`, `overrideConsole`).
+	*/
+	constructor(settings) {
+		super(settings);
+		this.settings = extend({}, defaultSettings, settings || {});
+		this._ring = new CircularBuffer(this.settings.maxStack ?? 100);
+		this.burstPrinted = 0;
+		this.missed = 0;
+		this.invalid = 0;
+		this.valid = 0;
+		this.errorTotal = 0;
+		this.criticTotal = 0;
+		this.start = 0;
+		this._async = this.settings.async || false;
+		if (this.settings.overrideConsole) Syslog.overrideConsole(this);
+	}
+	get ringStack() {
+		return this._ring.toArray();
+	}
+	/**
+	* Capacité MAX du ring buffer (`settings.maxStack`) — nombre de Pdu que la
+	* mémoire peut relire. `ringStack.length` = remplissage courant ; ce getter =
+	* le plafond. Lecture seule, 0 allocation (introspection data plane Studio).
+	*/
+	get bufferCapacity() {
+		return this._ring.capacity;
+	}
+	/** `true` si les Pdu sont stockés dans le ring (relecture mémoire active). */
+	get ringEnabled() {
+		return this._ringEnabled;
+	}
+	/**
+	* Active/désactive le stockage mémoire (ring) à chaud — outil avancé perf/mémoire.
+	* Désactiver = l'Explorer « mémoire » et `buffered` retombent à 0 (les logs ne
+	* sont plus gardés en RAM) ; les compteurs santé restent comptés. Vide le ring
+	* quand on coupe (libère la RAM tout de suite). Idempotent.
+	*
+	* @param enabled - `true` = stocker dans le ring ; `false` = ne plus stocker.
+	* @returns `true` si l'état a changé.
+	*/
+	setRingEnabled(enabled) {
+		if (this._ringEnabled === enabled) return false;
+		this._ringEnabled = enabled;
+		if (!enabled) this._ring.clear();
+		return true;
+	}
+	/** `true` si la diffusion temps réel (`nodefony:syslog`) est active. */
+	get streamEnabled() {
+		return this._streamEnabled;
+	}
+	/**
+	* Active/désactive la diffusion temps réel (bus `nodefony:syslog`) à chaud. Coupé =
+	* le pont Studio cesse de pousser des frames (onglet Live grisé) ; l'écriture et la
+	* relecture froide ne sont PAS touchées. Idempotent.
+	*
+	* @param enabled - `true` = diffuser ; `false` = couper la diffusion live.
+	* @returns `true` si l'état a changé.
+	*/
+	setStreamEnabled(enabled) {
+		if (this._streamEnabled === enabled) return false;
+		this._streamEnabled = enabled;
+		return true;
+	}
+	/**
+	* Redimensionne le ring buffer (capacité de relecture en mémoire) en
+	* **préservant** les Pdu déjà présents (tronqués aux `max` plus récents si on
+	* rétrécit). Destiné au **boot uniquement** (lu depuis `config.log.maxStack`) —
+	* recrée le buffer, donc à ne pas appeler dans le hot path. No-op si `max`
+	* invalide ou inchangé.
+	*
+	* @param max - nouvelle capacité (> 0).
+	*/
+	setMaxStack(max) {
+		if (!Number.isFinite(max) || max <= 0 || max === this.settings.maxStack) return;
+		const kept = this._ring.toArray().slice(-max);
+		this.settings.maxStack = max;
+		this._ring = new CircularBuffer(max);
+		for (const pdu of kept) this._ring.push(pdu);
+	}
+	static formatDebug(debug) {
+		return formatDebug(debug);
+	}
+	/**
+	* Initialise le pipeline Syslog selon environnement + debug. Idempotent — purge les
+	* listeners `"onLog"` existants avant d'en ajouter un.
+	*
+	* @param environment - `"development"` / `"production"` / `"test"`.
+	* @param debug - active sévérité DEBUG (`+7`).
+	* @param options - conditions de filtrage Syslog custom (override des conditions par env).
+	*/
+	init(environment, debug, options) {
+		this.removeAllListeners("onLog");
+		this.listenWithConditions(options || conditionOptions(environment, debug), (pdu) => Syslog.normalizeLog(pdu));
+	}
+	/**
+	* T2 — résout une sévérité (nom ou numérique) en valeur RFC 5424. Inconnue →
+	* `-1` (passe toujours le gate : fail-open, `createPDU` jettera comme avant).
+	* `sysLogSeverity` est un enum numérique TS → la reverse-map mêle string et
+	* number, d'où le narrowing explicite.
+	*/
+	static toSeverityNumber(severity) {
+		if (typeof severity === "number") return severity;
+		const v = sysLogSeverity[severity];
+		return typeof v === "number" ? v : -1;
+	}
+	/**
+	* Valide STRICTEMENT une sévérité d'ENTRÉE (nom RFC 5424 ou numérique 0-7) →
+	* numéro, ou `null` si invalide. Pour les surfaces d'entrée (endpoint admin,
+	* env) : un niveau inconnu doit être REJETÉ, jamais silencieusement
+	* réinterprété (≠ {@link toSeverityNumber}, fail-open `-1` pour le hot path).
+	*
+	* @param level - nom (`"DEBUG"`) ou numéro (`7` / `"7"`).
+	* @returns le numéro 0-7, ou `null` si hors plage / nom inconnu.
+	*/
+	static severityFromInput(level) {
+		if (typeof level === "number") return Number.isInteger(level) && level >= 0 && level <= 7 ? level : null;
+		if (typeof level === "string") {
+			if (/^\d+$/.test(level)) {
+				const n = Number(level);
+				return n >= 0 && n <= 7 ? n : null;
+			}
+			const v = sysLogSeverity[level];
+			return typeof v === "number" ? v : null;
+		}
+		return null;
+	}
+	/**
+	* Parse une spec `NF__DEBUG` (env runtime) en directives de debug ciblé.
+	* Tokens séparés par virgule/espace :
+	* - `*` → debug GLOBAL (lève le gate de sévérité, tout passe) ;
+	* - `MODULE` → override `MODULE` à DEBUG ;
+	* - `MODULE:LEVEL` → override `MODULE` au niveau `LEVEL` (nom/numérique ;
+	*   inconnu → DEBUG, tolérant : un typo d'env ne doit pas crasher le boot).
+	*
+	* Pur (statique, sans état) → testable seul ; appliqué par le Kernel au boot
+	* via {@link setSeverityThreshold} / {@link setDebugOverride}.
+	*
+	* @param spec - valeur brute de `NF__DEBUG` (ex. `"FIREWALL,SESSION:NOTICE"`).
+	* @returns `{ global, overrides }`.
+	*/
+	static parseDebugSpec(spec) {
+		const result = {
+			global: false,
+			overrides: []
+		};
+		if (typeof spec !== "string") return result;
+		for (const token of spec.split(/[,\s]+/)) {
+			if (!token) continue;
+			if (token === "*") {
+				result.global = true;
+				continue;
+			}
+			const sep = token.indexOf(":");
+			if (sep === -1) {
+				result.overrides.push({
+					module: token,
+					level: 7
+				});
+				continue;
+			}
+			const module = token.slice(0, sep);
+			if (!module) continue;
+			const lvl = Syslog.severityFromInput(token.slice(sep + 1)) ?? 7;
+			result.overrides.push({
+				module,
+				level: lvl
+			});
+		}
+		return result;
+	}
+	/**
+	* T2 — règle (ou lève) le gate d'entrée par sévérité À CHAUD, sans reboot.
+	* `null` = plus de gate (tout est créé/poussé, comportement historique) ;
+	* `"DEBUG"`/7 = tout passe en restant gateable ; `"INFO"`/6 = défaut prod.
+	* Levier de la fenêtre « audit à chaud » : élever temporairement la
+	* verbosité prod puis restaurer.
+	*
+	* @param threshold - sévérité max acceptée (nom ou numérique RFC 5424), ou `null`.
+	*/
+	setSeverityThreshold(threshold) {
+		this._severityThreshold = threshold === null ? null : Syslog.toSeverityNumber(threshold);
+	}
+	/**
+	* T2 — un log de cette sévérité franchirait-il le gate d'entrée ? À utiliser
+	* aux call sites du hot path AVANT de construire un message coûteux
+	* (template string, JSON) — pattern L1 « ne jamais formater au-dessus du
+	* niveau actif ».
+	*
+	* @param severity - sévérité à tester (nom ou numérique).
+	* @returns `true` si un log de cette sévérité serait accepté.
+	*/
+	severityEnabled(severity) {
+		if (this._severityThreshold === null) return true;
+		return Syslog.toSeverityNumber(severity) <= this._severityThreshold;
+	}
+	/**
+	* Élève à chaud le seuil de verbosité d'UN module (debug ciblé), sans reboot et
+	* sans toucher aux autres modules. `module` = `msgid` du Pdu (par défaut le nom
+	* du Service émetteur, cf `Service.log`). Effet : tant que l'override est actif,
+	* un log de ce module passe le gate d'entrée jusqu'à `level` (ex. `"DEBUG"`)
+	* alors que le reste reste au seuil global (ex. `"INFO"` en prod).
+	*
+	* Garde-fou : si `ttlMs > 0`, l'override s'auto-éteint après ce délai (timer
+	* `unref`). (Re)poser le même module ré-arme proprement le timer. Sans gate
+	* global actif (`_severityThreshold === null`, ex. dev) l'override est sans
+	* effet — tout passe déjà.
+	*
+	* @param module - identité du module (`msgid` / nom du Service).
+	* @param level - sévérité max laissée passer pour ce module (nom ou numérique).
+	* @param ttlMs - durée de vie en ms (auto-extinction). Omis/≤0 = permanent (déconseillé en prod).
+	*/
+	setDebugOverride(module, level, ttlMs) {
+		if (this._debugOverrides === null) this._debugOverrides = /* @__PURE__ */ new Map();
+		this._debugOverrides.set(module, Syslog.toSeverityNumber(level));
+		this.clearOverrideTimer(module);
+		if (ttlMs !== void 0 && ttlMs > 0) {
+			if (this._debugOverrideTimers === null) this._debugOverrideTimers = /* @__PURE__ */ new Map();
+			const timer = setTimeout(() => {
+				this.clearDebugOverride(module);
+			}, ttlMs);
+			timer.unref();
+			this._debugOverrideTimers.set(module, timer);
+			if (this._debugOverrideExpiry === null) this._debugOverrideExpiry = /* @__PURE__ */ new Map();
+			this._debugOverrideExpiry.set(module, Date.now() + ttlMs);
+		} else if (this._debugOverrideExpiry !== null) {
+			this._debugOverrideExpiry.delete(module);
+			if (this._debugOverrideExpiry.size === 0) this._debugOverrideExpiry = null;
+		}
+	}
+	/**
+	* Retire l'override de debug ciblé d'un module (et son timer d'auto-extinction).
+	* Retombe à `null` quand le dernier override part (RÈGLE perf : 0 coût hot path).
+	*
+	* @param module - identité du module (`msgid`).
+	* @returns `true` si un override existait et a été retiré.
+	*/
+	clearDebugOverride(module) {
+		this.clearOverrideTimer(module);
+		if (this._debugOverrideExpiry !== null) {
+			this._debugOverrideExpiry.delete(module);
+			if (this._debugOverrideExpiry.size === 0) this._debugOverrideExpiry = null;
+		}
+		if (this._debugOverrides === null) return false;
+		const had = this._debugOverrides.delete(module);
+		if (this._debugOverrides.size === 0) this._debugOverrides = null;
+		return had;
+	}
+	/** Retire TOUS les overrides de debug ciblé + leurs timers (retour à 0 coût). */
+	clearAllDebugOverrides() {
+		if (this._debugOverrideTimers !== null) {
+			for (const timer of this._debugOverrideTimers.values()) clearTimeout(timer);
+			this._debugOverrideTimers = null;
+		}
+		this._debugOverrides = null;
+		this._debugOverrideExpiry = null;
+	}
+	/**
+	* Snapshot des overrides de debug ciblé actifs (introspection — endpoint admin,
+	* toggle Studio). Cold path. `{}` si aucun.
+	*
+	* @returns map `module → seuil numérique` (copie, pas la structure interne).
+	*/
+	getDebugOverrides() {
+		if (this._debugOverrides === null) return {};
+		const out = {};
+		for (const [module, threshold] of this._debugOverrides) out[module] = threshold;
+		return out;
+	}
+	/**
+	* Échéances (epoch ms) des overrides TEMPORISÉS (introspection — countdown
+	* Studio « s'éteint dans X »). `{}` si aucun ; un override permanent (sans ttl)
+	* n'y figure pas.
+	*
+	* @returns map `module → epoch ms d'extinction` (copie).
+	*/
+	getDebugOverrideExpiry() {
+		if (this._debugOverrideExpiry === null) return {};
+		const out = {};
+		for (const [module, at] of this._debugOverrideExpiry) out[module] = at;
+		return out;
+	}
+	/** Annule + retire le timer d'auto-extinction d'un module (si présent). */
+	clearOverrideTimer(module) {
+		if (this._debugOverrideTimers === null) return;
+		const timer = this._debugOverrideTimers.get(module);
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			this._debugOverrideTimers.delete(module);
+			if (this._debugOverrideTimers.size === 0) this._debugOverrideTimers = null;
+		}
+	}
+	get async() {
+		return this._async;
+	}
+	set async(value) {
+		this._async = value;
+	}
+	/**
+	* Alias de {@link reset} — purge ring buffer + listeners.
+	*/
+	clean() {
+		return this.reset();
+	}
+	/**
+	* Reset complet — vide le ring buffer ET retire tous les listeners.
+	*
+	* @returns `this` pour chaînage.
+	*/
+	reset() {
+		this._ring.clear();
+		this.removeAllListeners();
+		this.clearAllDebugOverrides();
+		return this;
+	}
+	/**
+	* Vide uniquement le ring buffer (conserve les listeners attachés).
+	*/
+	clearLogStack() {
+		this._ring.clear();
+	}
+	/**
+	* Push manuel d'un Pdu dans le ring buffer + incrémente compteur `valid`.
+	*
+	* @param pdu - Pdu à enregistrer.
+	* @returns nouvelle taille du ring buffer après push.
+	*/
+	pushStack(pdu) {
+		if (this._ringEnabled) this._ring.push(pdu);
+		this.valid++;
+		const sev = pdu.severity;
+		if (sev >= 0 && sev <= 3) {
+			this.errorTotal++;
+			if (sev <= 2) this.criticTotal++;
+		}
+		return this._ring.length;
+	}
+	/**
+	* Crée un Pdu et le diffuse dans le pipeline (rate-limit → push → fire `"onLog"`).
+	*
+	* **Protection rate limit** : si `settings.rateLimit > 0`, ne fire `"onLog"` que pour les
+	* `burstLimit` premiers Pdu de la fenêtre. Les suivants incrémentent `missed`.
+	*
+	* **Mode async** : si `this.async === true`, fire `"onLog"` sur `setImmediate()` (libère
+	* le hot path du caller).
+	*
+	* @param payload - contenu (string, Error, objet — narrower côté lecteur).
+	* @param severity - sévérité RFC 5424 (`"INFO"`, `"ERROR"`, ...) ou numérique (6, 3, ...).
+	* @param msgid - catégorie de message (`"AUTH"`, `"ROUTER"`). Défaut = `settings.msgid`.
+	* @param msg - détail libre optionnel.
+	* @returns le `Pdu` créé (utile pour audit/tests).
+	*/
+	log(payload, severity, msgid, msg) {
+		if (this._severityThreshold !== null) {
+			const sev = payload instanceof Pdu ? payload.severity : Syslog.toSeverityNumber(severity ?? this.settings.defaultSeverity ?? "DEBUG");
+			let threshold = this._severityThreshold;
+			if (this._debugOverrides !== null) {
+				const key = payload instanceof Pdu ? payload.msgid : msgid || this.settings.msgid;
+				const eff = this._debugOverrides.get(key) ?? this._debugOverrides.get("*");
+				if (eff !== void 0) threshold = eff;
+			}
+			if (sev > threshold) {
+				this.gated++;
+				if (this._gatedPdu === null) {
+					this._gatedPdu = createPDU.call(this, "GATED", "DEBUG", this.settings.moduleName, msgid || this.settings.msgid);
+					this._gatedPdu.status = "DROPPED";
+				}
+				return this._gatedPdu;
+			}
+		}
+		let pdu;
+		if (this.settings.rateLimit !== false) {
+			const rate = this.settings.rateLimit;
+			const now = Date.now();
+			this.start = this.start || now;
+			if (now > this.start + rate) {
+				this.burstPrinted = 0;
+				this.missed = 0;
+				this.start = 0;
+			}
+			if (this.settings.burstLimit && this.settings.burstLimit > this.burstPrinted) {
+				try {
+					pdu = payload instanceof Pdu ? payload : createPDU.call(this, payload, severity, this.settings.moduleName, msgid || this.settings.msgid, msg);
+				} catch (e) {
+					console.error(e);
+					this.invalid++;
+					pdu = pdu ?? createPDU.call(this, e, "ERROR");
+					pdu.status = "INVALID";
+					return pdu;
+				}
+				this.pushStack(pdu);
+				pdu.status = "ACCEPTED";
+				if (this.listenerCount("onLog") > 0) this.fire("onLog", pdu);
+				if (this._transports.length > 0) this._fireTransports(pdu);
+				this.burstPrinted++;
+				return pdu;
+			}
+			this.missed++;
+			pdu = pdu ?? createPDU.call(this, "DROPPED", "WARNING");
+			pdu.status = "DROPPED";
+			return pdu;
+		}
+		try {
+			pdu = payload instanceof Pdu ? payload : createPDU.call(this, payload, severity, this.settings.moduleName, msgid || this.settings.msgid, msg);
+		} catch (e) {
+			console.error(e);
+			this.invalid++;
+			pdu = pdu ?? createPDU.call(this, e, "ERROR");
+			pdu.status = "INVALID";
+			return pdu;
+		}
+		this.pushStack(pdu);
+		pdu.status = "ACCEPTED";
+		if (this.listenerCount("onLog") > 0) this.fire("onLog", pdu);
+		if (this._transports.length > 0) this._fireTransports(pdu);
+		return pdu;
+	}
+	getLogStack(start, end, condition) {
+		if (arguments.length === 0) return this._ring.last();
+		let stack;
+		if (condition) stack = this.getLogs(condition);
+		else stack = this.ringStack;
+		if (!end) return stack.slice(start);
+		if (start === end) return stack[stack.length - start - 1];
+		return stack.slice(start, end);
+	}
+	getLogs(conditions, stack = null) {
+		if (conditions) return wrapperCondition.call(this, conditions, stack || this.ringStack);
+		return this.ringStack;
+	}
+	logToJson(conditions, stack = null) {
+		const res = conditions ? this.getLogs(conditions, stack) : this.ringStack;
+		return JSON.stringify(res);
+	}
+	loadStack(stack, doEvent = false, beforeConditions = null) {
+		if (!stack) throw new Error("syslog loadStack : not stack in arguments ");
+		if (typeof stack === "string") return this.loadStack(JSON.parse(stack), doEvent, beforeConditions);
+		if (Array.isArray(stack) || typeof stack === "object") {
+			for (const stackItem of stack) {
+				const pdu = new Pdu(stackItem.payload, stackItem.severity, stackItem.moduleName || this.settings.moduleName, stackItem.msgid, stackItem.msg, stackItem.timeStamp);
+				this.pushStack(pdu);
+				if (doEvent) {
+					if (beforeConditions) beforeConditions.call(this, pdu, stackItem);
+					this.fire("onLog", pdu);
+				}
+			}
+			return stack;
+		}
+		throw new Error("syslog loadStack : bad stack in arguments type");
+	}
+	filter(conditions, callback) {
+		if (!conditions) throw new Error("filter conditions not found ");
+		conditions = extend(true, {}, conditions);
+		const wrapper = wrapperCondition.call(this, conditions, callback);
+		if (wrapper) super.on("onLog", wrapper);
+	}
+	listenWithConditions(conditions, callback) {
+		return this.filter(conditions, callback);
+	}
+	error(data) {
+		return this.log(data, "ERROR");
+	}
+	warn(data) {
+		return this.log(data, "WARNING");
+	}
+	info(data) {
+		return this.log(data, "INFO");
+	}
+	debug(data) {
+		return this.log(data, "DEBUG");
+	}
+	trace(data, ...args) {
+		return this.log(data, "NOTICE", ...args);
+	}
+	print(...args) {
+		const payload = args.length === 1 ? args[0] : args;
+		return this.log(payload, this.settings.defaultSeverity);
+	}
+	logMultiple(severity, ...args) {
+		const payload = args.length === 1 ? args[0] : args;
+		return this.log(payload, severity);
+	}
+	addTransport(transport) {
+		const idx = this._transports.findIndex((t) => t.name === transport.name);
+		if (idx === -1) this._transports.push(transport);
+		else if (this._transports[idx] !== transport) this._transports[idx] = transport;
+		return this;
+	}
+	removeTransport(transport) {
+		const idx = this._transports.indexOf(transport);
+		if (idx !== -1) this._transports.splice(idx, 1);
+		return this;
+	}
+	/**
+	* Nombre de transports d'écriture branchés (introspection — data plane Studio,
+	* tests d'idempotence). Lecture seule, 0 allocation.
+	*/
+	get transportCount() {
+		return this._transports.length;
+	}
+	/**
+	* Liste polymorphe des transports d'écriture — chaque entrée porte le `name` de
+	* l'`ITransport` (`console`, `file`, `loki`, `syslog`…) et son état `enabled`.
+	* C'est l'axe **WRITE** du Log Backplane : l'écriture est un **fan-out** (1 log →
+	* N transports actifs), orthogonal à l'axe READ (1 driver queryable). Sert au data
+	* plane Studio pour afficher les vraies destinations (et non les inférer des drivers
+	* de relecture, ce qui masquait les transports write-only console/syslog/http).
+	*
+	* Inclut les transports désactivés à chaud (`enabled:false`) pour que l'UI puisse
+	* les ré-activer. Chemin FROID (introspection admin) : alloue à l'appel, jamais
+	* dans le hot path du log.
+	*
+	* @returns un tableau `{ name, enabled }` (montés `true` d'abord, puis désactivés).
+	*/
+	listTransports() {
+		const out = this._transports.map((t) => ({
+			name: t.name,
+			enabled: true
+		}));
+		if (this._disabledTransports) for (const name of this._disabledTransports.keys()) out.push({
+			name,
+			enabled: false
+		});
+		return out;
+	}
+	/**
+	* Active/désactive un transport d'écriture **à chaud, par nom** (outil dev /
+	* diagnostic — ex. couper la console pour un bench, ou remonter un transport).
+	* Désactiver = retirer le transport de la boucle de fire (réf gardée dans
+	* {@link _disabledTransports}) → **0 surcoût hot path**. Activer = le remonter.
+	*
+	* Réversible et idempotent : un toggle vers l'état déjà courant renvoie `false`.
+	* N'instancie RIEN : ne peut réactiver qu'un transport préalablement désactivé
+	* (un transport jamais monté — ex. `loki` sans URL — exige sa config, pas ce toggle).
+	*
+	* @param name - `ITransport.name` ciblé.
+	* @param enabled - `true` = remonter, `false` = retirer.
+	* @returns `true` si l'état a changé, `false` sinon (déjà dans l'état / introuvable).
+	*/
+	setTransportEnabled(name, enabled) {
+		if (enabled) {
+			const t = this._disabledTransports?.get(name);
+			if (!t) return false;
+			this._disabledTransports.delete(name);
+			if (this._disabledTransports.size === 0) this._disabledTransports = null;
+			this.addTransport(t);
+			return true;
+		}
+		const idx = this._transports.findIndex((t) => t.name === name);
+		if (idx === -1) return false;
+		const [t] = this._transports.splice(idx, 1);
+		(this._disabledTransports ??= /* @__PURE__ */ new Map()).set(name, t);
+		return true;
+	}
+	_fireTransports(pdu) {
+		for (const t of this._transports) t.send(pdu).catch((err) => this.fire("onTransportError", err, pdu));
+	}
+	static _nativeConsole = {
+		log: console.log.bind(console),
+		info: console.info.bind(console),
+		warn: console.warn.bind(console),
+		error: console.error.bind(console),
+		debug: console.debug.bind(console),
+		trace: console.trace.bind(console),
+		table: console.table.bind(console),
+		dir: console.dir.bind(console)
+	};
+	static _savedConsole = null;
+	/** Largeur fixe du champ `severityName` — couvre `WARNING` (7). */
+	static SEVERITY_WIDTH = 7;
+	/** Largeur fixe du champ `msgid` — couvre 95% des cas, déborde proprement pour les longs. */
+	static MSGID_WIDTH = 18;
+	static wrapper(pdu) {
+		if (!pdu) throw new Error("Syslog pdu not defined");
+		const d = new Date(pdu.timeStamp);
+		const dateStr = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}.${String(d.getMilliseconds()).padStart(3, "0")}`;
+		const sev = pdu.severityName.padEnd(Syslog.SEVERITY_WIDTH);
+		const id = pdu.msgid.padEnd(Syslog.MSGID_WIDTH);
+		const msgid = green(id);
+		switch (pdu.severity) {
+			case 0:
+			case 1:
+			case 2:
+			case 3: return {
+				logger: Syslog._nativeConsole.error,
+				text: `${dateStr} ${red(sev)} ${msgid} : `
+			};
+			case 4: return {
+				logger: Syslog._nativeConsole.warn,
+				text: `${dateStr} ${yellow(sev)} ${msgid} : `
+			};
+			case 5: return {
+				logger: Syslog._nativeConsole.log,
+				text: `${dateStr} ${red(sev)} ${msgid} : `
+			};
+			case 6: return {
+				logger: Syslog._nativeConsole.info,
+				text: `${dateStr} ${blue(sev)} ${msgid} : `
+			};
+			case 7: return {
+				logger: Syslog._nativeConsole.debug,
+				text: `${dateStr} ${cyan(sev)} ${msgid} : `
+			};
+			default: return {
+				logger: Syslog._nativeConsole.log,
+				text: `${dateStr} ${cyan(sev)} ${msgid} : `
+			};
+		}
+	}
+	/**
+	* Transport console par défaut — formate un Pdu et l'écrit vers `process.stdout` ou
+	* `process.stderr` selon sévérité (ERROR+ vers stderr).
+	*
+	* Format : `HH:MM:SS.mmm SEVERITY MSGID : payload` avec coloration ANSI.
+	*
+	* @param pdu - Pdu à imprimer.
+	* @param pid - PID préfixé (vide en dev mono-process pour réduire le bruit).
+	* @returns le Pdu (chaînable).
+	*/
+	static normalizeLog(pdu, pid = "") {
+		if (pdu.payload === "" || pdu.payload === void 0) {
+			Syslog._nativeConsole.warn(`${pdu.severityName} ${pdu.msgid} : logger message empty !!!!`);
+			Syslog._nativeConsole.trace(pdu);
+			return pdu;
+		}
+		const message = pdu.payload;
+		const wrap = Syslog.wrapper(pdu);
+		const prefix = pid ? `${pid} ` : "";
+		wrap.logger(`${prefix}${wrap.text}`, message);
+		return pdu;
+	}
+	static rawLog(pdu, pid = "") {
+		if (pdu.payload === "" || pdu.payload === void 0) return pdu;
+		const write = pdu.severity <= 3 ? writeErr : writeOut;
+		const { text } = Syslog.wrapper(pdu);
+		const msg = typeof pdu.payload === "string" || typeof pdu.payload === "number" ? String(pdu.payload) : inspect(pdu.payload, {
+			depth: 3,
+			colors: isLogColorEnabled(),
+			breakLength: Infinity
+		});
+		write(`${pid ? `${pid} ` : ""}${text}${msg}\n`);
+		return pdu;
+	}
+	/**
+	* Mode de bufférisation de la sortie console — **process-global** (un seul
+	* `process.stdout`). Câblé par {@link Kernel.initializeLog} depuis `config.log.buffered`.
+	*
+	* - `"auto"` (défaut) : bufférise si stdout n'est PAS un TTY (pipe/fichier =
+	*   prod/collecteur → débit) ; immédiat sur TTY (dev interactif → feedback + spinner).
+	* - `true` : toujours bufférisé (ex. bench dans un terminal).
+	* - `false` : jamais (ex. `tail -f` non bufférisé en debug prod).
+	*
+	* Bufférisé = coalesce les écritures d'un même tick en 1 `write()` (1 syscall).
+	* stderr (ERROR+) reste TOUJOURS immédiat. Flush les lignes en attente avant de switcher.
+	*
+	* @param mode - `true` | `false` | `"auto"`.
+	*/
+	static setOutputBuffering(mode) {
+		_setBufferMode(mode);
+	}
+	/** Vide immédiatement (synchrone) le buffer stdout en attente. Idempotent. */
+	static flushOutput() {
+		_flushOut();
+	}
+	/**
+	* Bascule le DRIVER de sink (LB.W — où partent les lignes après coalescing).
+	* `null` → stdout (défaut isomorphe). Câblé par {@link Kernel.initializeLog}
+	* depuis `config.log.driver`. Flush + close l'ancien driver avant de switcher.
+	*
+	* @param sink - driver `ILogSink` (ex. `FileSink`, `NULL_LOG_SINK`) ou `null`.
+	*/
+	static setLogSink(sink) {
+		_setLogSink(sink);
+	}
+	/** Nom du driver de sink actif (`"stdout"` | `"null"` | `"file"` | custom). */
+	static get logSinkName() {
+		return _sink.name;
+	}
+	/** `true` si le sink texte écrit (non muté). Coupé = plus de console/fichier .log. */
+	static get sinkEnabled() {
+		return !_sinkMuted;
+	}
+	/**
+	* Mute/démute le sink texte **à chaud, sans changer la config ni le driver**
+	* (outil dev/diagnostic — ex. couper la console en `npx nodefony dev`). Le nom
+	* du sink est préservé ; seul {@link sinkEnabled} bascule. Process-global (un seul
+	* sink texte par process). Idempotent.
+	*
+	* @param enabled - `true` = le sink écrit ; `false` = mute (rien n'est écrit).
+	* @returns `true` si l'état a changé.
+	*/
+	static setSinkEnabled(enabled) {
+		const muted = !enabled;
+		if (_sinkMuted === muted) return false;
+		_sinkMuted = muted;
+		return true;
+	}
+	/**
+	* Intercepte `console.log/warn/error/debug/info` → pipe vers le Syslog passé.
+	*
+	* **Side effect global** : modifie l'objet `console` du process. À utiliser avec parcimonie
+	* (un seul appel par process). {@link restoreConsole} restaure les méthodes originales.
+	*
+	* @param instance - Syslog cible (recevra tous les console.* du process).
+	*/
+	static overrideConsole(instance) {
+		if (Syslog._savedConsole !== null) {
+			instance.log("Syslog.overrideConsole: already active", "WARNING");
+			return;
+		}
+		Syslog._savedConsole = {
+			log: console.log.bind(console),
+			info: console.info.bind(console),
+			warn: console.warn.bind(console),
+			error: console.error.bind(console),
+			debug: console.debug.bind(console),
+			trace: console.trace.bind(console),
+			table: console.table.bind(console),
+			dir: console.dir.bind(console)
+		};
+		const con = console;
+		con.log = (...data) => instance.print(...data);
+		con.info = (...data) => instance.logMultiple("INFO", ...data);
+		con.warn = (...data) => instance.logMultiple("WARNING", ...data);
+		con.error = (...data) => instance.logMultiple("ERROR", ...data);
+		con.debug = (...data) => instance.logMultiple("DEBUG", ...data);
+		con.table = (data) => instance.logMultiple("INFO", data);
+		con.dir = (obj) => instance.logMultiple("DEBUG", obj);
+	}
+	/**
+	* Restaure `console.log/warn/error/debug/info` à leurs valeurs originales.
+	* Annule un {@link overrideConsole} précédent.
+	*/
+	static restoreConsole() {
+		if (Syslog._savedConsole === null) return;
+		Object.assign(console, Syslog._savedConsole);
+		Syslog._savedConsole = null;
+	}
+});
+typeof process !== "undefined" && process.env?.NF_PERF_PROBE;
+//#endregion
+//#region src/cli/completion.ts
+/** Chemin du manifest cache — même dossier que le pidfile superviseur. */
+function cliManifestFile(cwd) {
+	return path.join(cwd, "node_modules", ".cache", "nodefony", "cli-manifest.json");
+}
+/** Lit le manifest cache — `null` si absent ou corrompu (jamais de throw). */
+function readCliManifest(cwd) {
+	try {
+		const raw = readFileSync(cliManifestFile(cwd), "utf8");
+		const parsed = JSON.parse(raw);
+		return Array.isArray(parsed.commands) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Calcule les candidats de complétion pour les mots tapés.
+*
+* Protocole : `words` = tous les mots APRÈS le nom du binaire, dernier mot inclus
+* même vide (les scripts shell le transmettent tel quel). Le DERNIER mot est celui
+* en cours de frappe → la sélection de commande ne regarde que les mots VALIDÉS
+* (`slice(0, -1)`), et le shell filtre les candidats par le préfixe courant.
+*
+* - commande déjà validée → les CHOIX de l'argument positionnel en cours (s'il
+*   en déclare, ex. `create` → `app`) + ses options + les options globales ;
+* - sinon → noms + alias de toutes les commandes.
+*/
+function computeCompletions(manifest, words) {
+	const validated = words.slice(0, -1);
+	for (let i = 0; i < validated.length; i++) {
+		const w = validated[i];
+		if (w.startsWith("-")) continue;
+		const cmd = manifest.commands.find((c) => c.name === w || c.aliases.includes(w));
+		if (cmd) {
+			const after = validated.slice(i + 1);
+			let pos = 0;
+			for (let j = 0; j < after.length; j++) {
+				if (after[j].startsWith("-")) continue;
+				if (j > 0 && after[j - 1].startsWith("-")) continue;
+				pos++;
+			}
+			const last = validated[validated.length - 1] ?? "";
+			const expected = cmd.optionValues?.[last];
+			if (expected) return expected;
+			return [
+				...cmd.args?.[pos] ?? [],
+				...cmd.options,
+				...manifest.globalOptions
+			];
+		}
+	}
+	return manifest.commands.flatMap((c) => [c.name, ...c.aliases]);
+}
+/** Shells supportés par `nodefony completion <shell>`. */
+const COMPLETION_SHELLS = [
+	"bash",
+	"zsh",
+	"fish"
+];
+`${COMPLETION_SHELLS.join("|")}`, `${COMPLETION_SHELLS.join("|")}`;
+//#endregion
+//#region src/runtime/engineEnvironment.ts
+/**
+* Le mode qu'une ligne de commande EXPRIME — détecté avant tout kernel.
+*
+* Pourquoi en amont : commander ne parse la sous-commande qu'au démarrage du
+* kernel, si bien que `this.environment` reste indéfini pendant les premières
+* lignes du boot. Plusieurs branches en dépendent, et elles ratent sans cette
+* pré-détection. Une commande non reconnue rend `undefined`, et le défaut
+* reprend la main.
+*
+* 🔴 **Seuls les mots de COMMANDE sont examinés — ceux qui précèdent la première
+* option.** La version précédente balayait l'argv ENTIER : n'importe quel mot,
+* où qu'il soit, décidait du mode. `nodefony doctor --env production` faisait
+* ainsi basculer tout le processus en production — il chargeait `.env.production`
+* et les modules de production pour répondre à une question sur le poste, et le
+* catalogue de l'application, refusant de se construire, retombait en silence
+* sur une version périmée. Un argument de valeur n'est pas une intention.
+*
+* Vit ici plutôt que dans le binaire : ce module est la source unique de « quel
+* mode », il est importable, et une règle qu'on ne peut pas importer est une
+* règle qu'on ne peut pas éprouver.
+*
+* @param argv - les arguments APRÈS le binaire (`process.argv.slice(2)`).
+* @returns le mode exprimé par la commande, ou `undefined` si elle n'en exprime aucun.
+*/
+function detectEnvironmentFromArgv(argv) {
+	for (const a of argv) {
+		if (a.startsWith("-")) break;
+		if (a === "development" || a === "dev") return "development";
+		if (a === "production" || a === "prod" || a === "start") return "production";
+		if (a === "cluster") return "production";
+	}
+}
+//#endregion
+//#region src/bin/nodefony.ts
+/**
+* Résout le **mode runtime** (dev/prod) AVANT le kernel : `NODE_ENV` (ambiant)
+* PRIME sur l'intention de la commande (argv).
+*
+* ⚠️ **Ce n'est pas « le 12-factor » qui l'impose, et l'écrire était faux.** Sa
+* section *Config* REJETTE au contraire les groupes d'environnement : « In a
+* twelve-factor app, env vars are granular controls […] They are never grouped
+* together as "environments" ». `NODE_ENV` est précisément ce qu'elle
+* déconseille. Ce qui relève d'elle ici est la seule PRÉCÉDENCE — la
+* configuration ambiante l'emporte sur ce que la commande croit savoir.
+*
+* Ce qui garantit le mode en production est FACTUEL : Node.js le recommande
+* (« Always run your Node.js with NODE_ENV=production set »), l'image générée
+* pose `ENV NODE_ENV=production`, et les lanceurs déclarent leur intention. Miroir pur de `Kernel.resolveRuntimeEnv`, mais sans instance (le bin tourne
+* avant `new CliKernel()`) et autorisé à rendre `undefined` (aucun `.env.<env>` chargé
+* si ni NODE_ENV ni commande connue — ex. `nodefony frontend:build` hors contexte env).
+*/
+function resolveRuntimeEnv(argv) {
+	const node = process.env.NODE_ENV;
+	if (node === "dev" || node === "development") return "development";
+	if (node === "prod" || node === "production") return "production";
+	return detectEnvironmentFromArgv(argv);
+}
+/** Trace la décision du lanceur (opt-in `NF_CLI_DEBUG=1`, jamais par défaut). */
+function traceDecision(decision, selfDir) {
+	if (!process.env[DEBUG_ENV]) return;
+	const target = decision.delegate ?? `${selfDir} (soi-même — ${decision.reason})`;
+	process.stderr.write(`[nodefony] cli → ${target}\n`);
+}
+/**
+* Boote le CLI de CE paquet. Les imports du core sont **dynamiques** : quand le
+* lanceur délègue à l'app, le core de ce paquet-ci ne doit jamais être chargé
+* (sinon deux frameworks en mémoire, et le coût de boot payé deux fois).
+*/
+async function runSelf() {
+	if (process.argv[2] === "__complete") try {
+		const cached = readCliManifest(process.cwd());
+		if (cached) {
+			const sep = process.argv.indexOf("--");
+			const candidates = computeCompletions(cached, sep >= 0 ? process.argv.slice(sep + 1) : []);
+			if (candidates.length > 0) process.stdout.write(`${candidates.join("\n")}\n`);
+			return exit(0);
+		}
+	} catch {}
+	const { CliKernel, loadEnv } = await import("nodefony");
+	const runtimeEnv = resolveRuntimeEnv(process.argv.slice(2));
+	const appEnv = process.env.APP_ENV ?? process.env.NF_ENV;
+	if (runtimeEnv) process.env.NODE_ENV = runtimeEnv;
+	loadEnv({
+		runtimeEnv,
+		appEnv
+	});
+	return new CliKernel(runtimeEnv).start().catch((e) => {
+		exit(e.code || 1);
+	});
+}
+/**
+* Point d'entrée du binaire `nodefony` — **le CLI de l'application prime**.
+*
+* Le binaire global (`npm i -g nodefony`) est la porte d'entrée du framework : il
+* crée les applications. Mais une fois DANS une app, la version qui fait autorité
+* est celle des `node_modules` du projet : c'est elle qui connaît ses modules, ses
+* scaffolds et ses commandes. Le lanceur remonte donc au projet et, s'il y trouve
+* un autre paquet `nodefony` que lui-même, lui passe la main (`import` du binaire
+* du projet, dans le même process — ni spawn, ni double kernel).
+*
+* Une install cassée (paquet présent, binaire absent) échoue **bruyamment** : on ne
+* pilote pas une app avec une version de framework qu'elle n'a pas choisie.
+*/
+const selfDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const decision = resolveLocalCli({
+	cwd: process.cwd(),
+	selfDir,
+	env: process.env
+});
+traceDecision(decision, selfDir);
+if (decision.reason === "local-cli-broken") {
+	process.stderr.write(`nodefony: ${decision.detail}\n           (projet : ${decision.projectRoot})\n`);
+	exit(1);
+}
+let kernel;
+if (decision.delegate) {
+	process.env[DELEGATED_ENV] = "1";
+	kernel = await import(pathToFileURL(decision.delegate).href);
+} else kernel = await runSelf();
+var nodefony_default = kernel;
+//#endregion
+export { nodefony_default as default };