logixia 1.12.4 → 1.12.6

package/dist/{logitron-logger.module-BIGTm2V6.mjs → logitron-logger.module-Bs3XYZgF.mjs}

@@ -1,74 +1,16 @@
-import { d as internalError, f as internalLog, m as __require, p as internalWarn, t as TransportManager, u as safeToString } from "./transport.manager-DETpXuaY.mjs";
-import buildFastStringify from "fast-json-stringify";
+import { t as __require } from "./chunk-DLSkYcPk.mjs";
+import { n as internalLog, r as internalWarn, t as internalError } from "./internal-log-Cm8SOWSV.mjs";
+import { i as stringifyForLog } from "./safe-stringify-DJ66tW5I.mjs";
+import { t as LogixiaContext } from "./async-context-CwBNMm2E.mjs";
+import { t as safeToString } from "./coerce.utils-Dxv4_ikC.mjs";
+import { t as TransportManager } from "./transport.manager-D6KL3t9V.mjs";
+import { constants } from "node:os";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID } from "node:crypto";
+import buildFastStringify from "fast-json-stringify";
 import crypto from "crypto";
 import { Injectable, Module, Optional, RequestMethod, Scope } from "@nestjs/common";
 import { EMPTY, Observable } from "rxjs";
 
-//#region src/context/async-context.ts
-/** Generates an 8-character random ID using Node's crypto module. */
-function randomShortId() {
-	return randomUUID().slice(0, 8);
-}
-const _storage = new AsyncLocalStorage();
-const LogixiaContext = {
-	run(store, callback) {
-		const parent = _storage.getStore() ?? {};
-		return _storage.run({
-			...parent,
-			...store
-		}, callback);
-	},
-	get() {
-		return _storage.getStore();
-	},
-	set(fields) {
-		const store = _storage.getStore();
-		if (!store) return;
-		Object.assign(store, fields);
-	},
-	getStorage() {
-		return _storage;
-	}
-};
-/**
-* Create an Express/Connect-compatible middleware that wraps each request in
-* a `LogixiaContext.run()` scope populated with common request fields.
-*
-* @example
-* ```ts
-* import { createExpressContextMiddleware } from 'logixia';
-* app.use(createExpressContextMiddleware());
-* ```
-*/
-function createExpressContextMiddleware(options = {}) {
-	const { enrich, traceIdHeader = "x-trace-id" } = options;
-	return function logixiaContextMiddleware(req, _res, next) {
-		const base = { traceId: (req["headers"] ?? {})[traceIdHeader] ?? randomShortId() };
-		LogixiaContext.run({
-			...base,
-			...enrich ? enrich(req) : {}
-		}, next);
-	};
-}
-/**
-* Create a Fastify lifecycle hook that wraps each request in a context scope.
-*
-* Register with `fastify.addHook('onRequest', createFastifyContextHook())`.
-*/
-function createFastifyContextHook(options = {}) {
-	const { enrich, traceIdHeader = "x-trace-id" } = options;
-	return function logixiaFastifyHook(request, _reply, done) {
-		const base = { traceId: (request["headers"] ?? {})[traceIdHeader] ?? request["id"] ?? randomShortId() };
-		LogixiaContext.run({
-			...base,
-			...enrich ? enrich(request) : {}
-		}, done);
-	};
-}
-
-//#endregion
 //#region src/plugin.ts
 /**
 * Holds an ordered list of `LogixiaPlugin` instances and dispatches lifecycle
@@ -566,7 +508,7 @@ function pathToRegExp(pattern) {
 		}
 		regexStr += segment === "*" ? "[^.]+" : segment.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&");
 	}
-	return /* @__PURE__ */ new RegExp(`^${regexStr}$`);
+	return new RegExp(`^${regexStr}$`, "i");
 }
 /** Pre-compiled path matchers keyed by pattern string for perf */
 const patternCache = /* @__PURE__ */ new Map();
@@ -583,34 +525,66 @@ function applyPatterns(value, patterns, censor) {
 	for (const pattern of patterns) redacted = redacted.replace(pattern, censor);
 	return redacted;
 }
