logixia 1.13.3 → 2.0.4

package/dist/{nestjs-extras-ImbuDhs1.mjs → builder-D70z6kjj.mjs}

@@ -1,16 +1,83 @@
-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 { d as sanitizeIncomingId, i as TraceContext, l as getTraceContextKey, s as extractTraceId, t as DEFAULT_TRACE_HEADERS } from "./trace.utils-CvXgaiQT.mjs";
-import { t as LogixiaContext } from "./async-context-BzJrbfQs.mjs";
-import { t as safeToString } from "./coerce.utils-Cu6IUTgX.mjs";
-import { t as TransportManager, u as stripControlChars } from "./transport.manager-CpdVHEGP.mjs";
-import { constants } from "node:os";
+import { t as __require } from "./rolldown-runtime-D3PmRqjj.mjs";
+import { o as TraceContext } from "./request-trace-C_fvIDv4.mjs";
+import { t as LogixiaContext } from "./async-context-B05ArHgM.mjs";
+import { n as internalLog, o as SENSITIVE_KEY_NAMES, r as internalWarn, t as internalError } from "./internal-log-uCSd1PMc.mjs";
+import { n as protectSecrets } from "./secret-config-BegMLkYl.mjs";
+import { t as safeToString } from "./coerce.utils-B_rEudCn.mjs";
+import { i as stringifyForLog } from "./safe-stringify-BMRl3EX3.mjs";
+import { d as stripControlChars, t as TransportManager } from "./transport.manager-eZ_EeC00.mjs";
 import buildFastStringify from "fast-json-stringify";
