logixia 1.13.3 → 2.0.4

package/dist/{nestjs-extras-DnJ6vrIC.js → builder-M7NoaugM.js}

@@ -1,20 +1,83 @@
-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_trace_utils = require('./trace.utils-DpBOLDtq.js');
-const require_async_context = require('./async-context-DyQQYq3I.js');
-const require_coerce_utils = require('./coerce.utils-B-LilukN.js');
-const require_transport_manager = require('./transport.manager-Crau3Rle.js');
-let node_os = require("node:os");
-node_os = require_chunk.__toESM(node_os);
+const require_secret_config = require("./secret-config-CBZBs0p1.js");
+const require_request_trace = require("./request-trace-wTJdKp6-.js");
+const require_async_context = require("./async-context-DTQgi8f7.js");
+const require_internal_log = require("./internal-log-b0Vp4qrB.js");
+const require_coerce_utils = require("./coerce.utils-C1C5sIX0.js");
+const require_safe_stringify = require("./safe-stringify-DLz1Kz3o.js");
+const require_transport_manager = require("./transport.manager-DkcEOlqV.js");
 let fast_json_stringify = require("fast-json-stringify");
-fast_json_stringify = require_chunk.__toESM(fast_json_stringify);
-let __nestjs_common = require("@nestjs/common");
-__nestjs_common = require_chunk.__toESM(__nestjs_common);
-let rxjs = require("rxjs");
-rxjs = require_chunk.__toESM(rxjs);
-
-//#region src/plugin.ts
+fast_json_stringify = require_secret_config.__toESM(fast_json_stringify);
+let node_os = require("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
@@ -119,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",
@@ -190,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",
@@ -278,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;
@@ -385,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;
@@ -416,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 = require_internal_log.SENSITIVE_KEY_NAMES.map((name) => `**.${name}`);
 /**
 * Aggressive patterns: also catch personal data that could identify a person.
 * Applied when `autoDetect: 'aggressive'`.
@@ -655,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;
@@ -704,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"
@@ -725,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 = [];
@@ -905,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();
@@ -1027,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 = (0, fast_json_stringify.default)({
 	type: "object",
 	properties: {
@@ -1059,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;
@@ -1101,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"];
@@ -1111,12 +1127,25 @@ 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();
 		this.contextData = {};
 		this.fieldState = /* @__PURE__ */ new Map();
-		this.fallbackTraceId = require_trace_utils.TraceContext.instance.generate();
+		this.fallbackTraceId = require_request_trace.TraceContext.instance.generate();
 		this._levelValues = /* @__PURE__ */ new Map();
 		this._minLevelValue = 2;
 		this._warnedInvalidLevels = /* @__PURE__ */ new Set();
@@ -1128,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,
@@ -1156,7 +1185,10 @@ var LogixiaLogger = class LogixiaLogger {
 					[LogLevel.TRACE]: "gray",
 					[LogLevel.VERBOSE]: "cyan"
 				}
-			},
+			}
+		};
+		this.config = {
+			...defaultConfig,
 			...config
 		};
 		const resolvedLevel = resolveInitialLevel(this.config);
@@ -1174,6 +1206,7 @@ var LogixiaLogger = class LogixiaLogger {
 			timeTaken: "[time_taken_MS]"
 		};
 		this.context = context ?? "";
