nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/syslog/Syslog.js

@@ -0,0 +1,1159 @@
+import { isLogColorEnabled, logColor } from "./logColor.js";
+import { extend } from "../Tools.js";
+import Event from "../Event.js";
+import Pdu from "./Pdu.js";
+import { inspect } from "node:util";
+//#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);
+};
+/**
+* Hub central de logs structurés de Nodefony — conforme RFC 5424.
+*
+* Reçoit des {@link Pdu} via {@link log}, les pousse dans un ring buffer (`CircularBuffer`,
+* O(1)), applique les filtres ({@link listenWithConditions}), et fire `"onLog"` pour les
+* transports branchés (console, file, JSON, SSE Studio).
+*
+* Hérite d'{@link Event} (EventEmitter étendu) → toute brique du framework peut s'abonner.
+*
+* Modes :
+* - **rateLimit** + **burstLimit** : protection anti-flood (ex: boucle qui log 10k/s)
+* - **async** : fire `"onLog"` sur next tick (libère le hot path) ou inline
+* - **overrideConsole** : intercepte `console.log/warn/error/debug/info` → pipe vers Syslog
+*
+* @example
+* ```ts
+* const syslog = new Syslog({ moduleName: "MyApp", defaultSeverity: "INFO" });
+* syslog.on("onLog", (pdu: Pdu) => console.log(pdu.toString()));
+* syslog.log("hello world", "INFO");
+* ```
+*
+* @remarks Utilisé par défaut par chaque {@link Service} via `this.syslog`. Pour les apps
+*   complexes, partager un Syslog unique entre services évite de dupliquer les buffers.
+*/
+var Syslog = 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;
+	}
+};
+//#endregion
+export { NULL_LOG_SINK, Syslog as default };