-function redactArrayItem(item, config, fullPath, skipPatternScan) {
-	if (isPlainObject(item)) return redactObject(item, config, fullPath);
-	const { patterns = [], censor = DEFAULT_CENSOR } = config;
-	if (!skipPatternScan && typeof item === "string" && patterns.length > 0) return applyPatterns(item, patterns, censor);
-	return item;
+const CIRCULAR = "[Circular]";
+function joinPath(parent, key) {
+	return parent ? `${parent}.${key}` : key;
 }
-function redactField(value, config, fullPath) {
-	const { paths = [], excludePaths = [], patterns = [], censor = DEFAULT_CENSOR } = config;
-	if (paths.some((p) => matchesPath(fullPath, p))) return censor;
-	if (isPlainObject(value)) return redactObject(value, config, fullPath);
-	const skipPatternScan = excludePaths.some((p) => matchesPath(fullPath, p));
-	if (!skipPatternScan && typeof value === "string" && patterns.length > 0) return applyPatterns(value, patterns, censor);
-	if (Array.isArray(value)) return value.map((item) => redactArrayItem(item, config, fullPath, skipPatternScan));
+function walkValue(value, state, fullPath, bare) {
+	const { paths = [], excludePaths = [], patterns = [], censor = DEFAULT_CENSOR } = state.config;
+	if (paths.some((p) => matchesPath(fullPath, p) || matchesPath(bare, p))) return censor;
+	if (typeof value === "string") {
+		if (patterns.length === 0) return value;
+		if (excludePaths.some((p) => matchesPath(fullPath, p) || matchesPath(bare, p))) return value;
+		return applyPatterns(value, patterns, censor);
+	}
+	if (Array.isArray(value)) return walkContainer(value, state, fullPath, bare, walkArray);
+	if (isPlainObject(value)) return walkContainer(value, state, fullPath, bare, walkRecord);
 	return value;
 }
+function walkContainer(value, state, fullPath, bare, walk) {
+	if (state.ancestors.has(value)) return CIRCULAR;
+	state.ancestors.add(value);
+	try {
+		return walk(value, state, fullPath, bare);
+	} finally {
+		state.ancestors.delete(value);
+	}
+}
 /**
-* Deep-clone and redact an object according to the given RedactConfig.
-* Non-objects are returned as-is (with pattern replacement on strings).
-*
-* The function is intentionally non-mutating — it returns a new object.
+* Array elements are matched by their indexed path (`users.0.password`) and by
+* the index-free path (`users.password`) that earlier versions used.
+*/
+function walkArray(arr, state, fullPath, bare) {
+	let result;
+	for (const [i, item] of arr.entries()) {
+		const next = walkValue(item, state, joinPath(fullPath, String(i)), bare);
+		if (next !== item && !result) result = arr.slice(0, i);
+		if (result) result.push(next);
+	}
+	return result ?? arr;
+}
+function walkRecord(obj, state, fullPath, bare) {
+	let result;
+	const entries = Object.entries(obj);
+	for (const [index, [key, value]] of entries.entries()) {
+		const forbidden = key === "__proto__" || key === "constructor" || key === "prototype";
+		const next = forbidden ? void 0 : walkValue(value, state, joinPath(fullPath, key), joinPath(bare, key));
+		if ((forbidden || next !== value) && !result) result = Object.fromEntries(entries.slice(0, index));
+		if (result && !forbidden) result[key] = next;
+	}
+	return result ?? obj;
+}
+/**
+* Redact an object according to the given RedactConfig and return a new
+* top-level object. Subtrees with nothing to redact are shared with the input,
+* never mutated. Circular references become `[Circular]`.
 */
 function redactObject(obj, config, _currentPath = "") {
-	const result = {};
-	for (const [key, value] of Object.entries(obj)) {
-		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
-		result[key] = redactField(value, config, _currentPath ? `${_currentPath}.${key}` : key);
-	}
-	return result;
+	const result = walkRecord(obj, {
+		config,
+		ancestors: new Set([obj])
+	}, _currentPath, _currentPath);
+	return result === obj ? { ...obj } : result;
 }
 /**
 * Apply pattern-based redaction to a single string (e.g. the log message).
@@ -637,8 +611,25 @@ function applyRedaction(payload, config) {
 	if ((!resolved.paths || resolved.paths.length === 0) && (!resolved.patterns || resolved.patterns.length === 0)) return payload;
 	return redactObject(payload, resolved);
 }
+const OPAQUE_BUILTINS = [
+	Date,
+	Error,
+	RegExp,
+	URL,
+	URLSearchParams,
+	ArrayBuffer,
+	DataView,
+	Map,
+	Set,
+	WeakMap,
+	WeakSet,
+	Promise
+];
+/** Plain objects and class instances are walked; built-ins are left alone. */
 function isPlainObject(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Error) && !(value instanceof RegExp);
+	if (value === null || typeof value !== "object") return false;
+	if (ArrayBuffer.isView(value)) return false;
+	return !OPAQUE_BUILTINS.some((ctor) => value instanceof ctor);
 }
 
 //#endregion
@@ -650,12 +641,14 @@ const ALWAYS_EMIT_LEVELS = new Set([
 ]);
 var Sampler = class {
 	constructor(config, onStats) {
-		this.sampledTraces = /* @__PURE__ */ new Set();
-		this.droppedTraces = /* @__PURE__ */ new Set();
+		this.traceDecisions = /* @__PURE__ */ new Map();
 		this.maxTrackedTraces = 1e5;
+		this.traceTtlMs = 5 * 6e4;
 		this._tokenBucket = 0;
 		this._lastRefillMs = Date.now();
 		this._adaptiveWindow = [];
+		this._adaptiveHead = 0;
+		this._adaptiveErrors = 0;
 		this._stats = {
 			evaluated: 0,
 			emitted: 0,
@@ -690,23 +683,7 @@ var Sampler = class {
 			this._trackEmitted(lvl);
 			return true;
 		}
-		if (this.config.traceConsistent && traceId) {
-			if (this.sampledTraces.has(traceId)) {
-				this._trackEmitted(lvl);
-				return true;
-			}
-			if (this.droppedTraces.has(traceId)) {
-				this._trackDropped(lvl);
-				return false;
-			}
-			const emit = this._sampleByRate(lvl);
-			if (emit) this._rememberTrace(this.sampledTraces, traceId);
-			else this._rememberTrace(this.droppedTraces, traceId);
-			if (emit) this._trackEmitted(lvl);
-			else this._trackDropped(lvl);
-			return emit;
-		}
-		if (!this._sampleByRate(lvl)) {
+		if (!(this.config.traceConsistent && traceId ? this._decideForTrace(traceId, lvl) : this._sampleByRate(lvl))) {
 			this._trackDropped(lvl);
 			return false;
 		}
@@ -733,8 +710,6 @@ var Sampler = class {
 			byLevel: {},
 			windowStart: Date.now()
 		};
-		this.sampledTraces.clear();
-		this.droppedTraces.clear();
 	}
 	destroy() {
 		if (this._statsTimer) clearInterval(this._statsTimer);
@@ -747,20 +722,27 @@ var Sampler = class {
 		if (rate <= 0) return false;
 		return Math.random() < rate;
 	}
-	/**
-	* Record one evaluated sample into the adaptive sliding window and evict
-	* entries older than the window. Cheap O(evicted) amortized.
-	*/
+	/** Record one evaluated sample and evict entries older than the window. O(1) amortized. */
 	_recordAdaptiveSample(level) {
 		var _this$config$adaptive;
 		const now = Date.now();
 		const windowMs = ((_this$config$adaptive = this.config.adaptive) === null || _this$config$adaptive === void 0 ? void 0 : _this$config$adaptive.windowMs) ?? 1e4;
+		const err = level === "error" || level === "fatal";
 		this._adaptiveWindow.push({
 			t: now,
-			err: level === "error" || level === "fatal"
+			err
 		});
+		if (err) this._adaptiveErrors += 1;
 		const cutoff = now - windowMs;
-		while (this._adaptiveWindow.length > 0 && this._adaptiveWindow[0].t < cutoff) this._adaptiveWindow.shift();
+		const win = this._adaptiveWindow;
+		while (this._adaptiveHead < win.length && win[this._adaptiveHead].t < cutoff) {
+			if (win[this._adaptiveHead].err) this._adaptiveErrors -= 1;
+			this._adaptiveHead += 1;
+		}
+		if (this._adaptiveHead >= 1024 && this._adaptiveHead * 2 >= win.length) {
+			this._adaptiveWindow = win.slice(this._adaptiveHead);
+			this._adaptiveHead = 0;
+		}
 	}
 	/**
 	* Effective boost rate (0 = no boost). Returns the configured boostRate when
@@ -771,25 +753,39 @@ var Sampler = class {
 		const cfg = this.config.adaptive;
 		if (!cfg) return 0;
 		const minSamples = cfg.minSamples ?? 20;
-		const total = this._adaptiveWindow.length;
+		const total = this._adaptiveWindow.length - this._adaptiveHead;
 		if (total < minSamples) return 0;
-		let errors = 0;
-		for (const s of this._adaptiveWindow) if (s.err) errors += 1;
-		return errors / total >= (cfg.errorRateThreshold ?? .05) ? cfg.boostRate ?? 1 : 0;
+		return this._adaptiveErrors / total >= (cfg.errorRateThreshold ?? .05) ? cfg.boostRate ?? 1 : 0;
 	}
 	/** @internal Expose the current adaptive boost decision (tests / observability). */
 	isBoosting() {
 		return this._adaptiveBoostRate() > 0;
 	}
 	/**
-	* Record a trace decision, bounding the Set so it can't grow without limit.
-	* If the Set has reached the cap, clear it before inserting — stale decisions
-	* are simply re-made on next sight, which keeps memory bounded at the cost of
-	* occasional re-sampling for very high-cardinality trace workloads.
+	* Return the cached decision for a trace, or make and cache a new one. Entries
+	* idle past the TTL are re-decided; the least recently used entry is evicted
+	* once the cap is reached.
 	*/
-	_rememberTrace(set, traceId) {
-		if (set.size >= this.maxTrackedTraces) set.clear();
-		set.add(traceId);
+	_decideForTrace(traceId, level) {
+		const now = Date.now();
+		const known = this.traceDecisions.get(traceId);
+		if (known && now - known.seenAt <= this.traceTtlMs) {
+			this.traceDecisions.delete(traceId);
+			known.seenAt = now;
+			this.traceDecisions.set(traceId, known);
+			return known.emit;
+		}
+		const emit = this._sampleByRate(level);
+		this.traceDecisions.delete(traceId);
+		this.traceDecisions.set(traceId, {
+			emit,
+			seenAt: now
+		});
+		if (this.traceDecisions.size > this.maxTrackedTraces) {
+			const oldest = this.traceDecisions.keys().next().value;
+			if (oldest !== void 0) this.traceDecisions.delete(oldest);
+		}
+		return emit;
 	}
 	_consumeToken() {
 		const now = Date.now();
@@ -826,6 +822,7 @@ var Sampler = class {
 
 //#endregion
 //#region src/utils/shutdown.utils.ts
+const MAX_BEFORE_EXIT_FLUSHES = 5;
 /** Module-level registry of all logger instances that have opted into graceful shutdown */
 const registry = /* @__PURE__ */ new Set();
 let shutdownHandlerRegistered = false;
@@ -836,10 +833,16 @@ let shutdownInProgress = false;
 /** Our own handler + the signals we attached it to, so reset() can detach exactly it. */
 let activeHandler;
 let activeSignals = [];
+let activeOptions;
+let beforeExitHandler;
 /**
 * Register a logger instance so it is included in the graceful shutdown flush.
 * Called automatically when `gracefulShutdown: true` is set in logger config.
 */
+/** Test helper: number of loggers currently registered for graceful shutdown. */
+function _shutdownRegistrySize() {
+	return registry.size;
+}
 function registerForShutdown(logger) {
 	registry.add(logger);
 }
@@ -851,7 +854,11 @@ function deregisterFromShutdown(logger) {
 }
 /**
 * Register SIGTERM / SIGINT handlers that flush all registered loggers before
-* the process exits. Idempotent — calling multiple times is safe.
+* the process exits. Idempotent — the first call wins and later calls with
+* conflicting options print a warning. The process is ended with 128 + signal
+* number only when logixia's handler is the sole listener for that signal (see
+* `exit`); otherwise it just flushes and leaves shutdown to the application.
+* Loggers are also flushed (not closed) on `beforeExit`.
 *
 * @example
 * ```ts
@@ -860,28 +867,64 @@ function deregisterFromShutdown(logger) {
 * ```
 */
 function flushOnExit(options = {}) {
-	if (shutdownHandlerRegistered) return;
+	if (shutdownHandlerRegistered) {
+		warnOnConflict(activeOptions, options);
+		return;
+	}
 	shutdownHandlerRegistered = true;
-	const { timeout = 5e3, signals = ["SIGTERM", "SIGINT"], beforeFlush, afterFlush } = options;
+	activeOptions = options;
+	const { timeout = 5e3, signals = ["SIGTERM", "SIGINT"], beforeFlush, afterFlush, exit = "auto" } = options;
+	const shouldExit = (signal) => exit === "always" || exit === "auto" && process.listenerCount(signal) <= 1;
 	const handler = async (signal) => {
 		if (shutdownInProgress) return;
 		shutdownInProgress = true;
-		const forceExitTimer = setTimeout(() => {
+		const forceExitTimer = shouldExit(signal) ? setTimeout(() => {
 			process.stderr.write(`[logixia] Graceful shutdown timed out after ${timeout}ms on ${signal}. Force-exiting.\n`);
 			process.exit(1);
-		}, timeout).unref();
+		}, timeout).unref() : void 0;
 		try {
 			if (beforeFlush) await beforeFlush();
 			await Promise.allSettled([...registry].map((logger) => logger.close()));
 			if (afterFlush) await afterFlush();
+		} catch (err) {
+			process.stderr.write(`[logixia] Shutdown hook failed: ${String(err)}\n`);
 		} finally {
 			clearTimeout(forceExitTimer);
-			process.exit(0);
+			if (shouldExit(signal)) process.exit(128 + (constants.signals[signal] ?? 0));
+			shutdownInProgress = false;
 		}
 	};
 	activeHandler = handler;
 	activeSignals = signals;
 	for (const signal of signals) process.on(signal, activeHandler);
+	let beforeExitFlushes = 0;
+	let beforeExitFlushing = false;
+	beforeExitHandler = () => {
+		if (beforeExitFlushing || shutdownInProgress || beforeExitFlushes >= MAX_BEFORE_EXIT_FLUSHES) return;
+		beforeExitFlushing = true;
+		beforeExitFlushes += 1;
+		Promise.allSettled([...registry].map((logger) => {
+			var _logger$flush;
+			return (_logger$flush = logger.flush) === null || _logger$flush === void 0 ? void 0 : _logger$flush.call(logger);
+		})).finally(() => {
+			beforeExitFlushing = false;
+		});
+	};
+	process.on("beforeExit", beforeExitHandler);
+}
+function warnOnConflict(active, next) {
+	if (!active) return;
+	const conflicts = [];
+	if (next.timeout !== void 0 && next.timeout !== (active.timeout ?? 5e3)) conflicts.push("timeout");
+	if (next.exit !== void 0 && next.exit !== (active.exit ?? "auto")) conflicts.push("exit");
+	if (next.signals !== void 0) {
+		const current = new Set(active.signals ?? ["SIGTERM", "SIGINT"]);
+		if (next.signals.length !== current.size || next.signals.some((sig) => !current.has(sig))) conflicts.push("signals");
+	}
+	if (next.beforeFlush && next.beforeFlush !== active.beforeFlush) conflicts.push("beforeFlush");
+	if (next.afterFlush && next.afterFlush !== active.afterFlush) conflicts.push("afterFlush");
+	if (conflicts.length === 0) return;
+	process.stderr.write(`[logixia] flushOnExit was already configured; ignoring conflicting options: ${conflicts.join(", ")}.\n`);
 }
 /**
 * Remove all graceful shutdown handlers and clear the registry.
@@ -890,8 +933,11 @@ function flushOnExit(options = {}) {
 function resetShutdownHandlers() {
 	registry.clear();
 	if (activeHandler) for (const signal of activeSignals) process.removeListener(signal, activeHandler);
+	if (beforeExitHandler) process.removeListener("beforeExit", beforeExitHandler);
+	beforeExitHandler = void 0;
 	activeHandler = void 0;
 	activeSignals = [];
+	activeOptions = void 0;
 	shutdownHandlerRegistered = false;
 	shutdownInProgress = false;
 }
@@ -1261,18 +1307,29 @@ function matchesNamespacePattern(ns, pattern) {
 			_nsCacheEvictionCount++;
 			if (!_nsCacheEvictionWarned) {
 				_nsCacheEvictionWarned = true;
-				process.stderr.write(`[logixia] namespace pattern cache hit ${_NS_CACHE_MAX} entries — evicting. This usually means dynamic/unique patterns are being registered at runtime; review your levelOptions.namespaces configuration.\n`);
+				internalWarn(`namespace pattern cache hit ${_NS_CACHE_MAX} entries — evicting. This usually means dynamic/unique patterns are being registered at runtime; review your levelOptions.namespaces configuration.`);
 			}
 		}
 		_nsPatternCache.set(pattern, re);
 	}
 	return re.test(ns);
 }
+/**
+* Map a level name onto a known level key: exact match first (so custom levels
+* keep their declared casing), then lower case (so `DEBUG` → `debug`).
+*/
+function canonicalLevel(level, known) {
+	if (typeof level !== "string") return void 0;
+	if (known.has(level)) return level;
+	const lower = level.toLowerCase();
+	return known.has(lower) ? lower : void 0;
+}
 function resolveInitialLevel(config) {
-	var _config$levelOptions;
+	var _config$levelOptions, _config$levelOptions2;
 	const envLevel = process.env["LOGIXIA_LEVEL"];
-	if (envLevel) return envLevel;
-	if ((_config$levelOptions = config.levelOptions) === null || _config$levelOptions === void 0 ? void 0 : _config$levelOptions.level) return config.levelOptions.level;
+	const knownLevels = new Set([...Object.values(LogLevel), ...Object.keys(((_config$levelOptions = config.levelOptions) === null || _config$levelOptions === void 0 ? void 0 : _config$levelOptions.levels) ?? {})]);
+	if (envLevel && canonicalLevel(envLevel, knownLevels)) return envLevel;
+	if ((_config$levelOptions2 = config.levelOptions) === null || _config$levelOptions2 === void 0 ? void 0 : _config$levelOptions2.level) return config.levelOptions.level;
 	const nodeEnv = process.env["NODE_ENV"];
 	if (nodeEnv === "development") return LogLevel.DEBUG;
 	if (nodeEnv === "test") return LogLevel.WARN;
@@ -1281,20 +1338,22 @@ function resolveInitialLevel(config) {
 	return LogLevel.INFO;
 }
 var LogixiaLogger = class LogixiaLogger {
-	constructor(config, context) {
+	constructor(config, context, parent) {
 		this.timers = /* @__PURE__ */ new Map();
 		this.contextData = {};
 		this.fieldState = /* @__PURE__ */ new Map();
 		this.fallbackTraceId = TraceContext.instance.generate();
 		this._levelValues = /* @__PURE__ */ new Map();
 		this._minLevelValue = 2;
+		this._warnedInvalidLevels = /* @__PURE__ */ new Set();
 		this._colorMap = /* @__PURE__ */ new Map();
 		this._fieldCache = /* @__PURE__ */ new Map();
 		this._hasContextData = false;
 		this._formattedLevels = /* @__PURE__ */ new Map();
 		this._formattedAppName = "";
 		this._hasRedact = false;
-		this._pluginRegistry = new PluginRegistry();
+		this._parent = parent;
+		this._pluginRegistry = parent ? parent._pluginRegistry : new PluginRegistry();
 		this.config = {
 			appName: "App",
 			environment: "development",
@@ -1341,7 +1400,10 @@ var LogixiaLogger = class LogixiaLogger {
 			timeTaken: "[time_taken_MS]"
 		};
 		this.context = context ?? "";
-		if (this.config.transports) {
+		if (parent) {
+			this.transportManager = parent.transportManager;
+			this._sampler = parent._sampler;
+		} else if (this.config.transports) {
 			var _this$config$levelOpt;
 			const transportsWithColors = { ...this.config.transports };
 			const userColors = (_this$config$levelOpt = this.config.levelOptions) === null || _this$config$levelOpt === void 0 ? void 0 : _this$config$levelOpt.colors;
@@ -1351,16 +1413,16 @@ var LogixiaLogger = class LogixiaLogger {
 			};
 			this.transportManager = new TransportManager(transportsWithColors);
 		}
-		if (this.config.sampling) this._sampler = new Sampler(this.config.sampling, (stats) => {
+		if (!parent && this.config.sampling) this._sampler = new Sampler(this.config.sampling, (stats) => {
 			process.stdout.write(JSON.stringify({
 				level: "info",
 				message: "[logixia/sampling] stats",
 				...stats
 			}) + "\n");
 		});
-		this.setupGracefulShutdown();
+		if (!parent) this.setupGracefulShutdown();
 		this.createCustomLevelMethods();
-		for (const p of globalPluginRegistry._plugins) this._pluginRegistry.register(p);
+		if (!parent) for (const p of globalPluginRegistry._plugins) this._pluginRegistry.register(p);
 		this._buildPerfCaches();
 	}
 	setupGracefulShutdown() {
@@ -1371,7 +1433,8 @@ var LogixiaLogger = class LogixiaLogger {
 		registerForShutdown(this);
 		flushOnExit({
 			timeout: normalized.timeout ?? 5e3,
-			signals: normalized.signals ?? ["SIGTERM", "SIGINT"]
+			signals: normalized.signals ?? ["SIGTERM", "SIGINT"],
+			...normalized.exit ? { exit: normalized.exit } : {}
 		});
 	}
 	createCustomLevelMethods() {
@@ -1398,6 +1461,8 @@ var LogixiaLogger = class LogixiaLogger {
 			[LogLevel.VERBOSE, 5],
 			...customLevelEntries
 		]);
+		this.config.levelOptions = this.config.levelOptions ?? {};
+		this.config.levelOptions.level = this._validLevel(this.config.levelOptions.level, "levelOptions.level") ?? LogLevel.INFO;
 		const effectiveLevel = this.resolveEffectiveLevel();
 		this._minLevelValue = this._levelValues.get(effectiveLevel) ?? 2;
 		this._colorMap = new Map([
@@ -1533,15 +1598,39 @@ var LogixiaLogger = class LogixiaLogger {
 		}
 	}
 	setLevel(level) {
+		const canonical = canonicalLevel(level, this._levelValues);
+		if (canonical === void 0) {
+			internalWarn(`setLevel: unknown log level '${String(level)}' ignored; valid levels: ${this._validLevelList()}. Keeping '${this.getLevel()}'.`);
+			return;
+		}
 		this.config.levelOptions = this.config.levelOptions ?? {};
-		this.config.levelOptions.level = level;
-		this._minLevelValue = this._levelValues.get(level) ?? this._minLevelValue;
+		this.config.levelOptions.level = canonical;
+		this._minLevelValue = this._levelValues.get(canonical) ?? this._minLevelValue;
 		this._buildPerfCaches();
 	}
 	getLevel() {
 		var _this$config$levelOpt5;
 		return ((_this$config$levelOpt5 = this.config.levelOptions) === null || _this$config$levelOpt5 === void 0 ? void 0 : _this$config$levelOpt5.level) ?? LogLevel.INFO;
 	}
+	_validLevelList() {
+		return [...this._levelValues.keys()].join(", ");
+	}
+	/**
+	* Canonicalise a level from config/ENV. Unknown values return undefined so the
+	* caller falls through to the next source, and warn once per logger per source.
+	*/
+	_validLevel(level, source) {
+		if (level === void 0 || level === "") return void 0;
+		const canonical = canonicalLevel(level, this._levelValues);
+		if (canonical === void 0) {
+			const key = `${source}=${String(level)}`;
+			if (!this._warnedInvalidLevels.has(key)) {
+				this._warnedInvalidLevels.add(key);
+				internalWarn(`Unknown log level '${String(level)}' from ${source}; valid levels: ${this._validLevelList()}. Falling back to the next level source (default '${LogLevel.INFO}').`);
+			}
+		}
+		return canonical;
+	}
 	/**
 	* Replace the per-namespace level map at runtime — no restart needed.
 	*
@@ -1616,10 +1705,12 @@ var LogixiaLogger = class LogixiaLogger {
 		this.fieldState.clear();
 		internalLog("Field state reset to configuration defaults");
 	}
+	/** @deprecated No-op. Library code never prompts on stdin; use setTransportLevels(). */
 	enableTransportLevelPrompting() {
 		if (this.transportManager) this.transportManager.enableLevelPrompting();
 		else internalWarn("Transport manager not initialized");
 	}
+	/** @deprecated No-op. */
 	disableTransportLevelPrompting() {
 		if (this.transportManager) this.transportManager.disableLevelPrompting();
 		else internalWarn("Transport manager not initialized");
@@ -1641,7 +1732,7 @@ var LogixiaLogger = class LogixiaLogger {
 		return ((_this$transportManage = this.transportManager) === null || _this$transportManage === void 0 ? void 0 : _this$transportManage.getTransports()) ?? [];
 	}
 	child(context, data) {
-		const childLogger = new LogixiaLogger(this.config, context);
+		const childLogger = new LogixiaLogger(this.config, context, this);
 		const mergedContextData = {
 			...this.contextData,
 			...data
@@ -1692,6 +1783,7 @@ var LogixiaLogger = class LogixiaLogger {
 			duration: `${Date.now() - timer.startTime}ms (incomplete)`
 		});
 		this.timers.clear();
+		if (this._parent) return;
 		if (this.transportManager) await this.transportManager.close();
 		(_this$_sampler = this._sampler) === null || _this$_sampler === void 0 || _this$_sampler.destroy();
 		await this._pluginRegistry.runOnShutdown();
@@ -1701,7 +1793,7 @@ var LogixiaLogger = class LogixiaLogger {
 		if (this.config.silent) return;
 		if (!this.shouldLog(level)) return;
 		if (this._sampler) {
-			const traceId$1 = this.config.traceId ? TraceContext.instance.getCurrentTraceId() ?? this.fallbackTraceId : void 0;
+			const traceId$1 = this.config.traceId ? TraceContext.instance.getCurrentTraceId() : void 0;
 			if (!this._sampler.shouldEmit(level, traceId$1)) return;
 		}
 		const alsContext = LogixiaContext.get();
@@ -1766,21 +1858,28 @@ var LogixiaLogger = class LogixiaLogger {
 		const ns = this.context;
 		if (ns) {
 			const nsKey = ns.split(".")[0].toUpperCase();
-			const envNsLevel = process.env[`LOGIXIA_LEVEL_${nsKey}`];
+			const envNsLevel = this._validLevel(process.env[`LOGIXIA_LEVEL_${nsKey}`], `LOGIXIA_LEVEL_${nsKey}`);
 			if (envNsLevel) return envNsLevel;
 			const namespaceLevels = this.config.namespaceLevels;
 			if (namespaceLevels) {
 				const sortedPatterns = Object.keys(namespaceLevels).sort((a, b) => b.length - a.length);
-				for (const pattern of sortedPatterns) if (matchesNamespacePattern(ns, pattern)) return namespaceLevels[pattern];
+				for (const pattern of sortedPatterns) if (matchesNamespacePattern(ns, pattern)) {
+					const nsLevel = this._validLevel(namespaceLevels[pattern], `namespaceLevels['${pattern}']`);
+					if (nsLevel) return nsLevel;
+				}
 			}
 		}
-		const globalEnv = process.env["LOGIXIA_LEVEL"];
+		const globalEnv = this._validLevel(process.env["LOGIXIA_LEVEL"], "LOGIXIA_LEVEL");
 		if (globalEnv) return globalEnv;
 		return this.getLevel();
 	}
 	formatLog(entry) {
 		var _this$config$format2, _this$config$format3, _this$config$format4;
-		if ((_this$config$format2 = this.config.format) === null || _this$config$format2 === void 0 ? void 0 : _this$config$format2.json) return _fastStringifyEntry(entry);
+		if ((_this$config$format2 = this.config.format) === null || _this$config$format2 === void 0 ? void 0 : _this$config$format2.json) try {
+			return _fastStringifyEntry(entry);
+		} catch {
+			return stringifyForLog(entry);
+		}
 		let formatted = "";
 		const doColorize = ((_this$config$format3 = this.config.format) === null || _this$config$format3 === void 0 ? void 0 : _this$config$format3.colorize) ?? true;
 		const gray = doColorize ? this._colorMap.get("gray") : "";
@@ -1793,7 +1892,7 @@ var LogixiaLogger = class LogixiaLogger {
 		if (entry.traceId && this._fieldCache.get("traceId") !== false) formatted += `${cyan}[${entry.traceId}]${reset} `;
 		if (entry.context && this._fieldCache.get("context") !== false) formatted += `${yellow}[${entry.context}]${reset} `;
 		if (this._fieldCache.get("message") !== false) formatted += entry.message;
-		if (entry.payload !== void 0 && this._fieldCache.get("payload") !== false) formatted += ` ${JSON.stringify(entry.payload)}`;
+		if (entry.payload !== void 0 && this._fieldCache.get("payload") !== false) formatted += ` ${stringifyForLog(entry.payload)}`;
 		return formatted;
 	}
 	colorize(text, color) {
@@ -1830,10 +1929,10 @@ var LogixiaLogger = class LogixiaLogger {
 	}
 };
 function createLogger(config, context) {
-	var _config$levelOptions2;
+	var _config$levelOptions3;
 	const logger = new LogixiaLogger(config, context);
 	const mutableLogger = logger;
-	if ((_config$levelOptions2 = config.levelOptions) === null || _config$levelOptions2 === void 0 ? void 0 : _config$levelOptions2.levels) {
+	if ((_config$levelOptions3 = config.levelOptions) === null || _config$levelOptions3 === void 0 ? void 0 : _config$levelOptions3.levels) {
 		for (const levelName of Object.keys(config.levelOptions.levels)) if (!mutableLogger[levelName]) mutableLogger[levelName] = async (message, data) => {
 			await logger.logLevel(levelName, message, data);
 		};
@@ -2178,7 +2277,7 @@ let TraceMiddleware = class TraceMiddleware$1 {
 		if (!traceId && this.config.generator) {
 			const candidate = this.config.generator();
 			if (typeof candidate === "string" && candidate.trim().length > 0) traceId = candidate;
-			else process.stderr.write("[logixia] TraceIdConfig.generator returned a non-string/empty value — using built-in generator.\n");
+			else internalWarn("TraceIdConfig.generator returned a non-string/empty value — using built-in generator.");
 		}
 		if (!traceId) traceId = this.ctx.generate();
 		req.traceId = traceId;
@@ -2267,6 +2366,7 @@ const DEFAULT_ROUTES = [{
 	method: RequestMethod.ALL
 }];
 const LOGIXIA_LOGGER_CONFIG = "LOGIXIA_LOGGER_CONFIG";
+const LOGIXIA_TRACE_CONFIG = "TRACE_CONFIG";
 const LOGIXIA_LOGGER_PREFIX = "LOGIXIA_LOGGER_";
 let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
 	static {
@@ -2291,7 +2391,7 @@ let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
 	*/
 	static _setGlobalLogger(service) {
 		if (_LogixiaLoggerModule._globalLogger !== null) {
-			process.stderr.write("[logixia] LogixiaLoggerModule.forRoot() was called more than once — ignoring the second init. If this is intentional (e.g. in tests), call LogixiaLoggerModule._resetGlobalLogger() first.\n");
+			internalWarn("LogixiaLoggerModule.forRoot() was called more than once — ignoring the second init. If this is intentional (e.g. in tests), call LogixiaLoggerModule._resetGlobalLogger() first.");
 			return;
 		}
 		_LogixiaLoggerModule._globalLogger = service;
@@ -2349,7 +2449,7 @@ let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
 					useValue: config || {}
 				},
 				{
-					provide: "TRACE_CONFIG",
+					provide: LOGIXIA_TRACE_CONFIG,
 					useValue: traceConfig
 				},
 				{
@@ -2389,12 +2489,12 @@ let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
 				{
 					provide: KafkaTraceInterceptor,
 					useFactory: (traceConfig$1) => new KafkaTraceInterceptor(traceConfig$1),
-					inject: ["TRACE_CONFIG"]
+					inject: [LOGIXIA_TRACE_CONFIG]
 				},
 				{
 					provide: WebSocketTraceInterceptor,
 					useFactory: (traceConfig$1) => new WebSocketTraceInterceptor(traceConfig$1),
-					inject: ["TRACE_CONFIG"]
+					inject: [LOGIXIA_TRACE_CONFIG]
 				}
 			],
 			exports: [
@@ -2416,7 +2516,7 @@ let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
 			providers: [
 				...this.createAsyncProviders(options),
 				{
-					provide: "TRACE_CONFIG",
+					provide: LOGIXIA_TRACE_CONFIG,
 					useFactory: (loggerConfig) => {
 						return typeof (loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) === "object" ? loggerConfig.traceId : { enabled: !!(loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) };
 					},
@@ -2461,12 +2561,12 @@ let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
 				{
 					provide: KafkaTraceInterceptor,
 					useFactory: (traceConfig) => new KafkaTraceInterceptor(traceConfig),
-					inject: ["TRACE_CONFIG"]
+					inject: [LOGIXIA_TRACE_CONFIG]
 				},
 				{
 					provide: WebSocketTraceInterceptor,
 					useFactory: (traceConfig) => new WebSocketTraceInterceptor(traceConfig),
-					inject: ["TRACE_CONFIG"]
+					inject: [LOGIXIA_TRACE_CONFIG]
 				}
 			],
 			exports: [
@@ -2518,5 +2618,5 @@ let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
 LogixiaLoggerModule = _LogixiaLoggerModule = __decorate([Module({})], LogixiaLoggerModule);
 
 //#endregion
-export { redactObject as A, LogLevel as B, setTraceId as C, registerForShutdown as D, flushOnExit as E, isError as F, createExpressContextMiddleware as G, globalPluginRegistry as H, normalizeError as I, createFastifyContextHook as K, serializeError as L, getActiveOtelContext as M, getOtelMetaFields as N, resetShutdownHandlers as O, initOtelBridge as P, DEFAULT_LOG_COLORS as R, runWithTraceId as S, deregisterFromShutdown as T, usePlugin as U, PluginRegistry as V, LogixiaContext as W, _setActiveContextKey as _, TraceMiddleware as a, getCurrentTraceId as b, KafkaTraceInterceptor as c, __decorateMetadata as d, LogixiaLogger as f, TraceContext as g, TRACE_CONTEXT_KEY as h, WebSocketTraceInterceptor as i, disableOtelBridge as j, applyRedaction as k, LogixiaLoggerService as l, DEFAULT_TRACE_HEADERS as m, LOGIXIA_LOGGER_PREFIX as n, resolveResponseHeader as o, createLogger as p, LogixiaLoggerModule as r, __decorateParam as s, LOGIXIA_LOGGER_CONFIG as t, __decorate as u, createTraceMiddleware as v, traceStorage as w, getTraceContextKey as x, extractTraceId as y, DEFAULT_LOG_LEVELS as z };
-//# sourceMappingURL=logitron-logger.module-BIGTm2V6.mjs.map
+export { resetShutdownHandlers as A, DEFAULT_LOG_COLORS as B, runWithTraceId as C, deregisterFromShutdown as D, _shutdownRegistrySize as E, getOtelMetaFields as F, usePlugin as G, LogLevel as H, initOtelBridge as I, isError as L, redactObject as M, disableOtelBridge as N, flushOnExit as O, getActiveOtelContext as P, normalizeError as R, getTraceContextKey as S, traceStorage as T, PluginRegistry as U, DEFAULT_LOG_LEVELS as V, globalPluginRegistry as W, TraceContext as _, WebSocketTraceInterceptor as a, extractTraceId as b, __decorateParam as c, __decorate as d, __decorateMetadata as f, TRACE_CONTEXT_KEY as g, DEFAULT_TRACE_HEADERS as h, LogixiaLoggerModule as i, applyRedaction as j, registerForShutdown as k, KafkaTraceInterceptor as l, createLogger as m, LOGIXIA_LOGGER_PREFIX as n, TraceMiddleware as o, LogixiaLogger as p, LOGIXIA_TRACE_CONFIG as r, resolveResponseHeader as s, LOGIXIA_LOGGER_CONFIG as t, LogixiaLoggerService as u, _setActiveContextKey as v, setTraceId as w, getCurrentTraceId as x, createTraceMiddleware as y, serializeError as z };
+//# sourceMappingURL=logitron-logger.module-Bs3XYZgF.mjs.map