+		require_secret_config.protectSecrets(this, ["config"]);
 		if (parent) {
 			this.transportManager = parent.transportManager;
 			this._sampler = parent._sampler;
@@ -1239,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"],
@@ -1282,7 +1315,7 @@ var LogixiaLogger = class LogixiaLogger {
 			"green",
 			"blue"
 		];
-		const _BUILTIN_LEVELS = new Set([
+		const _BUILTIN_LEVELS = /* @__PURE__ */ new Set([
 			"error",
 			"warn",
 			"info",
@@ -1296,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");
@@ -1311,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,
@@ -1318,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) {
@@ -1371,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) {
@@ -1379,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;
@@ -1435,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 : require_coerce_utils.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();
 		require_internal_log.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();
 		require_internal_log.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",
@@ -1475,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();
 		require_internal_log.internalLog("Field state reset to configuration defaults");
@@ -1489,10 +1575,12 @@ var LogixiaLogger = class LogixiaLogger {
 		if (this.transportManager) this.transportManager.disableLevelPrompting();
 		else require_internal_log.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 require_internal_log.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);
 		require_internal_log.internalWarn("Transport manager not initialized");
@@ -1501,10 +1589,23 @@ var LogixiaLogger = class LogixiaLogger {
 		if (this.transportManager) this.transportManager.clearTransportLevelPreferences();
 		else require_internal_log.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 = {
@@ -1540,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,
@@ -1550,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`, {
@@ -1566,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 ? require_trace_utils.TraceContext.instance.getCurrentTraceId() : void 0;
-			if (!this._sampler.shouldEmit(level, traceId$1)) return;
-		}
 		const alsContext = require_async_context.LogixiaContext.get();
+		let activeTraceId;
+		if (this.config.traceId) {
+			const ctxTraceId = alsContext === null || alsContext === void 0 ? void 0 : alsContext.traceId;
+			activeTraceId = require_request_trace.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;
@@ -1590,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) {
-			require_internal_log.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) {
+				require_internal_log.internalError("Redaction failed", error);
+				payload = { redaction: REDACTION_FAILED };
+			}
+			else payload = rawPayload;
 		}
-		else payload = rawPayload;
-		const traceId = this.config.traceId ? require_trace_utils.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);
@@ -1635,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();
@@ -1714,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);
@@ -1725,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) => require_internal_log.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) => 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_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_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_internal_log.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 : require_coerce_utils.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 require_trace_utils.TraceContext.instance.getCurrentTraceId();
-	}
-	/** Returns the AsyncLocalStorage key currently used to store the trace ID. */
-	get traceContextKey() {
-		return require_trace_utils.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 require_coerce_utils.safeToString(message);
-	}
-};
-LogixiaLoggerService = _LogixiaLoggerService = __decorate([(0, __nestjs_common.Injectable)({ scope: __nestjs_common.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 = require_trace_utils.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 = require_trace_utils.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 rxjs.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 rxjs.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([(0, __nestjs_common.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 = require_trace_utils.TraceContext.instance;
-		const defaultExtractor = {
-			header: require_trace_utils.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 = require_trace_utils.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 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;
-		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([
-	(0, __nestjs_common.Injectable)(),
-	__decorateParam(0, (0, __nestjs_common.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 = require_trace_utils.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 = require_trace_utils.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 rxjs.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([(0, __nestjs_common.Injectable)(), __decorateMetadata("design:paramtypes", [Object])], WebSocketTraceInterceptor);
-
-//#endregion
-//#region src/core/logitron-logger.module.ts
-var _LogixiaLoggerModule;
-const DEFAULT_ROUTES = [{
-	path: "*",
-	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 {
-		_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) {
-			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;
-	}
-	/** @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: () => require_trace_utils.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([(0, __nestjs_common.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 });
@@ -2435,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.
 *
@@ -2448,7 +1920,7 @@ function isLogixiaException(value) {
 * @example `'550e8400-e29b-41d4-a716-446655440000'`
 */
 function generateTraceId() {
-	return require_trace_utils.TraceContext.instance.generate();
+	return require_request_trace.TraceContext.instance.generate();
 }
 /** @deprecated Use `generateTraceId` instead. */
 const generateRequestId = generateTraceId;
@@ -2535,11 +2007,11 @@ var ErrorResponseBuilder = class {
 			debug: exposeDebug,
 			cause: exposeCause
 		};
-		const traceId = require_trace_utils.TraceContext.instance.getCurrentTraceId() ?? rawTraceId;
+		const traceId = require_request_trace.TraceContext.instance.getCurrentTraceId() ?? rawTraceId;
 		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,
@@ -2558,7 +2030,7 @@ var ErrorResponseBuilder = class {
 						path,
 						status: exception.httpStatus
 					},
-					...debug$1 !== void 0 ? { debug: debug$1 } : {}
+					...debug !== void 0 ? { debug } : {}
 				},
 				httpStatus: exception.httpStatus
 			};
@@ -2574,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,
@@ -2589,7 +2061,7 @@ var ErrorResponseBuilder = class {
 						path,
 						status
 					},
-					...debug$1 !== void 0 ? { debug: debug$1 } : {}
+					...debug !== void 0 ? { debug } : {}
 				},
 				httpStatus: status
 			};
@@ -2615,401 +2087,173 @@ var ErrorResponseBuilder = class {
 		};
 	}
 };
-
-//#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 = () => (0, __nestjs_common.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) => {
-			require_internal_log.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;
-				require_internal_log.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 = require_trace_utils.TraceContext.instance.getCurrentTraceId() ?? require_trace_utils.sanitizeIncomingId((_request$headers = request.headers) === null || _request$headers === void 0 ? void 0 : _request$headers["x-trace-id"]) ?? require_trace_utils.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) => {
-				require_internal_log.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);
+Object.defineProperty(exports, "DEFAULT_CONFIG", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_CONFIG;
 	}
-};
-LogixiaExceptionFilter = __decorate([
-	(0, __nestjs_common.Catch)(),
-	__decorateParam(0, (0, __nestjs_common.Optional)()),
-	__decorateParam(0, (0, __nestjs_common.Inject)(`${LOGIXIA_LOGGER_PREFIX}SERVICE`)),
-	__decorateParam(1, (0, __nestjs_common.Optional)()),
-	__decorateParam(1, (0, __nestjs_common.Inject)(LOGIXIA_LOGGER_CONFIG)),
-	__decorateParam(2, (0, __nestjs_common.Optional)()),
-	__decorateParam(2, (0, __nestjs_common.Inject)(LOGIXIA_EXCEPTION_FILTER_OPTIONS)),
-	__decorateMetadata("design:paramtypes", [
-		Object,
-		typeof (_ref = typeof Partial !== "undefined" && Partial) === "function" ? _ref : Object,
-		Object
-	])
-], LogixiaExceptionFilter);
-
-//#endregion
-Object.defineProperty(exports, 'DEFAULT_LOG_COLORS', {
-  enumerable: true,
-  get: function () {
-    return DEFAULT_LOG_COLORS;
-  }
-});
-Object.defineProperty(exports, 'DEFAULT_LOG_LEVELS', {
-  enumerable: true,
-  get: function () {
-    return DEFAULT_LOG_LEVELS;
-  }
-});
-Object.defineProperty(exports, 'ErrorResponseBuilder', {
-  enumerable: true,
-  get: function () {
-    return ErrorResponseBuilder;
-  }
-});
-Object.defineProperty(exports, 'InjectLogger', {
-  enumerable: true,
-  get: function () {
-    return InjectLogger;
-  }
 });
-Object.defineProperty(exports, 'KafkaTraceInterceptor', {
-  enumerable: true,
-  get: function () {
-    return KafkaTraceInterceptor;
-  }
-});
-Object.defineProperty(exports, 'LOGIXIA_EXCEPTION_FILTER_OPTIONS', {
-  enumerable: true,
-  get: function () {
-    return LOGIXIA_EXCEPTION_FILTER_OPTIONS;
-  }
-});
-Object.defineProperty(exports, 'LOGIXIA_LOGGER_CONFIG', {
-  enumerable: true,
-  get: function () {
-    return LOGIXIA_LOGGER_CONFIG;
-  }
-});
-Object.defineProperty(exports, 'LOGIXIA_LOGGER_PREFIX', {
-  enumerable: true,
-  get: function () {
-    return LOGIXIA_LOGGER_PREFIX;
-  }
-});
-Object.defineProperty(exports, 'LOGIXIA_TRACE_CONFIG', {
-  enumerable: true,
-  get: function () {
-    return LOGIXIA_TRACE_CONFIG;
-  }
-});
-Object.defineProperty(exports, 'LogLevel', {
-  enumerable: true,
-  get: function () {
-    return LogLevel;
-  }
-});
-Object.defineProperty(exports, 'LogMethod', {
-  enumerable: true,
-  get: function () {
-    return LogMethod;
-  }
-});
-Object.defineProperty(exports, 'LogixiaException', {
-  enumerable: true,
-  get: function () {
-    return LogixiaException;
-  }
-});
-Object.defineProperty(exports, 'LogixiaExceptionFilter', {
-  enumerable: true,
-  get: function () {
-    return LogixiaExceptionFilter;
-  }
+Object.defineProperty(exports, "DEFAULT_LOG_COLORS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_LOG_COLORS;
+	}
 });
-Object.defineProperty(exports, 'LogixiaLogger', {
-  enumerable: true,
-  get: function () {
-    return LogixiaLogger;
-  }
+Object.defineProperty(exports, "DEFAULT_LOG_LEVELS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_LOG_LEVELS;
+	}
 });
-Object.defineProperty(exports, 'LogixiaLoggerModule', {
-  enumerable: true,
-  get: function () {
-    return LogixiaLoggerModule;
-  }
+Object.defineProperty(exports, "ErrorResponseBuilder", {
+	enumerable: true,
+	get: function() {
+		return ErrorResponseBuilder;
+	}
 });
-Object.defineProperty(exports, 'LogixiaLoggerService', {
-  enumerable: true,
-  get: function () {
-    return LogixiaLoggerService;
-  }
+Object.defineProperty(exports, "LogLevel", {
+	enumerable: true,
+	get: function() {
+		return LogLevel;
+	}
 });
-Object.defineProperty(exports, 'PluginRegistry', {
-  enumerable: true,
-  get: function () {
-    return PluginRegistry;
-  }
+Object.defineProperty(exports, "LogixiaException", {
+	enumerable: true,
+	get: function() {
+		return LogixiaException;
+	}
 });
-Object.defineProperty(exports, 'TraceMiddleware', {
-  enumerable: true,
-  get: function () {
-    return TraceMiddleware;
-  }
+Object.defineProperty(exports, "LogixiaLogger", {
+	enumerable: true,
+	get: function() {
+		return LogixiaLogger;
+	}
 });
-Object.defineProperty(exports, 'WebSocketTraceInterceptor', {
-  enumerable: true,
-  get: function () {
-    return WebSocketTraceInterceptor;
-  }
+Object.defineProperty(exports, "PluginRegistry", {
+	enumerable: true,
+	get: function() {
+		return PluginRegistry;
+	}
 });
-Object.defineProperty(exports, '_shutdownRegistrySize', {
-  enumerable: true,
-  get: function () {
-    return _shutdownRegistrySize;
-  }
+Object.defineProperty(exports, "_shutdownRegistrySize", {
+	enumerable: true,
+	get: function() {
+		return _shutdownRegistrySize;
+	}
 });
-Object.defineProperty(exports, 'applyRedaction', {
-  enumerable: true,
-  get: function () {
-    return applyRedaction;
-  }
+Object.defineProperty(exports, "applyRedaction", {
+	enumerable: true,
+	get: function() {
+		return applyRedaction;
+	}
 });
-Object.defineProperty(exports, 'createLogger', {
-  enumerable: true,
-  get: function () {
-    return createLogger;
-  }
+Object.defineProperty(exports, "createLogger", {
+	enumerable: true,
+	get: function() {
+		return createLogger;
+	}
 });
-Object.defineProperty(exports, 'deregisterFromShutdown', {
-  enumerable: true,
-  get: function () {
-    return deregisterFromShutdown;
-  }
+Object.defineProperty(exports, "deregisterFromShutdown", {
+	enumerable: true,
+	get: function() {
+		return deregisterFromShutdown;
+	}
 });
-Object.defineProperty(exports, 'disableOtelBridge', {
-  enumerable: true,
-  get: function () {
-    return disableOtelBridge;
-  }
+Object.defineProperty(exports, "disableOtelBridge", {
+	enumerable: true,
+	get: function() {
+		return disableOtelBridge;
+	}
 });
-Object.defineProperty(exports, 'flushOnExit', {
-  enumerable: true,
-  get: function () {
-    return flushOnExit;
-  }
+Object.defineProperty(exports, "flushOnExit", {
+	enumerable: true,
+	get: function() {
+		return flushOnExit;
+	}
 });
-Object.defineProperty(exports, 'generateRequestId', {
-  enumerable: true,
-  get: function () {
-    return generateRequestId;
-  }
+Object.defineProperty(exports, "generateRequestId", {
+	enumerable: true,
+	get: function() {
+		return generateRequestId;
+	}
 });
-Object.defineProperty(exports, 'generateTraceId', {
-  enumerable: true,
-  get: function () {
-    return generateTraceId;
-  }
+Object.defineProperty(exports, "generateTraceId", {
+	enumerable: true,
+	get: function() {
+		return generateTraceId;
+	}
 });
-Object.defineProperty(exports, 'getActiveOtelContext', {
-  enumerable: true,
-  get: function () {
-    return getActiveOtelContext;
-  }
+Object.defineProperty(exports, "getActiveOtelContext", {
+	enumerable: true,
+	get: function() {
+		return getActiveOtelContext;
+	}
 });
-Object.defineProperty(exports, 'getOtelMetaFields', {
-  enumerable: true,
-  get: function () {
-    return getOtelMetaFields;
-  }
+Object.defineProperty(exports, "getOtelMetaFields", {
+	enumerable: true,
+	get: function() {
+		return getOtelMetaFields;
+	}
 });
-Object.defineProperty(exports, 'globalPluginRegistry', {
-  enumerable: true,
-  get: function () {
-    return globalPluginRegistry;
-  }
+Object.defineProperty(exports, "globalPluginRegistry", {
+	enumerable: true,
+	get: function() {
+		return globalPluginRegistry;
+	}
 });
-Object.defineProperty(exports, 'initOtelBridge', {
-  enumerable: true,
-  get: function () {
-    return initOtelBridge;
-  }
+Object.defineProperty(exports, "initOtelBridge", {
+	enumerable: true,
+	get: function() {
+		return initOtelBridge;
+	}
 });
-Object.defineProperty(exports, 'isError', {
-  enumerable: true,
-  get: function () {
-    return isError;
-  }
+Object.defineProperty(exports, "isError", {
+	enumerable: true,
+	get: function() {
+		return isError;
+	}
 });
-Object.defineProperty(exports, 'isLogixiaException', {
-  enumerable: true,
-  get: function () {
-    return isLogixiaException;
-  }
+Object.defineProperty(exports, "isLogixiaException", {
+	enumerable: true,
+	get: function() {
+		return isLogixiaException;
+	}
 });
-Object.defineProperty(exports, 'normalizeError', {
-  enumerable: true,
-  get: function () {
-    return normalizeError;
-  }
+Object.defineProperty(exports, "normalizeError", {
+	enumerable: true,
+	get: function() {
+		return normalizeError;
+	}
 });
-Object.defineProperty(exports, 'redactObject', {
-  enumerable: true,
-  get: function () {
-    return redactObject;
-  }
+Object.defineProperty(exports, "redactObject", {
+	enumerable: true,
+	get: function() {
+		return redactObject;
+	}
 });
-Object.defineProperty(exports, 'registerForShutdown', {
-  enumerable: true,
-  get: function () {
-    return registerForShutdown;
-  }
+Object.defineProperty(exports, "registerForShutdown", {
+	enumerable: true,
+	get: function() {
+		return registerForShutdown;
+	}
 });
-Object.defineProperty(exports, 'resetShutdownHandlers', {
-  enumerable: true,
-  get: function () {
-    return resetShutdownHandlers;
-  }
+Object.defineProperty(exports, "resetShutdownHandlers", {
+	enumerable: true,
+	get: function() {
+		return resetShutdownHandlers;
+	}
 });
-Object.defineProperty(exports, 'serializeError', {
-  enumerable: true,
-  get: function () {
-    return serializeError;
-  }
+Object.defineProperty(exports, "serializeError", {
+	enumerable: true,
+	get: function() {
+		return serializeError;
+	}
 });
-Object.defineProperty(exports, 'usePlugin', {
-  enumerable: true,
-  get: function () {
-    return usePlugin;
-  }
+Object.defineProperty(exports, "usePlugin", {
+	enumerable: true,
+	get: function() {
+		return usePlugin;
+	}
 });
-//# sourceMappingURL=nestjs-extras-DnJ6vrIC.js.map
+
+//# sourceMappingURL=builder-M7NoaugM.js.map