-import { Catch, Inject, Injectable, Module, Optional, RequestMethod, Scope } from "@nestjs/common";
-import { EMPTY, Observable } from "rxjs";
-
-//#region src/plugin.ts
+import { constants } from "node:os";
+// src/types/index.ts
+const LogLevel = {
+	ERROR: "error",
+	WARN: "warn",
+	INFO: "info",
+	DEBUG: "debug",
+	TRACE: "trace",
+	VERBOSE: "verbose"
+};
+const DEFAULT_LOG_LEVELS = {
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3,
+	trace: 4,
+	verbose: 5
+};
+const DEFAULT_LOG_COLORS = {
+	error: "red",
+	warn: "yellow",
+	info: "green",
+	debug: "blue",
+	trace: "magenta",
+	verbose: "cyan"
+};
+// src/core/default-config.ts
+/**
+* Default configuration for Logixia logger
+*/
+const DEFAULT_CONFIG = {
+	appName: "App",
+	environment: "development",
+	traceId: true,
+	format: {
+		timestamp: true,
+		colorize: true,
+		json: false
+	},
+	silent: false,
+	levelOptions: {
+		level: LogLevel.INFO,
+		levels: {
+			[LogLevel.ERROR]: 0,
+			[LogLevel.WARN]: 1,
+			[LogLevel.INFO]: 2,
+			[LogLevel.DEBUG]: 3,
+			[LogLevel.TRACE]: 4,
+			[LogLevel.VERBOSE]: 5
+		},
+		colors: {
+			[LogLevel.ERROR]: "red",
+			[LogLevel.WARN]: "yellow",
+			[LogLevel.INFO]: "blue",
+			[LogLevel.DEBUG]: "green",
+			[LogLevel.TRACE]: "gray",
+			[LogLevel.VERBOSE]: "cyan"
+		}
+	},
+	fields: {
+		timestamp: true,
+		level: true,
+		appName: true,
+		traceId: true,
+		message: true,
+		payload: true,
+		timeTaken: true
+	},
+	outputs: ["console"]
+};
+// src/plugin.ts
 /**
 * Holds an ordered list of `LogixiaPlugin` instances and dispatches lifecycle
 * events to them. One registry is created per logger instance; a global
@@ -115,36 +182,7 @@ const globalPluginRegistry = new PluginRegistry();
 function usePlugin(plugin) {
 	globalPluginRegistry.register(plugin);
 }
-
-//#endregion
-//#region src/types/index.ts
-const LogLevel = {
-	ERROR: "error",
-	WARN: "warn",
-	INFO: "info",
-	DEBUG: "debug",
-	TRACE: "trace",
-	VERBOSE: "verbose"
-};
-const DEFAULT_LOG_LEVELS = {
-	error: 0,
-	warn: 1,
-	info: 2,
-	debug: 3,
-	trace: 4,
-	verbose: 5
-};
-const DEFAULT_LOG_COLORS = {
-	error: "red",
-	warn: "yellow",
-	info: "green",
-	debug: "blue",
-	trace: "magenta",
-	verbose: "cyan"
-};
-
-//#endregion
-//#region src/utils/error.utils.ts
+// src/utils/error.utils.ts
 const EXTRA_FIELDS = [
 	"code",
 	"statusCode",
@@ -186,13 +224,15 @@ function _serializeError(error, includeStack, maxDepth, excludeFields, depth, se
 	};
 	if (includeStack && error.stack) serialized.stack = error.stack;
 	const errorWithCause = error;
-	if (errorWithCause.cause !== void 0) if (errorWithCause.cause instanceof Error) serialized.cause = _serializeError(errorWithCause.cause, includeStack, maxDepth, excludeFields, depth + 1, seen);
-	else serialized.cause = serializeValue(errorWithCause.cause, maxDepth - depth - 1, seen);
+	if (errorWithCause.cause !== void 0) {
+		if (errorWithCause.cause instanceof Error) serialized.cause = _serializeError(errorWithCause.cause, includeStack, maxDepth, excludeFields, depth + 1, seen);
+		else serialized.cause = serializeValue(errorWithCause.cause, maxDepth - depth - 1, seen);
+	}
 	const aggregateError = error;
 	if (Array.isArray(aggregateError.errors)) serialized.errors = aggregateError.errors.map((e) => e instanceof Error ? _serializeError(e, includeStack, maxDepth, excludeFields, depth + 1, seen) : serializeValue(e, maxDepth - depth - 1, seen));
 	const errorRecord = error;
 	for (const field of EXTRA_FIELDS) if (!excludeFields.includes(field) && field in error && errorRecord[field] !== void 0) serialized[field] = errorRecord[field];
-	const skip = new Set([
+	const skip = /* @__PURE__ */ new Set([
 		"name",
 		"message",
 		"stack",
@@ -274,9 +314,7 @@ function normalizeError(error) {
 	}
 	return new Error(String(error));
 }
-
-//#endregion
-//#region src/utils/otel.ts
+// src/utils/otel.ts
 let _otelApi;
 function tryLoadOtelApi() {
 	if (_otelApi !== void 0) return _otelApi;
@@ -381,9 +419,7 @@ function _getOtelPayloadIfEnabled() {
 function disableOtelBridge() {
 	_bridgeOptions = null;
 }
-
-//#endregion
-//#region src/utils/redact.utils.ts
+// src/utils/redact.utils.ts
 const DEFAULT_CENSOR = "[REDACTED]";
 /** Maximum nesting depth walked; deeper values are replaced with a marker. */
 const MAX_DEPTH = 32;
@@ -412,34 +448,7 @@ const PII_CONSERVATIVE_PATTERNS = [
 /**
 * Conservative field-name paths auto-redacted by name regardless of value.
 */
-const PII_CONSERVATIVE_PATHS = [
-	"**.password",
-	"**.passwd",
-	"**.secret",
-	"**.token",
-	"**.apiKey",
-	"**.api_key",
-	"**.accessToken",
-	"**.access_token",
-	"**.refreshToken",
-	"**.refresh_token",
-	"**.authorization",
-	"**.credentials",
-	"**.privateKey",
-	"**.private_key",
-	"**.clientSecret",
-	"**.client_secret",
-	"**.cookie",
-	"**.set-cookie",
-	"**.x-api-key",
-	"**.session",
-	"**.proxy-authorization",
-	"**.x-auth-token",
-	"**.x-access-token",
-	"**.aws_secret_access_key",
-	"**.awsSecretAccessKey",
-	"**.secretAccessKey"
-];
+const PII_CONSERVATIVE_PATHS = SENSITIVE_KEY_NAMES.map((name) => `**.${name}`);
 /**
 * Aggressive patterns: also catch personal data that could identify a person.
 * Applied when `autoDetect: 'aggressive'`.
@@ -651,7 +660,7 @@ function walkToJSON(obj, state, fullPath, bare, depth) {
 function redactObject(obj, config, _currentPath = "") {
 	const result = walkRecord(obj, {
 		config,
-		ancestors: new Set([obj]),
+		ancestors: /* @__PURE__ */ new Set([obj]),
 		nodes: 0
 	}, _currentPath, _currentPath, 0);
 	return result === obj ? { ...obj } : result;
@@ -700,10 +709,8 @@ function isPlainObject(value) {
 	if (ArrayBuffer.isView(value)) return false;
 	return !OPAQUE_BUILTINS.some((ctor) => value instanceof ctor);
 }
-
-//#endregion
-//#region src/utils/sampling.utils.ts
-const ALWAYS_EMIT_LEVELS = new Set([
+// src/utils/sampling.utils.ts
+const ALWAYS_EMIT_LEVELS = /* @__PURE__ */ new Set([
 	"error",
 	"warn",
 	"fatal"
@@ -721,8 +728,8 @@ var Sampler = class {
 	constructor(config, onStats) {
 		this.traceDecisions = /* @__PURE__ */ new Map();
 		this.maxTrackedTraces = 1e5;
-		this.traceTtlMs = 5 * 6e4;
-		this.traceMaxLifetimeMs = 60 * 6e4;
+		this.traceTtlMs = 3e5;
+		this.traceMaxLifetimeMs = 36e5;
 		this._tokenBucket = 0;
 		this._lastRefillMs = Date.now();
 		this._adaptiveWindow = [];
@@ -901,9 +908,14 @@ var Sampler = class {
 		this._stats.dropped++;
 	}
 };
-
-//#endregion
-//#region src/utils/shutdown.utils.ts
+// src/utils/shutdown.utils.ts
+/**
+* Graceful shutdown utilities for Logixia
+*
+* Ensures all in-flight logs are flushed to every transport before the process
+* exits on SIGTERM / SIGINT — solving the "last N seconds of logs are lost on
+* deployment" problem reported in Pino issue #2002 and LogDNA issue #15.
+*/
 const MAX_BEFORE_EXIT_FLUSHES = 5;
 /** Module-level registry of all logger instances that have opted into graceful shutdown */
 const registry = /* @__PURE__ */ new Set();
@@ -1023,9 +1035,17 @@ function resetShutdownHandlers() {
 	shutdownHandlerRegistered = false;
 	shutdownInProgress = false;
 }
-
-//#endregion
-//#region src/core/logitron-logger.ts
+// src/core/logitron-logger.ts
+/**
+* Core Logixia Logger implementation
+*
+* v1.1 additions:
+*  - Feature 1: Graceful shutdown / flushOnExit (auto-registered via config)
+*  - Feature 2: Built-in log redaction (path-based + regex)
+*  - Feature 3: Per-namespace log levels + LOGIXIA_LEVEL* ENV overrides
+*  - Feature 4: Cause-chain error serialization (handled in error.utils)
+*  - Feature 5: Adaptive log level based on NODE_ENV / CI detection
+*/
 const _fastStringifyEntry = buildFastStringify({
 	type: "object",
 	properties: {
@@ -1055,7 +1075,7 @@ function nowIso() {
 }
 function namespacePatternToRegex(pattern) {
 	const escaped = pattern.split(".").map((s) => s === "*" ? "[^.]+" : s.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&")).join("\\.");
-	return /* @__PURE__ */ new RegExp(`^${escaped}$`);
+	return new RegExp(`^${escaped}$`);
 }
 /** Max compiled patterns to keep in memory. Oldest entry is evicted when full. */
 const _NS_CACHE_MAX = 1e3;
@@ -1097,7 +1117,7 @@ function canonicalLevel(level, known) {
 function resolveInitialLevel(config) {
 	var _config$levelOptions, _config$levelOptions2;
 	const envLevel = process.env["LOGIXIA_LEVEL"];
-	const knownLevels = new Set([...Object.values(LogLevel), ...Object.keys(((_config$levelOptions = config.levelOptions) === null || _config$levelOptions === void 0 ? void 0 : _config$levelOptions.levels) ?? {})]);
+	const knownLevels = /* @__PURE__ */ 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"];
@@ -1107,6 +1127,19 @@ function resolveInitialLevel(config) {
 	if (process.env["CI"]) return LogLevel.INFO;
 	return LogLevel.INFO;
 }
+/**
+* The logixia logger. Create instances with {@link createLogger} so that custom
+* levels from `levelOptions.levels` also become methods.
+*
+* @example
+* ```ts
+* const logger = createLogger({ appName: 'api', environment: 'production' });
+* await logger.info('Server started', { port: 3000 });
+* const req = logger.child('RequestHandler', { requestId: 'r-1' });
+* await req.error(new Error('boom'));
+* await logger.close(); // flush buffered transports before exit
+* ```
+*/
 var LogixiaLogger = class LogixiaLogger {
 	constructor(config, context, parent) {
 		this.timers = /* @__PURE__ */ new Map();
@@ -1124,7 +1157,7 @@ var LogixiaLogger = class LogixiaLogger {
 		this._hasRedact = false;
 		this._parent = parent;
 		this._pluginRegistry = parent ? parent._pluginRegistry : new PluginRegistry();
-		this.config = {
+		const defaultConfig = {
 			appName: "App",
 			environment: "development",
 			traceId: true,
@@ -1152,7 +1185,10 @@ var LogixiaLogger = class LogixiaLogger {
 					[LogLevel.TRACE]: "gray",
 					[LogLevel.VERBOSE]: "cyan"
 				}
-			},
+			}
+		};
+		this.config = {
+			...defaultConfig,
 			...config
 		};
 		const resolvedLevel = resolveInitialLevel(this.config);
@@ -1170,6 +1206,7 @@ var LogixiaLogger = class LogixiaLogger {
 			timeTaken: "[time_taken_MS]"
 		};
 		this.context = context ?? "";
+		protectSecrets(this, ["config"]);
 		if (parent) {
 			this.transportManager = parent.transportManager;
 			this._sampler = parent._sampler;
@@ -1235,7 +1272,7 @@ var LogixiaLogger = class LogixiaLogger {
 		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([
+		this._colorMap = /* @__PURE__ */ new Map([
 			["black", "\x1B[30m"],
 			["red", "\x1B[31m"],
 			["green", "\x1B[32m"],
@@ -1278,7 +1315,7 @@ var LogixiaLogger = class LogixiaLogger {
 			"green",
 			"blue"
 		];
-		const _BUILTIN_LEVELS = new Set([
+		const _BUILTIN_LEVELS = /* @__PURE__ */ new Set([
 			"error",
 			"warn",
 			"info",
@@ -1292,10 +1329,12 @@ var LogixiaLogger = class LogixiaLogger {
 			if (colorize && this._fieldCache.get("level") !== false) {
 				var _this$config$levelOpt4;
 				let colorName = (_this$config$levelOpt4 = this.config.levelOptions) === null || _this$config$levelOpt4 === void 0 || (_this$config$levelOpt4 = _this$config$levelOpt4.colors) === null || _this$config$levelOpt4 === void 0 ? void 0 : _this$config$levelOpt4[lvl];
-				if (!colorName) if (_BUILTIN_LEVELS.has(lvl)) colorName = "white";
-				else {
-					colorName = _AUTO_PALETTE[_paletteIdx % _AUTO_PALETTE.length];
-					_paletteIdx++;
+				if (!colorName) {
+					if (_BUILTIN_LEVELS.has(lvl)) colorName = "white";
+					else {
+						colorName = _AUTO_PALETTE[_paletteIdx % _AUTO_PALETTE.length];
+						_paletteIdx++;
+					}
 				}
 				const code = this._colorMap.get(colorName.toLowerCase()) ?? this._colorMap.get("white");
 				const reset = this._colorMap.get("reset");
@@ -1307,6 +1346,11 @@ var LogixiaLogger = class LogixiaLogger {
 		else this._formattedAppName = colorize ? `${this._colorMap.get("gray")}${appNameRaw}${this._colorMap.get("reset")} ` : `${appNameRaw} `;
 		this._hasRedact = !!(this.config.redact && ((((_this$config$redact$p = this.config.redact.paths) === null || _this$config$redact$p === void 0 ? void 0 : _this$config$redact$p.length) ?? 0) > 0 || (((_this$config$redact$p2 = this.config.redact.patterns) === null || _this$config$redact$p2 === void 0 ? void 0 : _this$config$redact$p2.length) ?? 0) > 0 || !!this.config.redact.autoDetect));
 	}
+	/**
+	* Log at `error` level. An `Error` is logged with its message and serialized
+	* (name, message, stack) under `data.error`; a string is logged as-is.
+	* `data` is merged into the entry payload.
+	*/
 	async error(messageOrError, data) {
 		if (isError(messageOrError)) await this.log("error", messageOrError.message, {
 			...data,
@@ -1314,30 +1358,53 @@ var LogixiaLogger = class LogixiaLogger {
 		});
 		else await this.log("error", messageOrError, data);
 	}
+	/** Log `message` at `warn` level; `data` is merged into the entry payload. */
 	async warn(message, data) {
 		await this.log("warn", message, data);
 	}
+	/** Log `message` at `info` level; `data` is merged into the entry payload. */
 	async info(message, data) {
 		await this.log("info", message, data);
 	}
+	/** Log `message` at `debug` level; `data` is merged into the entry payload. */
 	async debug(message, data) {
 		await this.log("debug", message, data);
 	}
+	/** Log `message` at `trace` level; `data` is merged into the entry payload. */
 	async trace(message, data) {
 		await this.log("trace", message, data);
 	}
+	/** Log `message` at `verbose` level; `data` is merged into the entry payload. */
 	async verbose(message, data) {
 		await this.log("verbose", message, data);
 	}
+	/**
+	* Log at an arbitrary level name, including custom levels. Levels below the
+	* active threshold are dropped, as are level names that are not registered
+	* in `levelOptions.levels` (and are not built-in).
+	*/
 	async logLevel(level, message, data) {
 		await this.log(level, message, data);
 	}
+	/** Start a named timer; finish it with {@link timeEnd}. Reusing a label restarts it. */
 	time(label) {
 		this.timers.set(label, {
 			label,
 			startTime: Date.now()
 		});
 	}
+	/**
+	* Stop the timer `label`, log its duration at `info` level, and return the
+	* elapsed milliseconds. Logs a `warn` and returns `undefined` if the timer
+	* does not exist.
+	*
+	* @example
+	* ```ts
+	* logger.time('db');
+	* await query();
+	* const ms = await logger.timeEnd('db');
+	* ```
+	*/
 	async timeEnd(label) {
 		const timer = this.timers.get(label);
 		if (!timer) {
@@ -1367,6 +1434,17 @@ var LogixiaLogger = class LogixiaLogger {
 			throw error;
 		}
 	}
+	/**
+	* Change the minimum log level at runtime. The override outranks
+	* `LOGIXIA_LEVEL`, `LOGIXIA_LEVEL_<NS>` and `namespaceLevels`, and survives
+	* later changes to fields or namespace levels. Unknown level names are
+	* ignored with a warning and the current level is kept.
+	*
+	* @example
+	* ```ts
+	* logger.setLevel('debug');
+	* ```
+	*/
 	setLevel(level) {
 		const canonical = canonicalLevel(level, this._levelValues);
 		if (canonical === void 0) {
@@ -1375,9 +1453,14 @@ var LogixiaLogger = class LogixiaLogger {
 		}
 		this.config.levelOptions = this.config.levelOptions ?? {};
 		this.config.levelOptions.level = canonical;
-		this._minLevelValue = this._levelValues.get(canonical) ?? this._minLevelValue;
+		this._runtimeLevel = canonical;
 		this._buildPerfCaches();
 	}
+	/**
+	* Return the configured minimum log level, not the per-namespace effective
+	* one. Without `setLevel()` it is `LOGIXIA_LEVEL`, else `levelOptions.level`,
+	* else a `NODE_ENV` default (`debug` in development, `warn` in test), else `info`.
+	*/
 	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;
@@ -1431,30 +1514,36 @@ var LogixiaLogger = class LogixiaLogger {
 	getNamespaceLevels() {
 		return { ...this.config.namespaceLevels };
 	}
+	/** Set the context label (e.g. a class or module name) attached to every subsequent entry. */
 	setContext(context) {
 		this.context = typeof context === "string" ? context : safeToString(context);
 	}
+	/** Return the current context label, or `undefined` if none is set. */
 	getContext() {
 		return this.context;
 	}
+	/** Show `fieldName` in log output, overriding the config for this logger instance. */
 	enableField(fieldName) {
 		this.fieldState.set(fieldName, true);
 		this._fieldCache.set(fieldName, true);
 		if (fieldName === "level" || fieldName === "appName") this._buildPerfCaches();
 		internalLog(`Field '${fieldName}' enabled`);
 	}
+	/** Hide `fieldName` from log output, overriding the config for this logger instance. */
 	disableField(fieldName) {
 		this.fieldState.set(fieldName, false);
 		this._fieldCache.set(fieldName, false);
 		if (fieldName === "level" || fieldName === "appName") this._buildPerfCaches();
 		internalLog(`Field '${fieldName}' disabled`);
 	}
+	/** Whether `fieldName` is currently shown: runtime override first, then config, default `true`. */
 	isFieldEnabled(fieldName) {
 		var _this$config$fields2;
 		if (this.fieldState.has(fieldName)) return this.fieldState.get(fieldName);
 		if (((_this$config$fields2 = this.config.fields) === null || _this$config$fields2 === void 0 ? void 0 : _this$config$fields2[fieldName]) !== void 0) return this.config.fields[fieldName] !== false;
 		return true;
 	}
+	/** Return the visibility (`true` = shown) of every standard log field. */
 	getFieldState() {
 		return Object.fromEntries([
 			"timestamp",
@@ -1471,6 +1560,7 @@ var LogixiaLogger = class LogixiaLogger {
 			"environment"
 		].map((f) => [f, this.isFieldEnabled(f)]));
 	}
+	/** Drop all runtime enable/disable overrides so field visibility follows the config again. */
 	resetFieldState() {
 		this.fieldState.clear();
 		internalLog("Field state reset to configuration defaults");
@@ -1485,10 +1575,12 @@ var LogixiaLogger = class LogixiaLogger {
 		if (this.transportManager) this.transportManager.disableLevelPrompting();
 		else internalWarn("Transport manager not initialized");
 	}
+	/** Restrict `transportId` to only the given `levels`. Warns if no transports are configured. */
 	setTransportLevels(transportId, levels) {
 		if (this.transportManager) this.transportManager.setTransportLevels(transportId, levels);
 		else internalWarn("Transport manager not initialized");
 	}
+	/** Return the levels `transportId` is restricted to, or `undefined` if it has none. */
 	getTransportLevels(transportId) {
 		if (this.transportManager) return this.transportManager.getTransportLevels(transportId);
 		internalWarn("Transport manager not initialized");
@@ -1497,10 +1589,23 @@ var LogixiaLogger = class LogixiaLogger {
 		if (this.transportManager) this.transportManager.clearTransportLevelPreferences();
 		else internalWarn("Transport manager not initialized");
 	}
+	/** Return the identifiers of the configured transports (empty if none). */
 	getAvailableTransports() {
 		var _this$transportManage;
 		return ((_this$transportManage = this.transportManager) === null || _this$transportManage === void 0 ? void 0 : _this$transportManage.getTransports()) ?? [];
 	}
+	/**
+	* Create a child logger with its own `context` that shares this logger's
+	* configuration and transports. `data` is merged into the bound fields
+	* inherited from this logger and added to every entry the child writes.
+	* Closing a child does not close the shared transports.
+	*
+	* @example
+	* ```ts
+	* const req = logger.child('Checkout', { requestId: 'r-42' });
+	* await req.info('started'); // entry includes requestId
+	* ```
+	*/
 	child(context, data) {
 		const childLogger = new LogixiaLogger(this.config, context, this);
 		const mergedContextData = {
@@ -1536,9 +1641,11 @@ var LogixiaLogger = class LogixiaLogger {
 		this._pluginRegistry.unregister(pluginName);
 		return this;
 	}
+	/** Flush buffered entries in all transports without closing them. */
 	async flush() {
 		if (this.transportManager) await this.transportManager.flush();
 	}
+	/** Report whether the transports are healthy; `healthy: false` if no transport manager exists. */
 	async healthCheck() {
 		if (!this.transportManager) return {
 			healthy: false,
@@ -1546,6 +1653,20 @@ var LogixiaLogger = class LogixiaLogger {
 		};
 		return this.transportManager.healthCheck();
 	}
+	/**
+	* Warn about timers that were never ended, then flush and close all transports,
+	* stop the sampler and run plugin shutdown hooks. On a child logger only the
+	* timer warnings run; the shared transports stay open.
+	*
+	* To flush on SIGTERM/SIGINT, set the `gracefulShutdown` config option rather
+	* than writing your own signal handler; do not combine it with a manual
+	* handler that calls `process.exit`, which can cut the flush short.
+	*
+	* @example
+	* ```ts
+	* await logger.close(); // e.g. at the end of a script or a test
+	* ```
+	*/
 	async close() {
 		var _this$_sampler;
 		for (const [label, timer] of this.timers) await this.warn(`Timer '${label}' was not ended properly`, {
@@ -1562,11 +1683,13 @@ var LogixiaLogger = class LogixiaLogger {
 	async log(level, message, data) {
 		if (this.config.silent) return;
 		if (!this.shouldLog(level)) return;
-		if (this._sampler) {
-			const traceId$1 = this.config.traceId ? TraceContext.instance.getCurrentTraceId() : void 0;
-			if (!this._sampler.shouldEmit(level, traceId$1)) return;
-		}
 		const alsContext = LogixiaContext.get();
+		let activeTraceId;
+		if (this.config.traceId) {
+			const ctxTraceId = alsContext === null || alsContext === void 0 ? void 0 : alsContext.traceId;
+			activeTraceId = TraceContext.instance.getCurrentTraceId() ?? (typeof ctxTraceId === "string" ? ctxTraceId : void 0);
+		}
+		if (this._sampler && !this._sampler.shouldEmit(level, activeTraceId)) return;
 		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;
@@ -1586,14 +1709,16 @@ var LogixiaLogger = class LogixiaLogger {
 			...mergedData
 		} : mergedData;
 		let payload;
-		if (rawPayload !== void 0 && rawPayload !== null) if (this._hasRedact) try {
-			payload = applyRedaction(rawPayload, this.config.redact) ?? rawPayload;
-		} catch (error) {
-			internalError("Redaction failed", error);
-			payload = { redaction: REDACTION_FAILED };
+		if (rawPayload !== void 0 && rawPayload !== null) {
+			if (this._hasRedact) try {
+				payload = applyRedaction(rawPayload, this.config.redact) ?? rawPayload;
+			} catch (error) {
+				internalError("Redaction failed", error);
+				payload = { redaction: REDACTION_FAILED };
+			}
+			else payload = rawPayload;
 		}
-		else payload = rawPayload;
-		const traceId = this.config.traceId ? TraceContext.instance.getCurrentTraceId() ?? this.fallbackTraceId : void 0;
+		const traceId = this.config.traceId ? activeTraceId ?? this.fallbackTraceId : void 0;
 		let safeMessage = message;
 		if (this._hasRedact) try {
 			safeMessage = applyRedactionToString(message, this.config.redact);
@@ -1631,12 +1756,14 @@ var LogixiaLogger = class LogixiaLogger {
 	* Feature 3: Resolve the effective log level for this logger instance.
 	*
 	* Priority:
+	*  0. A level set at runtime with `setLevel()` (explicit programmatic call, wins over all below)
 	*  1. ENV `LOGIXIA_LEVEL_<NS_UPPER>` (e.g. LOGIXIA_LEVEL_DB for ns "db" or "db.queries")
 	*  2. Matching `namespaceLevels` config entry (longer pattern = more specific, wins)
 	*  3. Global `LOGIXIA_LEVEL` ENV override
 	*  4. `levelOptions.level` (resolved via Feature 5 in constructor)
 	*/
 	resolveEffectiveLevel() {
+		if (this._runtimeLevel) return this._runtimeLevel;
 		const ns = this.context;
 		if (ns) {
 			const nsKey = ns.split(".")[0].toUpperCase();
@@ -1710,6 +1837,22 @@ var LogixiaLogger = class LogixiaLogger {
 		(level === LogLevel.ERROR ? process.stderr : process.stdout).write(this.formatLog(entry) + "\n");
 	}
 };
+/**
+* Create a logger from `config`, with an optional default `context` label.
+*
+* Every key of `levelOptions.levels` that is not already a method becomes an
+* async method on the returned logger, typed through the config, and routes to
+* {@link LogixiaLogger.logLevel}.
+*
+* @example
+* ```ts
+* const logger = createLogger({
+*   appName: 'api',
+*   levelOptions: { level: 'info', levels: { error: 0, warn: 1, info: 2, audit: 2 } },
+* });
+* await logger.audit('user exported data', { userId: 'u1' });
+* ```
+*/
 function createLogger(config, context) {
 	var _config$levelOptions3;
 	const logger = new LogixiaLogger(config, context);
@@ -1721,686 +1864,7 @@ function createLogger(config, context) {
 	}
 	return logger;
 }
-
-//#endregion
-//#region \0@oxc-project+runtime@0.95.0/helpers/decorateMetadata.js
-function __decorateMetadata(k, v) {
-	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.95.0/helpers/decorate.js
-function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-//#endregion
-//#region src/core/logitron-nestjs.service.ts
-var _LogixiaLoggerService;
-let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService$1 {
-	constructor(config) {
-		this._mergedConfig = {
-			appName: "NestJS-App",
-			environment: "development",
-			traceId: true,
-			format: {
-				timestamp: true,
-				colorize: true,
-				json: false
-			},
-			silent: false,
-			levelOptions: {
-				level: LogLevel.INFO,
-				levels: {
-					error: 0,
-					warn: 1,
-					log: 2,
-					debug: 3,
-					verbose: 4
-				},
-				colors: {
-					error: "red",
-					warn: "yellow",
-					log: "green",
-					debug: "blue",
-					verbose: "cyan"
-				}
-			},
-			fields: {
-				timestamp: "[yyyy-mm-dd HH:MM:ss.MS]",
-				level: "[log_level]",
-				appName: "[app_name]",
-				traceId: "[trace_id]",
-				message: "[message]",
-				payload: "[payload]",
-				timeTaken: "[time_taken_MS]"
-			},
-			...config
-		};
-		this.logger = new LogixiaLogger(this._mergedConfig);
-		this._createCustomLevelMethods();
-	}
-	_createCustomLevelMethods() {
-		var _this$_mergedConfig$l;
-		const levels = (_this$_mergedConfig$l = this._mergedConfig.levelOptions) === null || _this$_mergedConfig$l === void 0 ? void 0 : _this$_mergedConfig$l.levels;
-		if (!levels) return;
-		for (const levelName of Object.keys(levels)) {
-			const lower = levelName.toLowerCase();
-			if (typeof this[lower] !== "undefined") continue;
-			this[lower] = async (message, data) => {
-				return this.logger.logLevel(lower, message, data);
-			};
-		}
-	}
-	/**
-	* NestJS `LoggerService.log` — void, string context.
-	* Maps internally to `info`.
-	*
-	* @example `logger.log('User signed up', 'AuthService')`
-	*/
-	log(message, context) {
-		this.setContextIfProvided(context);
-		this.logger.info(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.log failed", err));
-	}
-	/**
-	* Native async `info` — structured data, returns `Promise<void>`.
-	*
-	* @example `await logger.info('User signed up', { userId: 'u_abc' })`
-	*/
-	async info(message, data) {
-		return this.logger.info(message, data);
-	}
-	error(message, dataOrTrace, context) {
-		if (typeof dataOrTrace === "object" && dataOrTrace !== null) return message instanceof Error ? this.logger.error(message, dataOrTrace) : this.logger.error(this.formatMessage(message), dataOrTrace);
-		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) => 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) => 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) => 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) => internalError("LogixiaLoggerService.verbose failed", err));
-	}
-	/**
-	* Native async `trace` — lowest verbosity level, structured data.
-	*/
-	async trace(message, data) {
-		return this.logger.trace(message, data);
-	}
-	/**
-	* Log at any named level with structured data.
-	*/
-	logLevel(level, message, data) {
-		return this.logger.logLevel(level, message, data);
-	}
-	time(label) {
-		this.logger.time(label);
-	}
-	async timeEnd(label) {
-		return this.logger.timeEnd(label);
-	}
-	async timeAsync(label, fn) {
-		return this.logger.timeAsync(label, fn);
-	}
-	setContext(context) {
-		const coerced = typeof context === "string" ? context : safeToString(context);
-		this.context = coerced;
-		this.logger.setContext(coerced);
-	}
-	getContext() {
-		return this.context;
-	}
-	setLevel(level) {
-		this.logger.setLevel(level);
-	}
-	getLevel() {
-		return this.logger.getLevel();
-	}
-	child(context, data) {
-		const childService = new _LogixiaLoggerService(this._mergedConfig);
-		childService.logger = this.logger.child(context, data);
-		childService.context = context;
-		return childService;
-	}
-	getCurrentTraceId() {
-		return TraceContext.instance.getCurrentTraceId();
-	}
-	/** Returns the AsyncLocalStorage key currently used to store the trace ID. */
-	get traceContextKey() {
-		return getTraceContextKey();
-	}
-	async close() {
-		return this.logger.close();
-	}
-	static create(config) {
-		return new _LogixiaLoggerService(config);
-	}
-	getLogger() {
-		return this.logger;
-	}
-	setContextIfProvided(context) {
-		if (typeof context !== "string" || context.length === 0) return;
-		if (context !== this.context) this.setContext(context);
-	}
-	formatMessage(message) {
-		if (typeof message === "string") return message;
-		return safeToString(message);
-	}
-};
-LogixiaLoggerService = _LogixiaLoggerService = __decorate([Injectable({ scope: Scope.TRANSIENT }), __decorateMetadata("design:paramtypes", [Object])], LogixiaLoggerService);
-
-//#endregion
-//#region src/core/kafka-trace.interceptor.ts
-var _KafkaTraceInterceptor;
-let KafkaTraceInterceptor = class KafkaTraceInterceptor$1 {
-	static {
-		_KafkaTraceInterceptor = this;
-	}
-	static #_ = this.metrics = {
-		accepted: 0,
-		acceptedWithoutTrace: 0,
-		dropped: 0
-	};
-	/** Reset counters (tests). */
-	static resetMetrics() {
-		_KafkaTraceInterceptor.metrics.accepted = 0;
-		_KafkaTraceInterceptor.metrics.acceptedWithoutTrace = 0;
-		_KafkaTraceInterceptor.metrics.dropped = 0;
-	}
-	/**
-	* @param config        - TraceIdConfig options (extractor keys, contextKey, etc.)
-	* @param requireTraceId - When true, messages with no traceId are silently skipped
-	*                         (EMPTY Observable — message is ack'd, consumer stays alive).
-	*                         A WARN is logged AND `KafkaTraceInterceptor.metrics.dropped`
-	*                         increments so the missing traceId is observable end-to-end.
-	*                         Default: false (handler runs without trace context).
-	*/
-	constructor(config, requireTraceId = false) {
-		this.config = config;
-		this.requireTraceId = requireTraceId;
-		this.ctx = TraceContext.instance;
-		this.config = {
-			enabled: true,
-			contextKey: "traceId",
-			extractor: {
-				body: [
-					"traceId",
-					"trace_id",
-					"x-trace-id"
-				],
-				header: ["x-trace-id", "trace-id"]
-			},
-			...config
-		};
-	}
-	intercept(context, next) {
-		var _this$config;
-		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next.handle();
-		const rpcContext = context.switchToRpc();
-		const data = rpcContext.getData();
-		const rpcData = rpcContext.getContext();
-		let traceId;
-		if (this.config.extractor) traceId = extractTraceId({
-			body: data,
-			headers: (rpcData === null || rpcData === void 0 ? void 0 : rpcData.headers) ?? {},
-			query: {},
-			params: {}
-		}, this.config.extractor);
-		if (!traceId) traceId = this.ctx.getCurrentTraceId();
-		if (!traceId) {
-			if (this.requireTraceId) {
-				var _LogixiaLoggerModule$;
-				_KafkaTraceInterceptor.metrics.dropped++;
-				(_LogixiaLoggerModule$ = LogixiaLoggerModule.getGlobalLogger()) === null || _LogixiaLoggerModule$ === void 0 || _LogixiaLoggerModule$.warn(`[KafkaTraceInterceptor] Missing traceId on topic "${rpcData === null || rpcData === void 0 ? void 0 : rpcData.topic}" — message skipped.`);
-				return EMPTY;
-			}
-			_KafkaTraceInterceptor.metrics.acceptedWithoutTrace++;
-			return next.handle();
-		}
-		_KafkaTraceInterceptor.metrics.accepted++;
-		const kafkaContext = {
-			messageType: "kafka",
-			topic: rpcData === null || rpcData === void 0 ? void 0 : rpcData.topic,
-			partition: rpcData === null || rpcData === void 0 ? void 0 : rpcData.partition,
-			offset: rpcData === null || rpcData === void 0 ? void 0 : rpcData.offset,
-			key: rpcData === null || rpcData === void 0 ? void 0 : rpcData.key,
-			timestamp: rpcData === null || rpcData === void 0 ? void 0 : rpcData.timestamp
-		};
-		return new Observable((subscriber) => {
-			let inner;
-			this.ctx.run(traceId, () => {
-				inner = next.handle().subscribe({
-					next: (value) => subscriber.next(value),
-					error: (err) => subscriber.error(err),
-					complete: () => subscriber.complete()
-				});
-			}, kafkaContext);
-			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
-		});
-	}
-};
-KafkaTraceInterceptor = _KafkaTraceInterceptor = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [Object, Boolean])], KafkaTraceInterceptor);
-
-//#endregion
-//#region \0@oxc-project+runtime@0.95.0/helpers/decorateParam.js
-function __decorateParam(paramIndex, decorator) {
-	return function(target, key) {
-		decorator(target, key, paramIndex);
-	};
-}
-
-//#endregion
-//#region src/core/trace.middleware.ts
-/** Default response header used to echo the resolved traceId back to the caller. */
-const DEFAULT_TRACE_RESPONSE_HEADER = "X-Trace-Id";
-/**
-* Resolve the response header name from config.
-* - `undefined`   → default `'X-Trace-Id'`
-* - `string`      → user's custom header
-* - `false`       → `null` (suppress entirely)
-*/
-function resolveResponseHeader(config) {
-	if ((config === null || config === void 0 ? void 0 : config.responseHeader) === false) return null;
-	return (config === null || config === void 0 ? void 0 : config.responseHeader) ?? DEFAULT_TRACE_RESPONSE_HEADER;
-}
-/**
-* Echo the trace ID on the response, tolerating non-Express responses and
-* already-sent headers. NestJS can run on Fastify (reply.header() instead of
-* res.setHeader()), and on a closed/sent response setHeader throws — neither
-* should crash the request. The trace ID is still propagated via async context.
-*/
-function writeTraceHeader(res, header, traceId) {
-	const r = res;
-	if (r.headersSent) return;
-	try {
-		if (typeof r.setHeader === "function") r.setHeader(header, traceId);
-		else if (typeof r.header === "function") r.header(header, traceId);
-	} catch {}
-}
-let TraceMiddleware = class TraceMiddleware$1 {
-	constructor(config) {
-		this.config = config;
-		this.ctx = TraceContext.instance;
-		const defaultExtractor = {
-			header: DEFAULT_TRACE_HEADERS,
-			query: ["traceId", "trace_id"]
-		};
-		this.config = {
-			enabled: true,
-			generator: () => this.ctx.generate(),
-			contextKey: "traceId",
-			...config,
-			extractor: (config === null || config === void 0 ? void 0 : config.extractor) ? {
-				...defaultExtractor,
-				...config.extractor
-			} : defaultExtractor
-		};
-		if (this.config.enabled) this.ctx.setContextKey(this.config.contextKey ?? "traceId");
-	}
-	use(req, res, next) {
-		var _this$config, _req$socket, _req$connection;
-		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next();
-		let traceId;
-		if (this.config.extractor) traceId = extractTraceId(req, this.config.extractor);
-		if (!traceId && this.config.generator) {
-			const candidate = this.config.generator();
-			if (typeof candidate === "string" && candidate.trim().length > 0) traceId = candidate;
-			else internalWarn("TraceIdConfig.generator returned a non-string/empty value — using built-in generator.");
-		}
-		if (!traceId) traceId = this.ctx.generate();
-		req.traceId = traceId;
-		const header = resolveResponseHeader(this.config);
-		if (header) writeTraceHeader(res, header, traceId);
-		this.ctx.run(traceId, () => next(), {
-			method: req.method,
-			url: req.url,
-			userAgent: req.get("User-Agent"),
-			ip: req.ip || ((_req$socket = req.socket) === null || _req$socket === void 0 ? void 0 : _req$socket.remoteAddress) || ((_req$connection = req.connection) === null || _req$connection === void 0 ? void 0 : _req$connection.remoteAddress)
-		});
-	}
-};
-TraceMiddleware = __decorate([
-	Injectable(),
-	__decorateParam(0, Optional()),
-	__decorateMetadata("design:paramtypes", [Object])
-], TraceMiddleware);
-
-//#endregion
-//#region src/core/websocket-trace.interceptor.ts
-let WebSocketTraceInterceptor = class WebSocketTraceInterceptor$1 {
-	constructor(config) {
-		this.config = config;
-		this.ctx = TraceContext.instance;
-		this.config = {
-			enabled: true,
-			contextKey: "traceId",
-			extractor: {
-				body: [
-					"traceId",
-					"trace_id",
-					"x-trace-id"
-				],
-				header: ["x-trace-id", "trace-id"],
-				query: ["traceId", "trace_id"]
-			},
-			...config
-		};
-	}
-	intercept(context, next) {
-		var _this$config, _client$handshake3;
-		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next.handle();
-		const wsContext = context.switchToWs();
-		const data = wsContext.getData();
-		const client = wsContext.getClient();
-		let traceId;
-		if (this.config.extractor) {
-			var _client$handshake, _client$handshake2;
-			traceId = extractTraceId({
-				body: data,
-				headers: (client === null || client === void 0 || (_client$handshake = client.handshake) === null || _client$handshake === void 0 ? void 0 : _client$handshake.headers) || {},
-				query: (client === null || client === void 0 || (_client$handshake2 = client.handshake) === null || _client$handshake2 === void 0 ? void 0 : _client$handshake2.query) || {},
-				params: {}
-			}, this.config.extractor);
-		}
-		if (!traceId) traceId = this.ctx.getCurrentTraceId();
-		if (!traceId) return next.handle();
-		const wsContextData = {
-			messageType: "websocket",
-			event: data === null || data === void 0 ? void 0 : data.event,
-			socketId: client === null || client === void 0 ? void 0 : client.id,
-			rooms: (client === null || client === void 0 ? void 0 : client.rooms) ? Array.from(client.rooms) : [],
-			clientAddress: client === null || client === void 0 || (_client$handshake3 = client.handshake) === null || _client$handshake3 === void 0 ? void 0 : _client$handshake3.address
-		};
-		return new Observable((observer) => {
-			let inner;
-			this.ctx.run(traceId, () => {
-				inner = next.handle().subscribe({
-					next: (value) => observer.next(value),
-					error: (err) => observer.error(err),
-					complete: () => observer.complete()
-				});
-			}, wsContextData);
-			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
-		});
-	}
-};
-WebSocketTraceInterceptor = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [Object])], WebSocketTraceInterceptor);
-
-//#endregion
-//#region src/core/logitron-logger.module.ts
-var _LogixiaLoggerModule;
-const DEFAULT_ROUTES = [{
-	path: "*",
-	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 {
-		_LogixiaLoggerModule = this;
-	}
-	constructor() {
-		this.config = {};
-	}
-	static #_ = this.loggerConfig = {};
-	static #_2 = this._globalLogger = null;
-	/**
-	* @internal Set the global logger exactly once.
-	*
-	* Called from the module's forRoot / forRootAsync factory. If the module is
-	* initialised more than once in the same process (nested DI context, test
-	* harness creating multiple apps, hot reload, etc.) a warning is written to
-	* stderr and the first logger wins — silently overwriting would allow the
-	* newer instance's transport config to replace the live one while the old
-	* one is still being used by registered shutdown hooks, decorators, etc.
-	*
-	* Use {@link _resetGlobalLogger} in tests to reset between runs.
-	*/
-	static _setGlobalLogger(service) {
-		if (_LogixiaLoggerModule._globalLogger !== null) {
-			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;
-	}
-	/** @internal Clear the global logger. Tests only. */
-	static _resetGlobalLogger() {
-		_LogixiaLoggerModule._globalLogger = null;
-	}
-	/**
-	* Returns the global LogixiaLoggerService instance that was created when the
-	* module booted. Useful for logging outside of NestJS DI — utility functions,
-	* plain scripts, decorators — without injecting the service everywhere.
-	*
-	* Returns `null` if called before `LogixiaLoggerModule.forRoot[Async]()` has
-	* been initialised (i.e. before the NestJS app has started).
-	*
-	* @example
-	* ```ts
-	* // some-util.ts
-	* import { LogixiaLoggerModule } from 'logixia/nest';
-	*
-	* export function doSomething() {
-	*   LogixiaLoggerModule.getGlobalLogger()?.info('doing something');
-	* }
-	* ```
-	*/
-	static getGlobalLogger() {
-		return _LogixiaLoggerModule._globalLogger;
-	}
-	configure(consumer) {
-		const { forRoutes = DEFAULT_ROUTES, exclude } = this.config;
-		let resolvedTraceConfig;
-		if (typeof _LogixiaLoggerModule.loggerConfig.traceId === "object") resolvedTraceConfig = _LogixiaLoggerModule.loggerConfig.traceId;
-		else if (_LogixiaLoggerModule.loggerConfig.traceId === true) resolvedTraceConfig = {
-			enabled: true,
-			contextKey: "traceId",
-			generator: () => TraceContext.instance.generate()
-		};
-		const middleware = new TraceMiddleware(resolvedTraceConfig);
-		const middlewareConfig = (req, res, next) => middleware.use(req, res, next);
-		if (exclude) consumer.apply(middlewareConfig).exclude(...exclude).forRoutes(...forRoutes);
-		else consumer.apply(middlewareConfig).forRoutes(...forRoutes);
-	}
-	/**
-	* Configure the module with synchronous options
-	*/
-	static forRoot(config) {
-		_LogixiaLoggerModule.loggerConfig = config || {};
-		const traceConfig = (config === null || config === void 0 ? void 0 : config.traceId) && typeof config.traceId === "object" ? config.traceId : { enabled: !!(config === null || config === void 0 ? void 0 : config.traceId) };
-		return {
-			module: _LogixiaLoggerModule,
-			providers: [
-				{
-					provide: LOGIXIA_LOGGER_CONFIG,
-					useValue: config || {}
-				},
-				{
-					provide: LOGIXIA_TRACE_CONFIG,
-					useValue: traceConfig
-				},
-				{
-					provide: LogixiaLoggerService,
-					useFactory: (loggerConfig) => {
-						const service = new LogixiaLoggerService({
-							level: "info",
-							service: "NestJSApp",
-							environment: "development",
-							fields: {},
-							formatters: ["text"],
-							outputs: ["console"],
-							levelOptions: {
-								level: "info",
-								levels: {
-									error: 0,
-									warn: 1,
-									info: 2,
-									debug: 3,
-									verbose: 4
-								},
-								colors: {
-									error: "red",
-									warn: "yellow",
-									info: "green",
-									debug: "blue",
-									verbose: "cyan"
-								}
-							},
-							...loggerConfig
-						});
-						_LogixiaLoggerModule._setGlobalLogger(service);
-						return service;
-					},
-					inject: [LOGIXIA_LOGGER_CONFIG]
-				},
-				{
-					provide: KafkaTraceInterceptor,
-					useFactory: (traceConfig$1) => new KafkaTraceInterceptor(traceConfig$1),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				},
-				{
-					provide: WebSocketTraceInterceptor,
-					useFactory: (traceConfig$1) => new WebSocketTraceInterceptor(traceConfig$1),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				}
-			],
-			exports: [
-				LogixiaLoggerService,
-				LOGIXIA_LOGGER_CONFIG,
-				KafkaTraceInterceptor,
-				WebSocketTraceInterceptor
-			],
-			global: true
-		};
-	}
-	/**
-	* Configure the module with asynchronous options
-	*/
-	static forRootAsync(options) {
-		return {
-			module: _LogixiaLoggerModule,
-			imports: options.imports || [],
-			providers: [
-				...this.createAsyncProviders(options),
-				{
-					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) };
-					},
-					inject: [LOGIXIA_LOGGER_CONFIG]
-				},
-				{
-					provide: LogixiaLoggerService,
-					useFactory: (loggerConfig) => {
-						const defaultConfig = {
-							level: "info",
-							service: "NestJSApp",
-							environment: "development",
-							fields: {},
-							formatters: ["text"],
-							outputs: ["console"],
-							levelOptions: {
-								level: "info",
-								levels: {
-									error: 0,
-									warn: 1,
-									info: 2,
-									debug: 3,
-									verbose: 4
-								},
-								colors: {
-									error: "red",
-									warn: "yellow",
-									info: "green",
-									debug: "blue",
-									verbose: "cyan"
-								}
-							},
-							...loggerConfig
-						};
-						_LogixiaLoggerModule.loggerConfig = defaultConfig;
-						const service = new LogixiaLoggerService(defaultConfig);
-						_LogixiaLoggerModule._setGlobalLogger(service);
-						return service;
-					},
-					inject: [LOGIXIA_LOGGER_CONFIG]
-				},
-				{
-					provide: KafkaTraceInterceptor,
-					useFactory: (traceConfig) => new KafkaTraceInterceptor(traceConfig),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				},
-				{
-					provide: WebSocketTraceInterceptor,
-					useFactory: (traceConfig) => new WebSocketTraceInterceptor(traceConfig),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				}
-			],
-			exports: [
-				LogixiaLoggerService,
-				LOGIXIA_LOGGER_CONFIG,
-				KafkaTraceInterceptor,
-				WebSocketTraceInterceptor
-			],
-			global: true
-		};
-	}
-	/**
-	* Create feature-specific logger instances
-	*/
-	static forFeature(context) {
-		const providerToken = `${LOGIXIA_LOGGER_PREFIX}${context.toUpperCase()}`;
-		return {
-			module: _LogixiaLoggerModule,
-			providers: [{
-				provide: providerToken,
-				useFactory: (baseLogger) => {
-					return baseLogger.child(context);
-				},
-				inject: [LogixiaLoggerService]
-			}],
-			exports: [providerToken]
-		};
-	}
-	static createAsyncProviders(options) {
-		if (options.useExisting || options.useFactory) return [this.createAsyncOptionsProvider(options)];
-		return [this.createAsyncOptionsProvider(options), {
-			provide: options.useClass,
-			useClass: options.useClass
-		}];
-	}
-	static createAsyncOptionsProvider(options) {
-		if (options.useFactory) return {
-			provide: LOGIXIA_LOGGER_CONFIG,
-			useFactory: options.useFactory,
-			inject: options.inject || []
-		};
-		return {
-			provide: LOGIXIA_LOGGER_CONFIG,
-			useFactory: async (optionsFactory) => await optionsFactory.createLogixiaOptions(),
-			inject: [options.useExisting || options.useClass]
-		};
-	}
-};
-LogixiaLoggerModule = _LogixiaLoggerModule = __decorate([Module({})], LogixiaLoggerModule);
-
-//#endregion
-//#region src/exceptions/exception.ts
+// src/exceptions/exception.ts
 var LogixiaException = class extends Error {
 	constructor(options) {
 		super(options.message, { cause: options.cause });
@@ -2431,9 +1895,21 @@ var LogixiaException = class extends Error {
 function isLogixiaException(value) {
 	return value instanceof LogixiaException;
 }
-
-//#endregion
-//#region src/exceptions/builder.ts
+// src/exceptions/builder.ts
+/**
+* ErrorResponseBuilder — turns any exception into a `LogixiaErrorResponse`.
+*
+* Priority order:
+*  1. `LogixiaException`      — typed fields used directly
+*  2. NestJS `HttpException`  — duck-typed; status + message extracted
+*  3. Plain `Error` / unknown — falls back to 500 `server_error`
+*
+* The builder **always** populates `debug` when possible.
+* Your exception filter is responsible for stripping it in production:
+* ```ts
+* if (process.env.NODE_ENV === 'production') delete response.debug;
+* ```
+*/
 /**
 * Generates a trace ID via the shared {@link TraceContext} generator.
 *
@@ -2535,7 +2011,7 @@ var ErrorResponseBuilder = class {
 		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
 		const durationMs = startTime !== void 0 ? Date.now() - startTime : void 0;
 		if (isLogixiaException(exception)) {
-			const debug$1 = buildDebug(exception, service, durationMs, expose);
+			const debug = buildDebug(exception, service, durationMs, expose);
 			const errorBlock = {
 				type: exception.errorType,
 				code: exception.errorCode,
@@ -2554,7 +2030,7 @@ var ErrorResponseBuilder = class {
 						path,
 						status: exception.httpStatus
 					},
-					...debug$1 !== void 0 ? { debug: debug$1 } : {}
+					...debug !== void 0 ? { debug } : {}
 				},
 				httpStatus: exception.httpStatus
 			};
@@ -2570,7 +2046,7 @@ var ErrorResponseBuilder = class {
 			} else message = exception.message;
 			const type = httpStatusToType(status);
 			const code = `HTTP_${status}`;
-			const debug$1 = buildDebug(exception, service, durationMs, expose);
+			const debug = buildDebug(exception, service, durationMs, expose);
 			return {
 				response: {
 					success: false,
@@ -2585,7 +2061,7 @@ var ErrorResponseBuilder = class {
 						path,
 						status
 					},
-					...debug$1 !== void 0 ? { debug: debug$1 } : {}
+					...debug !== void 0 ? { debug } : {}
 				},
 				httpStatus: status
 			};
@@ -2611,168 +2087,6 @@ var ErrorResponseBuilder = class {
 		};
 	}
 };
+export { globalPluginRegistry as C, DEFAULT_LOG_LEVELS as D, DEFAULT_LOG_COLORS as E, LogLevel as O, PluginRegistry as S, DEFAULT_CONFIG as T, getOtelMetaFields as _, isLogixiaException as a, normalizeError as b, _shutdownRegistrySize as c, registerForShutdown as d, resetShutdownHandlers as f, getActiveOtelContext as g, disableOtelBridge as h, LogixiaException as i, deregisterFromShutdown as l, redactObject as m, generateRequestId as n, LogixiaLogger as o, applyRedaction as p, generateTraceId as r, createLogger as s, ErrorResponseBuilder as t, flushOnExit as u, initOtelBridge as v, usePlugin as w, serializeError as x, isError as y };
 
-//#endregion
-//#region src/core/nestjs-extras.ts
-var _ref;
-/**
-* Inject the Logixia logger registered in the current NestJS DI container.
-*
-* Equivalent to `@Inject(LOGIXIA_LOGGER_TOKEN)` but without needing to import
-* the internal token constant yourself.
-*
-* @example
-* ```ts
-* constructor(@InjectLogger() private readonly logger: LogixiaLoggerService) {}
-* ```
-*/
-const InjectLogger = () => Inject(`${LOGIXIA_LOGGER_PREFIX}SERVICE`);
-/**
-* Method decorator that auto-logs entry, exit, duration, and errors.
-*
-* Preserves the original method's sync/async contract: a synchronous method
-* stays synchronous (returns its value directly, with logs emitted
-* fire-and-forget), and an async method is awaited so exit/error logs reflect
-* the resolved result. Attaches to the logger found on the class instance via a
-* `logger` property (the conventional NestJS name).
-*
-* @example
-* ```ts
-* @LogMethod({ level: 'info', logArgs: true })
-* async processPayment(orderId: string): Promise<void> { … }
-* ```
-*/
-function LogMethod(options = {}) {
-	const { level = "debug", logArgs = true, logResult = false, logErrors = true } = options;
-	return function(target, propertyKey, descriptor) {
-		var _constructor;
-		const originalMethod = descriptor.value;
-		if (typeof originalMethod !== "function") return descriptor;
-		const methodName = String(propertyKey);
-		const className = ((_constructor = target.constructor) === null || _constructor === void 0 ? void 0 : _constructor.name) ?? "Unknown";
-		const label = options.label ?? `${className}.${methodName}`;
-		let _warnedNoLogger = false;
-		const reportLogFailure = (phase, err) => {
-			internalError(`@LogMethod(${label}) ${phase} log failed: ${String(err)}`);
-		};
-		const emit = (logger, phase, message, data) => {
-			const logFnRaw = logger[level];
-			const p = (typeof logFnRaw === "function" ? logFnRaw : logger.debug).bind(logger)(message, data);
-			if (p && typeof p.catch === "function") p.catch((e) => reportLogFailure(phase, e));
-		};
-		const emitError = (logger, error, start) => {
-			const err = error instanceof Error ? error : new Error(String(error));
-			const errLog = logger.error(err, {
-				method: label,
-				durationMs: Date.now() - start
-			});
-			if (errLog && typeof errLog.catch === "function") errLog.catch((e) => reportLogFailure("error", e));
-		};
-		descriptor.value = function(...args) {
-			const logger = this.logger ?? LogixiaLoggerModule._globalLogger ?? void 0;
-			if (!logger && !_warnedNoLogger) {
-				_warnedNoLogger = true;
-				internalWarn(`@LogMethod on ${label}: no logger available. Either inject LogixiaLoggerService as this.logger or ensure LogixiaLoggerModule is initialised.`);
-			}
-			const start = Date.now();
-			const entry = { method: label };
-			if (logArgs && args.length > 0) entry["args"] = args;
-			if (logger) emit(logger, "entry", `→ ${label}`, entry);
-			const buildExit = (result$1) => {
-				const exit = {
-					method: label,
-					durationMs: Date.now() - start
-				};
-				if (logResult) exit["result"] = result$1;
-				return exit;
-			};
-			let result;
-			try {
-				result = originalMethod.apply(this, args);
-			} catch (error) {
-				if (logger && logErrors) emitError(logger, error, start);
-				throw error;
-			}
-			if (result && typeof result.then === "function") return result.then((resolved) => {
-				if (logger) emit(logger, "exit", `← ${label}`, buildExit(resolved));
-				return resolved;
-			}, (error) => {
-				if (logger && logErrors) emitError(logger, error, start);
-				throw error;
-			});
-			if (logger) emit(logger, "exit", `← ${label}`, buildExit(result));
-			return result;
-		};
-		return descriptor;
-	};
-}
-/** Injection token for {@link LogixiaExceptionFilterOptions}. */
-const LOGIXIA_EXCEPTION_FILTER_OPTIONS = "LOGIXIA_EXCEPTION_FILTER_OPTIONS";
-let LogixiaExceptionFilter = class LogixiaExceptionFilter$1 {
-	constructor(logger, loggerConfig, options) {
-		this._options = options ?? {};
-		this._logger = logger ?? LogixiaLoggerModule._globalLogger ?? void 0;
-		this._traceConfig = typeof (loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) === "object" ? loggerConfig.traceId : void 0;
-	}
-	catch(exception, host) {
-		var _request$headers;
-		const ctx = host.switchToHttp();
-		const request = ctx.getRequest();
-		const response = ctx.getResponse();
-		const traceId = TraceContext.instance.getCurrentTraceId() ?? sanitizeIncomingId((_request$headers = request.headers) === null || _request$headers === void 0 ? void 0 : _request$headers["x-trace-id"]) ?? sanitizeIncomingId(request.id) ?? void 0;
-		const { response: errorResponse, httpStatus } = ErrorResponseBuilder.build({
-			exception,
-			traceId,
-			path: request.url ?? "/",
-			startTime: request.startTime,
-			exposeDebug: this._options.exposeDebug === true,
-			exposeCause: this._options.exposeCause === true
-		});
-		if (this._logger) {
-			const requestMeta = {
-				method: request.method ?? "",
-				url: request.url ?? "",
-				status: httpStatus,
-				...errorResponse.meta.trace_id !== void 0 ? { trace_id: errorResponse.meta.trace_id } : {}
-			};
-			const onLogFailure = (err) => {
-				internalError(`ExceptionFilter failed to write log entry: ${String(err)}`);
-			};
-			let logPromise;
-			if (httpStatus >= 500) {
-				const err = exception instanceof Error ? exception : new Error(String(exception));
-				logPromise = this._logger.error(err, requestMeta);
-			} else if (isLogixiaException(exception)) logPromise = this._logger.warn(`[${errorResponse.error.code}] ${errorResponse.error.message}`, requestMeta);
-			else logPromise = this._logger.warn(`[${httpStatus}] ${errorResponse.error.message}`, requestMeta);
-			if (logPromise && typeof logPromise.catch === "function") logPromise.catch(onLogFailure);
-		}
-		if (errorResponse.meta.trace_id) {
-			const traceHeader = resolveResponseHeader(this._traceConfig);
-			if (traceHeader) try {
-				response.setHeader(traceHeader, errorResponse.meta.trace_id);
-			} catch {}
-		}
-		if (httpStatus === 429) try {
-			response.setHeader("Retry-After", "60");
-		} catch {}
-		response.status(httpStatus).json(errorResponse);
-	}
-};
-LogixiaExceptionFilter = __decorate([
-	Catch(),
-	__decorateParam(0, Optional()),
-	__decorateParam(0, Inject(`${LOGIXIA_LOGGER_PREFIX}SERVICE`)),
-	__decorateParam(1, Optional()),
-	__decorateParam(1, Inject(LOGIXIA_LOGGER_CONFIG)),
-	__decorateParam(2, Optional()),
-	__decorateParam(2, Inject(LOGIXIA_EXCEPTION_FILTER_OPTIONS)),
-	__decorateMetadata("design:paramtypes", [
-		Object,
-		typeof (_ref = typeof Partial !== "undefined" && Partial) === "function" ? _ref : Object,
-		Object
-	])
-], LogixiaExceptionFilter);
-
-//#endregion
-export { initOtelBridge as A, registerForShutdown as C, disableOtelBridge as D, redactObject as E, DEFAULT_LOG_LEVELS as F, LogLevel as I, PluginRegistry as L, normalizeError as M, serializeError as N, getActiveOtelContext as O, DEFAULT_LOG_COLORS as P, globalPluginRegistry as R, flushOnExit as S, applyRedaction as T, LogixiaLoggerService as _, ErrorResponseBuilder as a, _shutdownRegistrySize as b, LogixiaException as c, LOGIXIA_LOGGER_PREFIX as d, LOGIXIA_TRACE_CONFIG as f, KafkaTraceInterceptor as g, TraceMiddleware as h, LogixiaExceptionFilter as i, isError as j, getOtelMetaFields as k, isLogixiaException as l, WebSocketTraceInterceptor as m, LOGIXIA_EXCEPTION_FILTER_OPTIONS as n, generateRequestId as o, LogixiaLoggerModule as p, LogMethod as r, generateTraceId as s, InjectLogger as t, LOGIXIA_LOGGER_CONFIG as u, LogixiaLogger as v, resetShutdownHandlers as w, deregisterFromShutdown as x, createLogger as y, usePlugin as z };
-//# sourceMappingURL=nestjs-extras-ImbuDhs1.mjs.map
+//# sourceMappingURL=builder-D70z6kjj.mjs.map