logixia 1.12.4 → 1.12.6

package/dist/{logitron-logger.module-BTxDpK6u.js → logitron-logger.module-BsDZR5BH.js}

@@ -1,80 +1,22 @@
-const require_transport_manager = require('./transport.manager-ciG4r5uz.js');
-let fast_json_stringify = require("fast-json-stringify");
-fast_json_stringify = require_transport_manager.__toESM(fast_json_stringify);
+const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_internal_log = require('./internal-log-BUJYMZbE.js');
+const require_safe_stringify = require('./safe-stringify-DWo3aZp_.js');
+const require_async_context = require('./async-context-CSHWoHMB.js');
+const require_coerce_utils = require('./coerce.utils-BN980Y9V.js');
+const require_transport_manager = require('./transport.manager-BivyUTtU.js');
+let node_os = require("node:os");
+node_os = require_chunk.__toESM(node_os);
 let node_async_hooks = require("node:async_hooks");
-node_async_hooks = require_transport_manager.__toESM(node_async_hooks);
-let node_crypto = require("node:crypto");
-node_crypto = require_transport_manager.__toESM(node_crypto);
+node_async_hooks = require_chunk.__toESM(node_async_hooks);
+let fast_json_stringify = require("fast-json-stringify");
+fast_json_stringify = require_chunk.__toESM(fast_json_stringify);
 let crypto = require("crypto");
-crypto = require_transport_manager.__toESM(crypto);
+crypto = require_chunk.__toESM(crypto);
 let __nestjs_common = require("@nestjs/common");
-__nestjs_common = require_transport_manager.__toESM(__nestjs_common);
+__nestjs_common = require_chunk.__toESM(__nestjs_common);
 let rxjs = require("rxjs");
-rxjs = require_transport_manager.__toESM(rxjs);
-
-//#region src/context/async-context.ts
-/** Generates an 8-character random ID using Node's crypto module. */
-function randomShortId() {
-	return (0, node_crypto.randomUUID)().slice(0, 8);
-}
-const _storage = new node_async_hooks.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);
-	};
-}
+rxjs = require_chunk.__toESM(rxjs);
 
-//#endregion
 //#region src/plugin.ts
 /**
 * Holds an ordered list of `LogixiaPlugin` instances and dispatches lifecycle
@@ -572,7 +514,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();
@@ -589,34 +531,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).
@@ -643,8 +617,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
@@ -656,12 +647,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,
@@ -696,23 +689,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;
 		}
@@ -739,8 +716,6 @@ var Sampler = class {
 			byLevel: {},
 			windowStart: Date.now()
 		};
-		this.sampledTraces.clear();
-		this.droppedTraces.clear();
 	}
 	destroy() {
 		if (this._statsTimer) clearInterval(this._statsTimer);
@@ -753,20 +728,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
@@ -777,25 +759,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();
@@ -832,6 +828,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;
@@ -842,10 +839,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);
 }
@@ -857,7 +860,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
@@ -866,28 +873,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 + (node_os.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.
@@ -896,8 +939,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;
 }
@@ -1267,18 +1313,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`);
+				require_internal_log.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;
@@ -1287,20 +1344,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",
@@ -1347,7 +1406,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;
@@ -1357,16 +1419,16 @@ var LogixiaLogger = class LogixiaLogger {
 			};
 			this.transportManager = new require_transport_manager.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() {
@@ -1377,7 +1439,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() {
@@ -1404,6 +1467,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([
@@ -1539,15 +1604,39 @@ var LogixiaLogger = class LogixiaLogger {
 		}
 	}
 	setLevel(level) {
+		const canonical = canonicalLevel(level, this._levelValues);
+		if (canonical === void 0) {
+			require_internal_log.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);
+				require_internal_log.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.
 	*
@@ -1579,7 +1668,7 @@ var LogixiaLogger = class LogixiaLogger {
 		return { ...this.config.namespaceLevels };
 	}
 	setContext(context) {
-		this.context = typeof context === "string" ? context : require_transport_manager.safeToString(context);
+		this.context = typeof context === "string" ? context : require_coerce_utils.safeToString(context);
 	}
 	getContext() {
 		return this.context;
@@ -1588,13 +1677,13 @@ var LogixiaLogger = class LogixiaLogger {
 		this.fieldState.set(fieldName, true);
 		this._fieldCache.set(fieldName, true);
 		if (fieldName === "level" || fieldName === "appName") this._buildPerfCaches();
-		require_transport_manager.internalLog(`Field '${fieldName}' enabled`);
+		require_internal_log.internalLog(`Field '${fieldName}' enabled`);
 	}
 	disableField(fieldName) {
 		this.fieldState.set(fieldName, false);
 		this._fieldCache.set(fieldName, false);
 		if (fieldName === "level" || fieldName === "appName") this._buildPerfCaches();
-		require_transport_manager.internalLog(`Field '${fieldName}' disabled`);
+		require_internal_log.internalLog(`Field '${fieldName}' disabled`);
 	}
 	isFieldEnabled(fieldName) {
 		var _this$config$fields2;
@@ -1620,34 +1709,36 @@ var LogixiaLogger = class LogixiaLogger {
 	}
 	resetFieldState() {
 		this.fieldState.clear();
-		require_transport_manager.internalLog("Field state reset to configuration defaults");
+		require_internal_log.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 require_transport_manager.internalWarn("Transport manager not initialized");
+		else require_internal_log.internalWarn("Transport manager not initialized");
 	}
+	/** @deprecated No-op. */
 	disableTransportLevelPrompting() {
 		if (this.transportManager) this.transportManager.disableLevelPrompting();
-		else require_transport_manager.internalWarn("Transport manager not initialized");
+		else require_internal_log.internalWarn("Transport manager not initialized");
 	}
 	setTransportLevels(transportId, levels) {
 		if (this.transportManager) this.transportManager.setTransportLevels(transportId, levels);
-		else require_transport_manager.internalWarn("Transport manager not initialized");
+		else require_internal_log.internalWarn("Transport manager not initialized");
 	}
 	getTransportLevels(transportId) {
 		if (this.transportManager) return this.transportManager.getTransportLevels(transportId);
-		require_transport_manager.internalWarn("Transport manager not initialized");
+		require_internal_log.internalWarn("Transport manager not initialized");
 	}
 	clearTransportLevelPreferences() {
 		if (this.transportManager) this.transportManager.clearTransportLevelPreferences();
-		else require_transport_manager.internalWarn("Transport manager not initialized");
+		else require_internal_log.internalWarn("Transport manager not initialized");
 	}
 	getAvailableTransports() {
 		var _this$transportManage;
 		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
@@ -1698,6 +1789,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();
@@ -1707,10 +1799,10 @@ 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();
+		const alsContext = require_async_context.LogixiaContext.get();
 		const hasAls = alsContext !== void 0 && Object.keys(alsContext).length > 0;
 		const otelFields = _isOtelBridgeEnabled() ? _getOtelPayloadIfEnabled() : void 0;
 		const hasOtel = otelFields !== void 0 && Object.keys(otelFields).length > 0;
@@ -1772,21 +1864,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 require_safe_stringify.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") : "";
@@ -1799,7 +1898,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 += ` ${require_safe_stringify.stringifyForLog(entry.payload)}`;
 		return formatted;
 	}
 	colorize(text, color) {
@@ -1830,16 +1929,16 @@ var LogixiaLogger = class LogixiaLogger {
 	/** Shared transport-failure handler: log internally, notify plugins, then fall
 	* back to a direct stdout/stderr write so the entry is never lost. */
 	async _handleOutputError(error, entry, level) {
-		require_transport_manager.internalError("Transport write failed", error);
+		require_internal_log.internalError("Transport write failed", error);
 		if (this._pluginRegistry.size > 0) await this._pluginRegistry.runOnError(error instanceof Error ? error : new Error(String(error)), entry);
 		(level === LogLevel.ERROR ? process.stderr : process.stdout).write(this.formatLog(entry) + "\n");
 	}
 };
 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);
 		};
@@ -1928,7 +2027,7 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService$1
 	*/
 	log(message, context) {
 		this.setContextIfProvided(context);
-		this.logger.info(this.formatMessage(message)).catch((err) => require_transport_manager.internalError("LogixiaLoggerService.log failed", err));
+		this.logger.info(this.formatMessage(message)).catch((err) => require_internal_log.internalError("LogixiaLoggerService.log failed", err));
 	}
 	/**
 	* Native async `info` — structured data, returns `Promise<void>`.
@@ -1943,22 +2042,22 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService$1
 		this.setContextIfProvided(context);
 		const errorData = {};
 		if (typeof dataOrTrace === "string" && dataOrTrace) errorData.stack = dataOrTrace;
-		(message instanceof Error ? this.logger.error(message, errorData) : this.logger.error(this.formatMessage(message), errorData)).catch((err) => require_transport_manager.internalError("LogixiaLoggerService.error failed", err));
+		(message instanceof Error ? this.logger.error(message, errorData) : this.logger.error(this.formatMessage(message), errorData)).catch((err) => require_internal_log.internalError("LogixiaLoggerService.error failed", err));
 	}
 	warn(message, dataOrContext) {
 		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.warn(this.formatMessage(message), dataOrContext);
 		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.warn(this.formatMessage(message)).catch((err) => require_transport_manager.internalError("LogixiaLoggerService.warn failed", err));
+		this.logger.warn(this.formatMessage(message)).catch((err) => require_internal_log.internalError("LogixiaLoggerService.warn failed", err));
 	}
 	debug(message, dataOrContext) {
 		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.debug(this.formatMessage(message), dataOrContext);
 		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.debug(this.formatMessage(message)).catch((err) => require_transport_manager.internalError("LogixiaLoggerService.debug failed", err));
+		this.logger.debug(this.formatMessage(message)).catch((err) => require_internal_log.internalError("LogixiaLoggerService.debug failed", err));
 	}
 	verbose(message, dataOrContext) {
 		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.trace(this.formatMessage(message), dataOrContext);
 		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.trace(this.formatMessage(message)).catch((err) => require_transport_manager.internalError("LogixiaLoggerService.verbose failed", err));
+		this.logger.trace(this.formatMessage(message)).catch((err) => require_internal_log.internalError("LogixiaLoggerService.verbose failed", err));
 	}
 	/**
 	* Native async `trace` — lowest verbosity level, structured data.
@@ -1982,7 +2081,7 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService$1
 		return this.logger.timeAsync(label, fn);
 	}
 	setContext(context) {
-		const coerced = typeof context === "string" ? context : require_transport_manager.safeToString(context);
+		const coerced = typeof context === "string" ? context : require_coerce_utils.safeToString(context);
 		this.context = coerced;
 		this.logger.setContext(coerced);
 	}
@@ -2023,7 +2122,7 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService$1
 	}
 	formatMessage(message) {
 		if (typeof message === "string") return message;
-		return require_transport_manager.safeToString(message);
+		return require_coerce_utils.safeToString(message);
 	}
 };
 LogixiaLoggerService = _LogixiaLoggerService = __decorate([(0, __nestjs_common.Injectable)({ scope: __nestjs_common.Scope.TRANSIENT }), __decorateMetadata("design:paramtypes", [Object])], LogixiaLoggerService);
@@ -2184,7 +2283,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 require_internal_log.internalWarn("TraceIdConfig.generator returned a non-string/empty value — using built-in generator.");
 		}
 		if (!traceId) traceId = this.ctx.generate();
 		req.traceId = traceId;
@@ -2273,6 +2372,7 @@ const DEFAULT_ROUTES = [{
 	method: __nestjs_common.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 {
@@ -2297,7 +2397,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");
+			require_internal_log.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;
@@ -2355,7 +2455,7 @@ let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
 					useValue: config || {}
 				},
 				{
-					provide: "TRACE_CONFIG",
+					provide: LOGIXIA_TRACE_CONFIG,
 					useValue: traceConfig
 				},
 				{
@@ -2395,12 +2495,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: [
@@ -2422,7 +2522,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) };
 					},
@@ -2467,12 +2567,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: [
@@ -2560,16 +2660,16 @@ Object.defineProperty(exports, 'LOGIXIA_LOGGER_PREFIX', {
     return LOGIXIA_LOGGER_PREFIX;
   }
 });
-Object.defineProperty(exports, 'LogLevel', {
+Object.defineProperty(exports, 'LOGIXIA_TRACE_CONFIG', {
   enumerable: true,
   get: function () {
-    return LogLevel;
+    return LOGIXIA_TRACE_CONFIG;
   }
 });
-Object.defineProperty(exports, 'LogixiaContext', {
+Object.defineProperty(exports, 'LogLevel', {
   enumerable: true,
   get: function () {
-    return LogixiaContext;
+    return LogLevel;
   }
 });
 Object.defineProperty(exports, 'LogixiaLogger', {
@@ -2644,22 +2744,16 @@ Object.defineProperty(exports, '_setActiveContextKey', {
     return _setActiveContextKey;
   }
 });
-Object.defineProperty(exports, 'applyRedaction', {
-  enumerable: true,
-  get: function () {
-    return applyRedaction;
-  }
-});
-Object.defineProperty(exports, 'createExpressContextMiddleware', {
+Object.defineProperty(exports, '_shutdownRegistrySize', {
   enumerable: true,
   get: function () {
-    return createExpressContextMiddleware;
+    return _shutdownRegistrySize;
   }
 });
-Object.defineProperty(exports, 'createFastifyContextHook', {
+Object.defineProperty(exports, 'applyRedaction', {
   enumerable: true,
   get: function () {
-    return createFastifyContextHook;
+    return applyRedaction;
   }
 });
 Object.defineProperty(exports, 'createLogger', {
@@ -2800,4 +2894,4 @@ Object.defineProperty(exports, 'usePlugin', {
     return usePlugin;
   }
 });
-//# sourceMappingURL=logitron-logger.module-BTxDpK6u.js.map
+//# sourceMappingURL=logitron-logger.module-BsDZR5BH.js.map