logixia 1.8.2 → 1.8.4

package/dist/logitron-logger.module-CMDM61Iz.js

@@ -0,0 +1,2566 @@
+const require_transport_manager = require('./transport.manager-DPjB-dFH.js');
+let fast_json_stringify = require("fast-json-stringify");
+fast_json_stringify = require_transport_manager.__toESM(fast_json_stringify);
+let node_async_hooks = require("node:async_hooks");
+node_async_hooks = require_transport_manager.__toESM(node_async_hooks);
+let node_crypto = require("node:crypto");
+node_crypto = require_transport_manager.__toESM(node_crypto);
+let crypto = require("crypto");
+crypto = require_transport_manager.__toESM(crypto);
+let __nestjs_common = require("@nestjs/common");
+__nestjs_common = require_transport_manager.__toESM(__nestjs_common);
+let rxjs = require("rxjs");
+rxjs = require_transport_manager.__toESM(rxjs);
+
+//#region src/context/async-context.ts
+/** Generates an 8-character random ID using Node's crypto module. */
+function randomShortId() {
+	return (0, node_crypto.randomUUID)().slice(0, 8);
+}
+const _storage = new node_async_hooks.AsyncLocalStorage();
+const LogixiaContext = {
+	run(store, callback) {
+		const parent = _storage.getStore() ?? {};
+		return _storage.run({
+			...parent,
+			...store
+		}, callback);
+	},
+	get() {
+		return _storage.getStore();
+	},
+	set(fields) {
+		const store = _storage.getStore();
+		if (!store) return;
+		Object.assign(store, fields);
+	},
+	getStorage() {
+		return _storage;
+	}
+};
+/**
+* Create an Express/Connect-compatible middleware that wraps each request in
+* a `LogixiaContext.run()` scope populated with common request fields.
+*
+* @example
+* ```ts
+* import { createExpressContextMiddleware } from 'logixia';
+* app.use(createExpressContextMiddleware());
+* ```
+*/
+function createExpressContextMiddleware(options = {}) {
+	const { enrich, traceIdHeader = "x-trace-id" } = options;
+	return function logixiaContextMiddleware(req, _res, next) {
+		const base = { traceId: (req["headers"] ?? {})[traceIdHeader] ?? randomShortId() };
+		LogixiaContext.run({
+			...base,
+			...enrich ? enrich(req) : {}
+		}, next);
+	};
+}
+/**
+* Create a Fastify lifecycle hook that wraps each request in a context scope.
+*
+* Register with `fastify.addHook('onRequest', createFastifyContextHook())`.
+*/
+function createFastifyContextHook(options = {}) {
+	const { enrich, traceIdHeader = "x-trace-id" } = options;
+	return function logixiaFastifyHook(request, _reply, done) {
+		const base = { traceId: (request["headers"] ?? {})[traceIdHeader] ?? request["id"] ?? randomShortId() };
+		LogixiaContext.run({
+			...base,
+			...enrich ? enrich(request) : {}
+		}, done);
+	};
+}
+
+//#endregion
+//#region 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
+* singleton is also exported for process-wide registration.
+*/
+var PluginRegistry = class {
+	constructor() {
+		this._plugins = [];
+	}
+	/**
+	* Register a plugin. Silently skips if a plugin with the same `name` is
+	* already registered on this registry.
+	*/
+	register(plugin) {
+		if (this._plugins.some((p) => p.name === plugin.name)) return;
+		this._plugins.push(plugin);
+		if (plugin.onInit) {
+			const result = plugin.onInit();
+			if (result instanceof Promise) result.catch(() => {});
+		}
+	}
+	/** Remove a previously registered plugin by name. No-op if not found. */
+	unregister(name) {
+		const idx = this._plugins.findIndex((p) => p.name === name);
+		if (idx !== -1) this._plugins.splice(idx, 1);
+	}
+	/** Returns `true` if a plugin with the given name is registered. */
+	has(name) {
+		return this._plugins.some((p) => p.name === name);
+	}
+	/** Number of currently registered plugins. */
+	get size() {
+		return this._plugins.length;
+	}
+	/**
+	* Run all `onLog` hooks in order.
+	* Returns `null` if any plugin cancels the entry; otherwise returns the
+	* (possibly transformed) entry.
+	*/
+	async runOnLog(entry) {
+		let current = entry;
+		for (const plugin of this._plugins) {
+			if (!plugin.onLog) continue;
+			current = await plugin.onLog(current);
+			if (current === null) return null;
+		}
+		return current;
+	}
+	/**
+	* Notify all `onError` hooks.
+	* Errors thrown inside hooks are swallowed to prevent error cascades.
+	*/
+	async runOnError(error, entry) {
+		for (const plugin of this._plugins) if (plugin.onError) {
+			const r = plugin.onError(error, entry);
+			if (r instanceof Promise) await r.catch(() => {});
+		}
+	}
+	/** Run all `onShutdown` hooks concurrently. Hook errors are swallowed. */
+	async runOnShutdown() {
+		await Promise.all(this._plugins.filter((p) => Boolean(p.onShutdown)).map((p) => {
+			const r = p.onShutdown();
+			return r instanceof Promise ? r.catch(() => {}) : Promise.resolve();
+		}));
+	}
+};
+/**
+* Module-level singleton registry.
+*
+* Plugins registered here are automatically copied into every **new** logger
+* instance created after the registration. Already-created loggers are not
+* retroactively affected — use `logger.use(plugin)` for per-instance control.
+*/
+const globalPluginRegistry = new PluginRegistry();
+/**
+* Register a plugin in the global registry so it applies to every future
+* logger instance.
+*
+* @example
+* ```ts
+* import { usePlugin } from 'logixia';
+*
+* usePlugin({
+*   name: 'audit-sink',
+*   onLog(entry) {
+*     if (entry.level === 'error') auditQueue.push(entry);
+*     return entry;
+*   },
+* });
+* ```
+*/
+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
+const EXTRA_FIELDS = [
+	"code",
+	"statusCode",
+	"status",
+	"errno",
+	"syscall",
+	"path",
+	"address",
+	"port",
+	"type"
+];
+/**
+* Serialize an Error into a plain JSON-safe object, including:
+*  - `name`, `message`, `stack`
+*  - `cause` (recursively serialized, full ES2022 chain)
+*  - `errors` (for AggregateError)
+*  - standard Node.js error fields (`code`, `statusCode`, `errno`, …)
+*  - any other enumerable own properties
+*/
+function serializeError(error, options = {}) {
+	const { includeStack = true, maxDepth = 5, excludeFields = [] } = options;
+	return _serializeError(error, includeStack, maxDepth, excludeFields, 0, /* @__PURE__ */ new WeakSet());
+}
+function _serializeError(error, includeStack, maxDepth, excludeFields, depth, seen) {
+	if (depth >= maxDepth) return {
+		name: error.name,
+		message: error.message,
+		_truncated: true
+	};
+	if (seen.has(error)) return {
+		name: error.name,
+		message: error.message,
+		_circular: true
+	};
+	seen.add(error);
+	const serialized = {
+		name: error.name,
+		message: error.message
+	};
+	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);
+	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));
+	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([
+		"name",
+		"message",
+		"stack",
+		"cause",
+		"errors",
+		...EXTRA_FIELDS,
+		...excludeFields
+	]);
+	for (const key of Object.getOwnPropertyNames(error)) {
+		if (skip.has(key)) continue;
+		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+		try {
+			serialized[key] = serializeValue(errorRecord[key], maxDepth - depth - 1);
+		} catch {
+			serialized[key] = "[Unserializable]";
+		}
+	}
+	return serialized;
+}
+/**
+* Recursively serialize an arbitrary value to a JSON-safe representation.
+*/
+function serializeValue(value, remainingDepth) {
+	if (remainingDepth <= 0) return "[Max Depth]";
+	if (value === null || value === void 0) return value;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof Error) return _serializeError(value, true, remainingDepth, [], 0, /* @__PURE__ */ new WeakSet());
+	if (Array.isArray(value)) return value.map((item) => serializeValue(item, remainingDepth - 1));
+	if (typeof value === "object") {
+		const out = {};
+		for (const [k, v] of Object.entries(value)) {
+			if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
+			try {
+				out[k] = serializeValue(v, remainingDepth - 1);
+			} catch {
+				out[k] = "[Unserializable]";
+			}
+		}
+		return out;
+	}
+	return String(value);
+}
+/**
+* Type guard: returns true if the value looks like an Error object.
+*/
+function isError(value) {
+	return value instanceof Error || Boolean(value) && typeof value === "object" && "name" in value && "message" in value;
+}
+/**
+* Coerce any thrown value into a proper Error instance.
+*/
+function normalizeError(error) {
+	if (isError(error)) return error;
+	if (typeof error === "string") return new Error(error);
+	if (typeof error === "object" && error !== null) {
+		const e = error;
+		const err = new Error(typeof e["message"] === "string" ? e["message"] : "Unknown error");
+		Object.assign(err, error);
+		return err;
+	}
+	return new Error(String(error));
+}
+
+//#endregion
+//#region src/utils/otel.ts
+let _otelApi;
+function tryLoadOtelApi() {
+	if (_otelApi !== void 0) return _otelApi;
+	try {
+		_otelApi = require("@opentelemetry/api");
+		return _otelApi;
+	} catch {
+		_otelApi = null;
+		return null;
+	}
+}
+/**
+* Read the currently active OTel span context (if any) and return its fields
+* in a plain object suitable for spreading into a log entry.
+*
+* Returns `undefined` when:
+* - `@opentelemetry/api` is not installed
+* - No active span exists (root context)
+* - The span context is invalid (all-zeros)
+*/
+function getActiveOtelContext(opts = {}) {
+	const api = tryLoadOtelApi();
+	if (!api) return void 0;
+	const ctx = api.context.active();
+	const sc = api.trace.getSpanContext(ctx);
+	if (!sc || !api.trace.isSpanContextValid(sc)) return void 0;
+	const isSampled = (sc.traceFlags & api.trace.TraceFlags.SAMPLED) === api.trace.TraceFlags.SAMPLED;
+	if (opts.sampledOnly && !isSampled) return void 0;
+	return {
+		traceId: sc.traceId,
+		spanId: sc.spanId,
+		traceFlags: sc.traceFlags,
+		isSampled
+	};
+}
+/**
+* Returns a metadata object with OTel context fields ready to merge into a log call,
+* using the configured field names.
+*
+* Returns `{}` when no active span exists (safe to spread unconditionally).
+*
+* @example
+* ```ts
+* await logger.info('Payment processed', {
+*   ...getOtelMetaFields(),
+*   orderId: 'ord_123',
+* });
+* ```
+*/
+function getOtelMetaFields(opts = {}) {
+	const { traceIdField = "traceId", spanIdField = "spanId", traceFlagsField = "traceFlags" } = opts;
+	const ctx = getActiveOtelContext(opts);
+	if (!ctx) return {};
+	return {
+		[traceIdField]: ctx.traceId,
+		[spanIdField]: ctx.spanId,
+		[traceFlagsField]: ctx.traceFlags
+	};
+}
+let _bridgeOptions = null;
+/**
+* Initialise the global OTel bridge.
+*
+* Once called, logixia's internal log pipeline checks for an active OTel span
+* on **every** log call and automatically merges the span context into the
+* entry's metadata — no per-call wiring needed.
+*
+* Call once at app startup, **after** the OTel SDK has been initialised:
+* ```ts
+* import { initOtelBridge } from 'logixia';
+* initOtelBridge();
+* ```
+*/
+function initOtelBridge(opts = {}) {
+	_bridgeOptions = opts;
+}
+/**
+* @internal
+* Used by the core logger to inject OTel context when the bridge is active.
+* Returns `{}` when the bridge is not initialised or no active span exists.
+*/
+function _getOtelPayloadIfEnabled() {
+	if (!_bridgeOptions) return {};
+	return getOtelMetaFields(_bridgeOptions);
+}
+/**
+* Disable the OTel bridge (useful for tests).
+*/
+function disableOtelBridge() {
+	_bridgeOptions = null;
+}
+
+//#endregion
+//#region src/utils/redact.utils.ts
+const DEFAULT_CENSOR = "[REDACTED]";
+/**
+* Conservative patterns: tokens and secrets that should NEVER appear in logs.
+* Applied when `autoDetect: true` or `autoDetect: 'conservative'`.
+*/
+const PII_CONSERVATIVE_PATTERNS = [
+	/eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g,
+	/Bearer\s+[A-Za-z0-9._~+/-]+=*/gi,
+	/\b(?:sk|pk|api|key|secret|token)-[A-Za-z0-9_-]{16,}/gi,
+	/\bAKIA[0-9A-Z]{16}\b/g,
+	/\b[A-Za-z0-9/+]{40}\b(?=.*aws)/gi
+];
+/**
+* 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"
+];
+/**
+* Aggressive patterns: also catch personal data that could identify a person.
+* Applied when `autoDetect: 'aggressive'`.
+*/
+const PII_AGGRESSIVE_PATTERNS = [
+	/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+	/\b\d{3}-?\d{2}-?\d{4}\b/g,
+	/\b(?:\d[ -]?){13,19}\b/g,
+	/\b(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
+	/\b(?:\d{1,3}\.){3}\d{1,3}\b/g
+];
+const PII_AGGRESSIVE_PATHS = [
+	...PII_CONSERVATIVE_PATHS,
+	"**.email",
+	"**.emailAddress",
+	"**.email_address",
+	"**.phone",
+	"**.phoneNumber",
+	"**.phone_number",
+	"**.mobile",
+	"**.ssn",
+	"**.sin",
+	"**.dob",
+	"**.dateOfBirth",
+	"**.date_of_birth",
+	"**.creditCard",
+	"**.credit_card",
+	"**.cardNumber",
+	"**.card_number",
+	"**.cvv",
+	"**.cvc",
+	"**.ipAddress",
+	"**.ip_address"
+];
+/**
+* Build an effective config that merges `autoDetect` PII rules into the
+* explicit `paths` and `patterns` the caller provided.
+*/
+function resolveConfig(config) {
+	const { autoDetect } = config;
+	if (!autoDetect) return config;
+	const aggressive = autoDetect === "aggressive";
+	const extraPaths = aggressive ? PII_AGGRESSIVE_PATHS : PII_CONSERVATIVE_PATHS;
+	const extraPatterns = aggressive ? [...PII_CONSERVATIVE_PATTERNS, ...PII_AGGRESSIVE_PATTERNS] : PII_CONSERVATIVE_PATTERNS;
+	const { paths = [], patterns = [] } = config;
+	return {
+		...config,
+		paths: [...paths, ...extraPaths],
+		patterns: [...patterns, ...extraPatterns]
+	};
+}
+/**
+* Convert a dot-notation path pattern to a RegExp.
+* Supports `*` (one segment) and `**` (zero or more segments).
+*
+* Examples:
+*   "password"          → /^password$/
+*   "user.password"     → /^user\.password$/
+*   "*.token"           → /^[^.]+\.token$/
+*   "req.headers.*"     → /^req\.headers\.[^.]+$/
+*   "**"                → /^.*$/
+*/
+function pathToRegExp(pattern) {
+	const regexStr = pattern.split(".").map((segment) => {
+		if (segment === "**") return ".*";
+		if (segment === "*") return "[^.]+";
+		return segment.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&");
+	}).join("\\.");
+	return /* @__PURE__ */ new RegExp(`^${regexStr}$`);
+}
+/** Pre-compiled path matchers keyed by pattern string for perf */
+const patternCache = /* @__PURE__ */ new Map();
+function matchesPath(fullPath, pattern) {
+	let re = patternCache.get(pattern);
+	if (!re) {
+		re = pathToRegExp(pattern);
+		patternCache.set(pattern, re);
+	}
+	return re.test(fullPath);
+}
+/**
+* Deep-clone and redact an object according to the given RedactConfig.
+* Non-objects are returned as-is (with pattern replacement on strings).
+*
+* The function is intentionally non-mutating — it returns a new object.
+*/
+function redactObject(obj, config, _currentPath = "") {
+	const { paths = [], patterns = [], censor = DEFAULT_CENSOR } = config;
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+		const fullPath = _currentPath ? `${_currentPath}.${key}` : key;
+		if (paths.length > 0 && paths.some((p) => matchesPath(fullPath, p))) {
+			result[key] = censor;
+			continue;
+		}
+		if (isPlainObject(value)) {
+			result[key] = redactObject(value, config, fullPath);
+			continue;
+		}
+		if (typeof value === "string" && patterns.length > 0) {
+			let redacted = value;
+			for (const pattern of patterns) redacted = redacted.replace(pattern, censor);
+			result[key] = redacted;
+			continue;
+		}
+		if (Array.isArray(value)) {
+			result[key] = value.map((item) => {
+				if (isPlainObject(item)) return redactObject(item, config, fullPath);
+				if (typeof item === "string" && patterns.length > 0) return patterns.reduce((s, p) => s.replace(p, censor), item);
+				return item;
+			});
+			continue;
+		}
+		result[key] = value;
+	}
+	return result;
+}
+/**
+* Apply redaction to a log payload (top-level call convenience wrapper).
+* Returns a new object — never mutates the input.
+*/
+function applyRedaction(payload, config) {
+	if (!payload || !config) return payload;
+	const resolved = resolveConfig(config);
+	if ((!resolved.paths || resolved.paths.length === 0) && (!resolved.patterns || resolved.patterns.length === 0)) return payload;
+	return redactObject(payload, resolved);
+}
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Error) && !(value instanceof RegExp);
+}
+
+//#endregion
+//#region src/utils/sampling.utils.ts
+const ALWAYS_EMIT_LEVELS = new Set(["error", "fatal"]);
+var Sampler = class {
+	constructor(config, onStats) {
+		this.sampledTraces = /* @__PURE__ */ new Set();
+		this.droppedTraces = /* @__PURE__ */ new Set();
+		this._tokenBucket = 0;
+		this._lastRefillMs = Date.now();
+		this._stats = {
+			evaluated: 0,
+			emitted: 0,
+			dropped: 0,
+			byLevel: {},
+			windowStart: Date.now()
+		};
+		this.config = config;
+		if (config.maxLogsPerSecond && config.maxLogsPerSecond > 0) this._tokenBucket = config.maxLogsPerSecond;
+		const interval = config.statsIntervalMs ?? 6e4;
+		if (interval > 0 && onStats) {
+			this._statsTimer = setInterval(() => {
+				onStats(this.getStats());
+				this.resetStats();
+			}, interval);
+			if (this._statsTimer.unref) this._statsTimer.unref();
+		}
+	}
+	/**
+	* Decide whether a given log entry should be emitted.
+	*
+	* @param level    Log level string (lowercase)
+	* @param traceId  Active trace ID, if any
+	* @returns true → emit, false → drop
+	*/
+	shouldEmit(level, traceId) {
+		var _this$config$perLevel;
+		const lvl = level.toLowerCase();
+		this._trackEvaluated(lvl);
+		if (ALWAYS_EMIT_LEVELS.has(lvl) && ((_this$config$perLevel = this.config.perLevel) === null || _this$config$perLevel === void 0 ? void 0 : _this$config$perLevel[lvl]) === void 0) {
+			this._trackEmitted(lvl);
+			return true;
+		}
+		if (this.config.traceConsistent && traceId) {
+			if (this.sampledTraces.has(traceId)) {
+				this._trackEmitted(lvl);
+				return true;
+			}
+			if (this.droppedTraces.has(traceId)) {
+				this._trackDropped(lvl);
+				return false;
+			}
+			const emit = this._sampleByRate(lvl);
+			if (emit) this.sampledTraces.add(traceId);
+			else this.droppedTraces.add(traceId);
+			if (emit) this._trackEmitted(lvl);
+			else this._trackDropped(lvl);
+			return emit;
+		}
+		if (!this._sampleByRate(lvl)) {
+			this._trackDropped(lvl);
+			return false;
+		}
+		if (this.config.maxLogsPerSecond && this.config.maxLogsPerSecond > 0) {
+			if (!this._consumeToken()) {
+				this._trackDropped(lvl);
+				return false;
+			}
+		}
+		this._trackEmitted(lvl);
+		return true;
+	}
+	getStats() {
+		return {
+			...this._stats,
+			byLevel: { ...this._stats.byLevel }
+		};
+	}
+	resetStats() {
+		this._stats = {
+			evaluated: 0,
+			emitted: 0,
+			dropped: 0,
+			byLevel: {},
+			windowStart: Date.now()
+		};
+		this.sampledTraces.clear();
+		this.droppedTraces.clear();
+	}
+	destroy() {
+		if (this._statsTimer) clearInterval(this._statsTimer);
+	}
+	_sampleByRate(level) {
+		var _this$config$perLevel2, _this$config$perLevel3;
+		const rate = ((_this$config$perLevel2 = this.config.perLevel) === null || _this$config$perLevel2 === void 0 ? void 0 : _this$config$perLevel2[level]) ?? ((_this$config$perLevel3 = this.config.perLevel) === null || _this$config$perLevel3 === void 0 ? void 0 : _this$config$perLevel3["*"]) ?? this.config.rate ?? 1;
+		if (rate >= 1) return true;
+		if (rate <= 0) return false;
+		return Math.random() < rate;
+	}
+	_consumeToken() {
+		const now = Date.now();
+		const elapsed = (now - this._lastRefillMs) / 1e3;
+		const max = this.config.maxLogsPerSecond;
+		this._tokenBucket = Math.min(max, this._tokenBucket + elapsed * max);
+		this._lastRefillMs = now;
+		if (this._tokenBucket >= 1) {
+			this._tokenBucket -= 1;
+			return true;
+		}
+		return false;
+	}
+	_ensure(level) {
+		if (!this._stats.byLevel[level]) this._stats.byLevel[level] = {
+			evaluated: 0,
+			emitted: 0
+		};
+	}
+	_trackEvaluated(level) {
+		this._stats.evaluated++;
+		this._ensure(level);
+		this._stats.byLevel[level].evaluated++;
+	}
+	_trackEmitted(level) {
+		this._stats.emitted++;
+		this._ensure(level);
+		this._stats.byLevel[level].emitted++;
+	}
+	_trackDropped(_level) {
+		this._stats.dropped++;
+	}
+};
+
+//#endregion
+//#region src/utils/shutdown.utils.ts
+/** Module-level registry of all logger instances that have opted into graceful shutdown */
+const registry = /* @__PURE__ */ new Set();
+let shutdownHandlerRegistered = false;
+/**
+* Register a logger instance so it is included in the graceful shutdown flush.
+* Called automatically when `gracefulShutdown: true` is set in logger config.
+*/
+function registerForShutdown(logger) {
+	registry.add(logger);
+}
+/**
+* Deregister a logger (e.g. after `logger.close()` is called manually).
+*/
+function deregisterFromShutdown(logger) {
+	registry.delete(logger);
+}
+/**
+* Register SIGTERM / SIGINT handlers that flush all registered loggers before
+* the process exits. Idempotent — calling multiple times is safe.
+*
+* @example
+* ```ts
+* import { flushOnExit } from 'logixia';
+* flushOnExit({ timeout: 5000 });
+* ```
+*/
+function flushOnExit(options = {}) {
+	if (shutdownHandlerRegistered) return;
+	shutdownHandlerRegistered = true;
+	const { timeout = 5e3, signals = ["SIGTERM", "SIGINT"], beforeFlush, afterFlush } = options;
+	const handler = async (signal) => {
+		const forceExitTimer = setTimeout(() => {
+			process.stderr.write(`[logixia] Graceful shutdown timed out after ${timeout}ms on ${signal}. Force-exiting.\n`);
+			process.exit(1);
+		}, timeout).unref();
+		try {
+			if (beforeFlush) await beforeFlush();
+			await Promise.allSettled([...registry].map((logger) => logger.close()));
+			if (afterFlush) await afterFlush();
+		} finally {
+			clearTimeout(forceExitTimer);
+			process.exit(0);
+		}
+	};
+	for (const signal of signals) if (process.listenerCount(signal) === 0) process.on(signal, handler);
+}
+/**
+* Remove all graceful shutdown handlers and clear the registry.
+* Primarily useful in tests.
+*/
+function resetShutdownHandlers() {
+	registry.clear();
+	shutdownHandlerRegistered = false;
+}
+
+//#endregion
+//#region node_modules/uuid/dist/esm-node/rng.js
+const rnds8Pool = new Uint8Array(256);
+let poolPtr = rnds8Pool.length;
+function rng() {
+	if (poolPtr > rnds8Pool.length - 16) {
+		crypto.default.randomFillSync(rnds8Pool);
+		poolPtr = 0;
+	}
+	return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+//#endregion
+//#region node_modules/uuid/dist/esm-node/stringify.js
+/**
+* Convert array of 16 byte values to UUID string format of the form:
+* XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+*/
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) byteToHex.push((i + 256).toString(16).slice(1));
+function unsafeStringify(arr, offset = 0) {
+	return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+
+//#endregion
+//#region node_modules/uuid/dist/esm-node/native.js
+var native_default = { randomUUID: crypto.default.randomUUID };
+
+//#endregion
+//#region node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+	if (native_default.randomUUID && !buf && !options) return native_default.randomUUID();
+	options = options || {};
+	const rnds = options.random || (options.rng || rng)();
+	rnds[6] = rnds[6] & 15 | 64;
+	rnds[8] = rnds[8] & 63 | 128;
+	if (buf) {
+		offset = offset || 0;
+		for (let i = 0; i < 16; ++i) buf[offset + i] = rnds[i];
+		return buf;
+	}
+	return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+//#endregion
+//#region src/utils/trace.utils.ts
+/** Default key used to store the trace ID in AsyncLocalStorage. */
+const TRACE_CONTEXT_KEY = "traceId";
+/**
+* Singleton that owns the AsyncLocalStorage and the active contextKey.
+*
+* Why a class instead of bare module-level variables?
+*  - The contextKey is user-configurable; encapsulating it here means there is
+*    exactly one place that reads and writes it.
+*  - All helpers (getCurrentTraceId, runWithTraceId, etc.) delegate to this
+*    instance, so the key is always in sync without hidden global state.
+*  - Easier to test: you can reset the singleton between test cases.
+*
+* Usage (advanced):
+*   import { TraceContext } from 'logixia';
+*   TraceContext.instance.contextKey          // → 'traceId' (or custom)
+*   TraceContext.instance.getCurrentTraceId() // same as standalone fn
+*/
+var TraceContext = class TraceContext {
+	static #_ = this._instance = null;
+	constructor() {
+		this.storage = new node_async_hooks.AsyncLocalStorage();
+		this._contextKey = TRACE_CONTEXT_KEY;
+	}
+	/** The process-wide singleton. */
+	static get instance() {
+		if (!TraceContext._instance) TraceContext._instance = new TraceContext();
+		return TraceContext._instance;
+	}
+	/** @internal Reset the singleton (useful in tests). */
+	static _reset() {
+		TraceContext._instance = null;
+	}
+	/** The AsyncLocalStorage key that holds the trace ID value. */
+	get contextKey() {
+		return this._contextKey;
+	}
+	/** @internal Called by TraceMiddleware when it boots to register the user's key. */
+	setContextKey(key) {
+		this._contextKey = key;
+	}
+	/** UUID v4 generator (default). */
+	generate() {
+		return v4_default();
+	}
+	/** Read the trace ID from the current async context. */
+	getCurrentTraceId() {
+		var _this$storage$getStor;
+		return (_this$storage$getStor = this.storage.getStore()) === null || _this$storage$getStor === void 0 ? void 0 : _this$storage$getStor[this._contextKey];
+	}
+	/**
+	* Mutate the CURRENT async context in-place.
+	*
+	* ⚠️  DEPRECATED — unsafe for concurrent requests.
+	*
+	* Uses `AsyncLocalStorage.enterWith()`, which mutates the current async
+	* execution context and every Promise chain spawned from it. In a server
+	* processing overlapping requests this can cause a trace ID set for one
+	* request to bleed into *other* in-flight requests that share the same
+	* async parent (e.g. a module-level setup function or a cached handler).
+	*
+	* Use {@link run} instead — it scopes the context to a callback so there
+	* is no risk of cross-request leakage.
+	*
+	* @deprecated Use `TraceContext.instance.run(traceId, fn)` — do not call
+	*             `setTraceId` from request-handling code.
+	*/
+	setTraceId(traceId, data) {
+		const current = this.storage.getStore() ?? {};
+		this.storage.enterWith({
+			...current,
+			[this._contextKey]: traceId,
+			...data
+		});
+	}
+	/** Run `fn` inside a new async context that carries `traceId`. */
+	run(traceId, fn, data) {
+		return this.storage.run({
+			[this._contextKey]: traceId,
+			...data
+		}, fn);
+	}
+};
+/**
+* The shared AsyncLocalStorage instance.
+* @deprecated Prefer `TraceContext.instance.storage` for new code.
+*/
+const traceStorage = TraceContext.instance.storage;
+/** Returns the key currently used to store the trace ID in AsyncLocalStorage. */
+function getTraceContextKey() {
+	return TraceContext.instance.contextKey;
+}
+/** @internal Called by TraceMiddleware / traceMiddleware() when they boot. */
+function _setActiveContextKey(key) {
+	TraceContext.instance.setContextKey(key);
+}
+/** Generate a UUID v4 trace ID. */
+function generateTraceId() {
+	return TraceContext.instance.generate();
+}
+/**
+* Get the current trace ID from async context.
+* Returns `undefined` when called outside a traced request.
+*/
+function getCurrentTraceId() {
+	return TraceContext.instance.getCurrentTraceId();
+}
+/**
+* Set trace ID in the CURRENT async context without starting a new one.
+*
+* ⚠️  DEPRECATED — unsafe for concurrent requests.
+*
+* Uses `AsyncLocalStorage.enterWith()`, which mutates the current async
+* execution context and every Promise chain spawned from it. Under load this
+* can cause a trace ID from one request to bleed into others sharing the same
+* async parent.
+*
+* Use {@link runWithTraceId} instead. Migration patterns:
+*
+* **Express / Fastify middleware — before:**
+* ```ts
+* app.use((req, _res, next) => {
+*   setTraceId(req.headers['x-trace-id'] ?? generateTraceId());
+*   next();
+* });
+* ```
+* **after:**
+* ```ts
+* app.use((req, _res, next) => {
+*   runWithTraceId(req.headers['x-trace-id'] ?? generateTraceId(), () => next());
+* });
+* ```
+*
+* **Kafka / queue consumer — before:**
+* ```ts
+* async function handle(msg) {
+*   setTraceId(msg.headers['x-trace-id']);
+*   await processMessage(msg);
+* }
+* ```
+* **after:**
+* ```ts
+* async function handle(msg) {
+*   await runWithTraceId(msg.headers['x-trace-id'], () => processMessage(msg));
+* }
+* ```
+*
+* **Background job — before:**
+* ```ts
+* setTraceId(generateTraceId(), { jobId: job.id });
+* await job.run();
+* ```
+* **after:**
+* ```ts
+* await runWithTraceId(generateTraceId(), () => job.run(), { jobId: job.id });
+* ```
+*
+* @deprecated Use `runWithTraceId(traceId, fn)` — do not call `setTraceId`
+*             from request-handling code.
+*/
+function setTraceId(traceId, data) {
+	TraceContext.instance.setTraceId(traceId, data);
+}
+/** Run `fn` inside a new async context carrying `traceId`. */
+function runWithTraceId(traceId, fn, data) {
+	return TraceContext.instance.run(traceId, fn, data);
+}
+/**
+* Coerce an arbitrary value to a non-empty trace ID string, or `undefined`.
+* Rejects empty/whitespace-only strings, non-strings, and non-first array elements.
+*/
+function toValidTraceId(value) {
+	const first = Array.isArray(value) ? value[0] : value;
+	if (typeof first !== "string") return void 0;
+	const trimmed = first.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/** Extract trace ID from request using configuration (header → query → body → params). */
+function extractTraceId(request, config) {
+	const req = request;
+	if (config.header) {
+		const headers = Array.isArray(config.header) ? config.header : [config.header];
+		for (const header of headers) {
+			var _req$headers;
+			const value = toValidTraceId((_req$headers = req.headers) === null || _req$headers === void 0 ? void 0 : _req$headers[header.toLowerCase()]);
+			if (value) return value;
+		}
+	}
+	if (config.query) {
+		const queries = Array.isArray(config.query) ? config.query : [config.query];
+		for (const query of queries) {
+			var _req$query;
+			const value = toValidTraceId((_req$query = req.query) === null || _req$query === void 0 ? void 0 : _req$query[query]);
+			if (value) return value;
+		}
+	}
+	if (config.body) {
+		const bodyFields = Array.isArray(config.body) ? config.body : [config.body];
+		for (const field of bodyFields) {
+			var _req$body;
+			const value = toValidTraceId((_req$body = req.body) === null || _req$body === void 0 ? void 0 : _req$body[field]);
+			if (value) return value;
+		}
+	}
+	if (config.params) {
+		const paramFields = Array.isArray(config.params) ? config.params : [config.params];
+		for (const param of paramFields) {
+			var _req$params;
+			const value = toValidTraceId((_req$params = req.params) === null || _req$params === void 0 ? void 0 : _req$params[param]);
+			if (value) return value;
+		}
+	}
+}
+/**
+* Default headers checked for incoming trace ID propagation, in priority order:
+*   traceparent (W3C/OTel) → x-trace-id → x-request-id → x-correlation-id → trace-id
+*/
+const DEFAULT_TRACE_HEADERS = [
+	"traceparent",
+	"x-trace-id",
+	"x-request-id",
+	"x-correlation-id",
+	"trace-id"
+];
+/**
+* Create trace ID middleware for Express/NestJS
+*/
+function createTraceMiddleware(config) {
+	const defaultExtractor = {
+		header: DEFAULT_TRACE_HEADERS,
+		query: ["traceId", "trace_id"]
+	};
+	const resolvedConfig = {
+		...config,
+		extractor: (config === null || config === void 0 ? void 0 : config.extractor) ? {
+			...defaultExtractor,
+			...config.extractor
+		} : defaultExtractor
+	};
+	_setActiveContextKey(resolvedConfig.contextKey ?? TRACE_CONTEXT_KEY);
+	return (req, res, next) => {
+		let traceId;
+		if (resolvedConfig.extractor) traceId = extractTraceId(req, resolvedConfig.extractor);
+		if (!traceId) traceId = resolvedConfig.generator ? resolvedConfig.generator() : generateTraceId();
+		req.traceId = traceId;
+		res.setHeader("X-Trace-Id", traceId);
+		runWithTraceId(traceId, () => next());
+	};
+}
+
+//#endregion
+//#region src/core/logitron-logger.ts
+const _fastStringifyEntry = (0, fast_json_stringify.default)({
+	type: "object",
+	properties: {
+		timestamp: { type: "string" },
+		level: { type: "string" },
+		appName: { type: "string" },
+		environment: { type: "string" },
+		message: { type: "string" },
+		context: { type: "string" },
+		traceId: { type: "string" },
+		payload: {
+			type: "object",
+			additionalProperties: true
+		}
+	},
+	additionalProperties: true
+});
+function namespacePatternToRegex(pattern) {
+	const escaped = pattern.split(".").map((s) => s === "*" ? "[^.]+" : s.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&")).join("\\.");
+	return /* @__PURE__ */ new RegExp(`^${escaped}$`);
+}
+/** Max compiled patterns to keep in memory. Oldest entry is evicted when full. */
+const _NS_CACHE_MAX = 1e3;
+const _nsPatternCache = /* @__PURE__ */ new Map();
+/**
+* One-shot warning so operators notice runaway pattern growth.
+* If the cache is being thrashed (>N evictions) the namespace level config is
+* almost certainly wrong — likely dynamic/unique patterns being registered.
+*/
+let _nsCacheEvictionWarned = false;
+let _nsCacheEvictionCount = 0;
+function matchesNamespacePattern(ns, pattern) {
+	let re = _nsPatternCache.get(pattern);
+	if (!re) {
+		re = namespacePatternToRegex(pattern);
+		if (_nsPatternCache.size >= _NS_CACHE_MAX) {
+			const firstKey = _nsPatternCache.keys().next().value;
+			if (firstKey !== void 0) _nsPatternCache.delete(firstKey);
+			_nsCacheEvictionCount++;
+			if (!_nsCacheEvictionWarned) {
+				_nsCacheEvictionWarned = true;
+				process.stderr.write(`[logixia] namespace pattern cache hit ${_NS_CACHE_MAX} entries — evicting. This usually means dynamic/unique patterns are being registered at runtime; review your levelOptions.namespaces configuration.\n`);
+			}
+		}
+		_nsPatternCache.set(pattern, re);
+	}
+	return re.test(ns);
+}
+function resolveInitialLevel(config) {
+	var _config$levelOptions;
+	const envLevel = process.env["LOGIXIA_LEVEL"];
+	if (envLevel) return envLevel;
+	if ((_config$levelOptions = config.levelOptions) === null || _config$levelOptions === void 0 ? void 0 : _config$levelOptions.level) return config.levelOptions.level;
+	const nodeEnv = process.env["NODE_ENV"];
+	if (nodeEnv === "development") return LogLevel.DEBUG;
+	if (nodeEnv === "test") return LogLevel.WARN;
+	if (nodeEnv === "production") return LogLevel.INFO;
+	if (process.env["CI"]) return LogLevel.INFO;
+	return LogLevel.INFO;
+}
+var LogixiaLogger = class LogixiaLogger {
+	constructor(config, context) {
+		this.timers = /* @__PURE__ */ new Map();
+		this.contextData = {};
+		this.fieldState = /* @__PURE__ */ new Map();
+		this.fallbackTraceId = TraceContext.instance.generate();
+		this._levelValues = /* @__PURE__ */ new Map();
+		this._minLevelValue = 2;
+		this._colorMap = /* @__PURE__ */ new Map();
+		this._fieldCache = /* @__PURE__ */ new Map();
+		this._hasContextData = false;
+		this._formattedLevels = /* @__PURE__ */ new Map();
+		this._formattedAppName = "";
+		this._hasRedact = false;
+		this._pluginRegistry = new PluginRegistry();
+		this.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"
+				}
+			},
+			...config
+		};
+		const resolvedLevel = resolveInitialLevel(this.config);
+		this.config.levelOptions = {
+			...this.config.levelOptions,
+			level: resolvedLevel
+		};
+		if (!this.config.fields) this.config.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]"
+		};
+		this.context = context ?? "";
+		if (this.config.transports) {
+			var _this$config$levelOpt;
+			const transportsWithColors = { ...this.config.transports };
+			const userColors = (_this$config$levelOpt = this.config.levelOptions) === null || _this$config$levelOpt === void 0 ? void 0 : _this$config$levelOpt.colors;
+			if (userColors && transportsWithColors.console) transportsWithColors.console = {
+				...typeof transportsWithColors.console === "object" ? transportsWithColors.console : {},
+				levelColors: userColors
+			};
+			this.transportManager = new require_transport_manager.TransportManager(transportsWithColors);
+		}
+		if (this.config.sampling) this._sampler = new Sampler(this.config.sampling, (stats) => {
+			process.stdout.write(JSON.stringify({
+				level: "info",
+				message: "[logixia/sampling] stats",
+				...stats
+			}) + "\n");
+		});
+		this.setupGracefulShutdown();
+		this.createCustomLevelMethods();
+		for (const p of globalPluginRegistry._plugins) this._pluginRegistry.register(p);
+		this._buildPerfCaches();
+	}
+	setupGracefulShutdown() {
+		const shutdownCfg = this.config.gracefulShutdown;
+		if (!shutdownCfg) return;
+		const normalized = shutdownCfg === true ? { enabled: true } : shutdownCfg;
+		if (!normalized.enabled) return;
+		registerForShutdown(this);
+		flushOnExit({
+			timeout: normalized.timeout ?? 5e3,
+			signals: normalized.signals ?? ["SIGTERM", "SIGINT"]
+		});
+	}
+	createCustomLevelMethods() {
+		var _this$config$levelOpt2;
+		if ((_this$config$levelOpt2 = this.config.levelOptions) === null || _this$config$levelOpt2 === void 0 ? void 0 : _this$config$levelOpt2.levels) {
+			for (const levelName of Object.keys(this.config.levelOptions.levels)) if (!this[levelName.toLowerCase()]) this[levelName.toLowerCase()] = async (message, data) => {
+				await this.logLevel(levelName.toLowerCase(), message, data);
+			};
+		}
+	}
+	/**
+	* Rebuild all hot-path caches after any config mutation or level change.
+	* Keeps the actual log() call free of allocations in the common case.
+	*/
+	_buildPerfCaches() {
+		var _this$config$levelOpt3, _this$config$format, _this$config$redact$p, _this$config$redact$p2;
+		const customLevelEntries = Object.entries(((_this$config$levelOpt3 = this.config.levelOptions) === null || _this$config$levelOpt3 === void 0 ? void 0 : _this$config$levelOpt3.levels) ?? {});
+		this._levelValues = new Map([
+			[LogLevel.ERROR, 0],
+			[LogLevel.WARN, 1],
+			[LogLevel.INFO, 2],
+			[LogLevel.DEBUG, 3],
+			[LogLevel.TRACE, 4],
+			[LogLevel.VERBOSE, 5],
+			...customLevelEntries
+		]);
+		const effectiveLevel = this.resolveEffectiveLevel();
+		this._minLevelValue = this._levelValues.get(effectiveLevel) ?? 2;
+		this._colorMap = new Map([
+			["black", "\x1B[30m"],
+			["red", "\x1B[31m"],
+			["green", "\x1B[32m"],
+			["yellow", "\x1B[33m"],
+			["blue", "\x1B[34m"],
+			["magenta", "\x1B[35m"],
+			["cyan", "\x1B[36m"],
+			["white", "\x1B[37m"],
+			["gray", "\x1B[90m"],
+			["grey", "\x1B[90m"],
+			["brightred", "\x1B[91m"],
+			["brightgreen", "\x1B[92m"],
+			["brightyellow", "\x1B[93m"],
+			["brightblue", "\x1B[94m"],
+			["brightmagenta", "\x1B[95m"],
+			["brightcyan", "\x1B[96m"],
+			["brightwhite", "\x1B[97m"],
+			["reset", "\x1B[0m"]
+		]);
+		for (const f of [
+			"timestamp",
+			"level",
+			"appName",
+			"traceId",
+			"context",
+			"message",
+			"payload"
+		]) {
+			var _this$config$fields;
+			if (this.fieldState.has(f)) this._fieldCache.set(f, this.fieldState.get(f));
+			else if (((_this$config$fields = this.config.fields) === null || _this$config$fields === void 0 ? void 0 : _this$config$fields[f]) !== void 0) this._fieldCache.set(f, this.config.fields[f] !== false);
+			else this._fieldCache.set(f, true);
+		}
+		const colorize = ((_this$config$format = this.config.format) === null || _this$config$format === void 0 ? void 0 : _this$config$format.colorize) ?? true;
+		this._formattedLevels = /* @__PURE__ */ new Map();
+		const _AUTO_PALETTE = [
+			"magenta",
+			"cyan",
+			"yellow",
+			"green",
+			"blue"
+		];
+		const _BUILTIN_LEVELS = new Set([
+			"error",
+			"warn",
+			"info",
+			"debug",
+			"trace",
+			"verbose"
+		]);
+		let _paletteIdx = 0;
+		for (const [lvl] of this._levelValues) {
+			const upper = lvl.toUpperCase();
+			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++;
+				}
+				const code = this._colorMap.get(colorName.toLowerCase()) ?? this._colorMap.get("white");
+				const reset = this._colorMap.get("reset");
+				this._formattedLevels.set(lvl, `[${code}${upper}${reset}] `);
+			} else this._formattedLevels.set(lvl, `[${upper}] `);
+		}
+		const appNameRaw = `[${this.config.appName ?? "App"}]`;
+		if (this._fieldCache.get("appName") !== false) this._formattedAppName = colorize ? `${this._colorMap.get("gray")}${appNameRaw}${this._colorMap.get("reset")} ` : `${appNameRaw} `;
+		else this._formattedAppName = "";
+		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));
+	}
+	async error(messageOrError, data) {
+		if (isError(messageOrError)) await this.log("error", messageOrError.message, {
+			...data,
+			error: serializeError(messageOrError)
+		});
+		else await this.log("error", messageOrError, data);
+	}
+	async warn(message, data) {
+		await this.log("warn", message, data);
+	}
+	async info(message, data) {
+		await this.log("info", message, data);
+	}
+	async debug(message, data) {
+		await this.log("debug", message, data);
+	}
+	async trace(message, data) {
+		await this.log("trace", message, data);
+	}
+	async verbose(message, data) {
+		await this.log("verbose", message, data);
+	}
+	async logLevel(level, message, data) {
+		await this.log(level, message, data);
+	}
+	time(label) {
+		this.timers.set(label, {
+			label,
+			startTime: Date.now()
+		});
+	}
+	async timeEnd(label) {
+		const timer = this.timers.get(label);
+		if (!timer) {
+			await this.warn(`Timer '${label}' does not exist`);
+			return;
+		}
+		const endTime = Date.now();
+		const duration = endTime - timer.startTime;
+		timer.endTime = endTime;
+		timer.duration = duration;
+		await this.info(`Timer '${label}' finished`, {
+			duration: `${duration}ms`,
+			startTime: new Date(timer.startTime).toISOString(),
+			endTime: new Date(endTime).toISOString()
+		});
+		this.timers.delete(label);
+		return duration;
+	}
+	async timeAsync(label, fn) {
+		this.time(label);
+		try {
+			const result = await fn();
+			await this.timeEnd(label);
+			return result;
+		} catch (error) {
+			await this.timeEnd(label);
+			throw error;
+		}
+	}
+	setLevel(level) {
+		this.config.levelOptions = this.config.levelOptions ?? {};
+		this.config.levelOptions.level = level;
+		this._minLevelValue = this._levelValues.get(level) ?? this._minLevelValue;
+		this._buildPerfCaches();
+	}
+	getLevel() {
+		var _this$config$levelOpt5;
+		return ((_this$config$levelOpt5 = this.config.levelOptions) === null || _this$config$levelOpt5 === void 0 ? void 0 : _this$config$levelOpt5.level) ?? LogLevel.INFO;
+	}
+	setContext(context) {
+		this.context = context;
+	}
+	getContext() {
+		return this.context;
+	}
+	enableField(fieldName) {
+		this.fieldState.set(fieldName, true);
+		this._fieldCache.set(fieldName, true);
+		if (fieldName === "level" || fieldName === "appName") this._buildPerfCaches();
+		require_transport_manager.internalLog(`Field '${fieldName}' enabled`);
+	}
+	disableField(fieldName) {
+		this.fieldState.set(fieldName, false);
+		this._fieldCache.set(fieldName, false);
+		if (fieldName === "level" || fieldName === "appName") this._buildPerfCaches();
+		require_transport_manager.internalLog(`Field '${fieldName}' disabled`);
+	}
+	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;
+	}
+	getFieldState() {
+		return Object.fromEntries([
+			"timestamp",
+			"level",
+			"appName",
+			"service",
+			"traceId",
+			"message",
+			"payload",
+			"timeTaken",
+			"context",
+			"userId",
+			"sessionId",
+			"environment"
+		].map((f) => [f, this.isFieldEnabled(f)]));
+	}
+	resetFieldState() {
+		this.fieldState.clear();
+		require_transport_manager.internalLog("Field state reset to configuration defaults");
+	}
+	enableTransportLevelPrompting() {
+		if (this.transportManager) this.transportManager.enableLevelPrompting();
+		else require_transport_manager.internalWarn("Transport manager not initialized");
+	}
+	disableTransportLevelPrompting() {
+		if (this.transportManager) this.transportManager.disableLevelPrompting();
+		else require_transport_manager.internalWarn("Transport manager not initialized");
+	}
+	setTransportLevels(transportId, levels) {
+		if (this.transportManager) this.transportManager.setTransportLevels(transportId, levels);
+		else require_transport_manager.internalWarn("Transport manager not initialized");
+	}
+	getTransportLevels(transportId) {
+		if (this.transportManager) return this.transportManager.getTransportLevels(transportId);
+		require_transport_manager.internalWarn("Transport manager not initialized");
+	}
+	clearTransportLevelPreferences() {
+		if (this.transportManager) this.transportManager.clearTransportLevelPreferences();
+		else require_transport_manager.internalWarn("Transport manager not initialized");
+	}
+	getAvailableTransports() {
+		var _this$transportManage;
+		return ((_this$transportManage = this.transportManager) === null || _this$transportManage === void 0 ? void 0 : _this$transportManage.getTransports()) ?? [];
+	}
+	child(context, data) {
+		const childLogger = new LogixiaLogger(this.config, context);
+		if (data) childLogger.contextData = {
+			...this.contextData,
+			...data
+		};
+		return childLogger;
+	}
+	/**
+	* Register a plugin on this logger instance.
+	*
+	* @example
+	* ```ts
+	* logger.use({
+	*   name: 'audit',
+	*   onLog(entry) { auditQueue.push(entry); return entry; },
+	* });
+	* ```
+	*/
+	use(plugin) {
+		this._pluginRegistry.register(plugin);
+		return this;
+	}
+	/**
+	* Remove a previously registered plugin by name.
+	* No-op if the plugin is not registered on this instance.
+	*/
+	unuse(pluginName) {
+		this._pluginRegistry.unregister(pluginName);
+		return this;
+	}
+	async flush() {
+		if (this.transportManager) await this.transportManager.flush();
+	}
+	async healthCheck() {
+		if (!this.transportManager) return {
+			healthy: false,
+			details: { error: "TransportManager not initialized" }
+		};
+		return this.transportManager.healthCheck();
+	}
+	async close() {
+		var _this$_sampler;
+		for (const [label, timer] of this.timers) await this.warn(`Timer '${label}' was not ended properly`, {
+			startTime: new Date(timer.startTime).toISOString(),
+			duration: `${Date.now() - timer.startTime}ms (incomplete)`
+		});
+		this.timers.clear();
+		if (this.transportManager) {
+			await this.transportManager.flush();
+			await this.transportManager.close();
+		}
+		(_this$_sampler = this._sampler) === null || _this$_sampler === void 0 || _this$_sampler.destroy();
+		await this._pluginRegistry.runOnShutdown();
+		deregisterFromShutdown(this);
+	}
+	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() ?? this.fallbackTraceId : void 0;
+			if (!this._sampler.shouldEmit(level, traceId$1)) return;
+		}
+		const alsContext = LogixiaContext.get();
+		const otelFields = _getOtelPayloadIfEnabled();
+		const hasOtel = Object.keys(otelFields).length > 0;
+		let mergedData;
+		if (alsContext && Object.keys(alsContext).length > 0) mergedData = {
+			...alsContext,
+			...hasOtel ? otelFields : {},
+			...data
+		};
+		else if (hasOtel) mergedData = {
+			...otelFields,
+			...data
+		};
+		else mergedData = data;
+		const rawPayload = this._hasContextData ? {
+			...this.contextData,
+			...mergedData
+		} : mergedData;
+		let payload;
+		if (rawPayload !== void 0 && rawPayload !== null) payload = this._hasRedact ? applyRedaction(rawPayload, this.config.redact) ?? rawPayload : rawPayload;
+		const traceId = this.config.traceId ? TraceContext.instance.getCurrentTraceId() ?? this.fallbackTraceId : void 0;
+		const entry = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			level,
+			appName: this.config.appName ?? "App",
+			environment: this.config.environment ?? "development",
+			message
+		};
+		if (this.context) entry.context = this.context;
+		if (payload !== void 0) entry.payload = payload;
+		if (traceId !== void 0) entry.traceId = traceId;
+		let finalEntry = entry;
+		if (this._pluginRegistry.size > 0) {
+			finalEntry = await this._pluginRegistry.runOnLog(entry);
+			if (finalEntry === null) return;
+		}
+		const formattedLog = this.formatLog(finalEntry);
+		await this.output(formattedLog, level, finalEntry);
+	}
+	/**
+	* Hot-path level check: a single Map lookup + integer compare.
+	* The level map and threshold are pre-built in _buildPerfCaches().
+	*/
+	shouldLog(level) {
+		const v = this._levelValues.get(level);
+		return v !== void 0 && v <= this._minLevelValue;
+	}
+	/**
+	* Feature 3: Resolve the effective log level for this logger instance.
+	*
+	* Priority:
+	*  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() {
+		const ns = this.context;
+		if (ns) {
+			const nsKey = ns.split(".")[0].toUpperCase();
+			const envNsLevel = process.env[`LOGIXIA_LEVEL_${nsKey}`];
+			if (envNsLevel) return envNsLevel;
+			const namespaceLevels = this.config.namespaceLevels;
+			if (namespaceLevels) {
+				const sortedPatterns = Object.keys(namespaceLevels).sort((a, b) => b.length - a.length);
+				for (const pattern of sortedPatterns) if (matchesNamespacePattern(ns, pattern)) return namespaceLevels[pattern];
+			}
+		}
+		const globalEnv = process.env["LOGIXIA_LEVEL"];
+		if (globalEnv) return globalEnv;
+		return this.getLevel();
+	}
+	formatLog(entry) {
+		var _this$config$format2, _this$config$format3, _this$config$format4;
+		if ((_this$config$format2 = this.config.format) === null || _this$config$format2 === void 0 ? void 0 : _this$config$format2.json) return _fastStringifyEntry(entry);
+		let formatted = "";
+		const doColorize = ((_this$config$format3 = this.config.format) === null || _this$config$format3 === void 0 ? void 0 : _this$config$format3.colorize) ?? true;
+		const gray = doColorize ? this._colorMap.get("gray") : "";
+		const cyan = doColorize ? this._colorMap.get("cyan") : "";
+		const yellow = doColorize ? this._colorMap.get("yellow") : "";
+		const reset = doColorize ? this._colorMap.get("reset") : "";
+		if (((_this$config$format4 = this.config.format) === null || _this$config$format4 === void 0 ? void 0 : _this$config$format4.timestamp) !== false && this._fieldCache.get("timestamp") !== false) formatted += `${gray}[${entry.timestamp}]${reset} `;
+		if (this._fieldCache.get("level") !== false) formatted += this._formattedLevels.get(entry.level) ?? `[${entry.level.toUpperCase()}] `;
+		formatted += this._formattedAppName;
+		if (entry.traceId && this._fieldCache.get("traceId") !== false) formatted += `${cyan}[${entry.traceId}]${reset} `;
+		if (entry.context && this._fieldCache.get("context") !== false) formatted += `${yellow}[${entry.context}]${reset} `;
+		if (this._fieldCache.get("message") !== false) formatted += entry.message;
+		if (entry.payload !== void 0 && this._fieldCache.get("payload") !== false) formatted += ` ${JSON.stringify(entry.payload)}`;
+		return formatted;
+	}
+	colorize(text, color) {
+		var _this$config$format5;
+		if (!((_this$config$format5 = this.config.format) === null || _this$config$format5 === void 0 ? void 0 : _this$config$format5.colorize)) return text;
+		return `${this._colorMap.get(color.toLowerCase()) ?? this._colorMap.get("white")}${text}${this._colorMap.get("reset")}`;
+	}
+	async output(message, level, entry) {
+		if (this.transportManager) try {
+			await this.transportManager.write(entry);
+			return;
+		} catch (error) {
+			require_transport_manager.internalError("Transport write failed", error);
+		}
+		(level === LogLevel.ERROR ? process.stderr : process.stdout).write(message + "\n");
+	}
+};
+function createLogger(config, context) {
+	var _config$levelOptions2;
+	const logger = new LogixiaLogger(config, context);
+	const mutableLogger = logger;
+	if ((_config$levelOptions2 = config.levelOptions) === null || _config$levelOptions2 === void 0 ? void 0 : _config$levelOptions2.levels) {
+		for (const levelName of Object.keys(config.levelOptions.levels)) if (!mutableLogger[levelName]) mutableLogger[levelName] = async (message, data) => {
+			await logger.logLevel(levelName, message, data);
+		};
+	}
+	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_transport_manager.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_transport_manager.internalError("LogixiaLoggerService.error failed", err));
+	}
+	warn(message, dataOrContext) {
+		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.warn(this.formatMessage(message), dataOrContext);
+		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
+		this.logger.warn(this.formatMessage(message)).catch((err) => require_transport_manager.internalError("LogixiaLoggerService.warn failed", err));
+	}
+	debug(message, dataOrContext) {
+		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.debug(this.formatMessage(message), dataOrContext);
+		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
+		this.logger.debug(this.formatMessage(message)).catch((err) => require_transport_manager.internalError("LogixiaLoggerService.debug failed", err));
+	}
+	verbose(message, dataOrContext) {
+		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.trace(this.formatMessage(message), dataOrContext);
+		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
+		this.logger.trace(this.formatMessage(message)).catch((err) => require_transport_manager.internalError("LogixiaLoggerService.verbose failed", err));
+	}
+	/**
+	* 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) {
+		this.context = context;
+		this.logger.setContext(context);
+	}
+	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 (context && context !== this.context) this.setContext(context);
+	}
+	formatMessage(message) {
+		if (typeof message === "string") return message;
+		if (typeof message === "object") return JSON.stringify(message);
+		return String(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 = 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 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) => {
+			this.ctx.run(traceId, () => {
+				next.handle().subscribe({
+					next: (value) => subscriber.next(value),
+					error: (err) => subscriber.error(err),
+					complete: () => subscriber.complete()
+				});
+			}, kafkaContext);
+		});
+	}
+};
+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;
+}
+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;
+		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 process.stderr.write("[logixia] TraceIdConfig.generator returned a non-string/empty value — using built-in generator.\n");
+		}
+		if (!traceId) traceId = this.ctx.generate();
+		req.traceId = traceId;
+		const header = resolveResponseHeader(this.config);
+		if (header) res.setHeader(header, traceId);
+		this.ctx.run(traceId, () => next(), {
+			method: req.method,
+			url: req.url,
+			userAgent: req.get("User-Agent"),
+			ip: req.ip || 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 = 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 rxjs.Observable((observer) => {
+			this.ctx.run(traceId, () => {
+				next.handle().subscribe({
+					next: (value) => observer.next(value),
+					error: (err) => observer.error(err),
+					complete: () => observer.complete()
+				});
+			}, wsContextData);
+		});
+	}
+};
+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_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) {
+			process.stderr.write("[logixia] LogixiaLoggerModule.forRoot() was called more than once — ignoring the second init. If this is intentional (e.g. in tests), call LogixiaLoggerModule._resetGlobalLogger() first.\n");
+			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: "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: ["TRACE_CONFIG"]
+				},
+				{
+					provide: WebSocketTraceInterceptor,
+					useFactory: (traceConfig$1) => new WebSocketTraceInterceptor(traceConfig$1),
+					inject: ["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: "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: ["TRACE_CONFIG"]
+				},
+				{
+					provide: WebSocketTraceInterceptor,
+					useFactory: (traceConfig) => new WebSocketTraceInterceptor(traceConfig),
+					inject: ["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
+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, 'DEFAULT_TRACE_HEADERS', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_TRACE_HEADERS;
+  }
+});
+Object.defineProperty(exports, 'KafkaTraceInterceptor', {
+  enumerable: true,
+  get: function () {
+    return KafkaTraceInterceptor;
+  }
+});
+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, 'LogLevel', {
+  enumerable: true,
+  get: function () {
+    return LogLevel;
+  }
+});
+Object.defineProperty(exports, 'LogixiaContext', {
+  enumerable: true,
+  get: function () {
+    return LogixiaContext;
+  }
+});
+Object.defineProperty(exports, 'LogixiaLogger', {
+  enumerable: true,
+  get: function () {
+    return LogixiaLogger;
+  }
+});
+Object.defineProperty(exports, 'LogixiaLoggerModule', {
+  enumerable: true,
+  get: function () {
+    return LogixiaLoggerModule;
+  }
+});
+Object.defineProperty(exports, 'LogixiaLoggerService', {
+  enumerable: true,
+  get: function () {
+    return LogixiaLoggerService;
+  }
+});
+Object.defineProperty(exports, 'PluginRegistry', {
+  enumerable: true,
+  get: function () {
+    return PluginRegistry;
+  }
+});
+Object.defineProperty(exports, 'TRACE_CONTEXT_KEY', {
+  enumerable: true,
+  get: function () {
+    return TRACE_CONTEXT_KEY;
+  }
+});
+Object.defineProperty(exports, 'TraceContext', {
+  enumerable: true,
+  get: function () {
+    return TraceContext;
+  }
+});
+Object.defineProperty(exports, 'TraceMiddleware', {
+  enumerable: true,
+  get: function () {
+    return TraceMiddleware;
+  }
+});
+Object.defineProperty(exports, 'WebSocketTraceInterceptor', {
+  enumerable: true,
+  get: function () {
+    return WebSocketTraceInterceptor;
+  }
+});
+Object.defineProperty(exports, '__decorate', {
+  enumerable: true,
+  get: function () {
+    return __decorate;
+  }
+});
+Object.defineProperty(exports, '__decorateMetadata', {
+  enumerable: true,
+  get: function () {
+    return __decorateMetadata;
+  }
+});
+Object.defineProperty(exports, '__decorateParam', {
+  enumerable: true,
+  get: function () {
+    return __decorateParam;
+  }
+});
+Object.defineProperty(exports, '_setActiveContextKey', {
+  enumerable: true,
+  get: function () {
+    return _setActiveContextKey;
+  }
+});
+Object.defineProperty(exports, 'applyRedaction', {
+  enumerable: true,
+  get: function () {
+    return applyRedaction;
+  }
+});
+Object.defineProperty(exports, 'createExpressContextMiddleware', {
+  enumerable: true,
+  get: function () {
+    return createExpressContextMiddleware;
+  }
+});
+Object.defineProperty(exports, 'createFastifyContextHook', {
+  enumerable: true,
+  get: function () {
+    return createFastifyContextHook;
+  }
+});
+Object.defineProperty(exports, 'createLogger', {
+  enumerable: true,
+  get: function () {
+    return createLogger;
+  }
+});
+Object.defineProperty(exports, 'createTraceMiddleware', {
+  enumerable: true,
+  get: function () {
+    return createTraceMiddleware;
+  }
+});
+Object.defineProperty(exports, 'deregisterFromShutdown', {
+  enumerable: true,
+  get: function () {
+    return deregisterFromShutdown;
+  }
+});
+Object.defineProperty(exports, 'disableOtelBridge', {
+  enumerable: true,
+  get: function () {
+    return disableOtelBridge;
+  }
+});
+Object.defineProperty(exports, 'extractTraceId', {
+  enumerable: true,
+  get: function () {
+    return extractTraceId;
+  }
+});
+Object.defineProperty(exports, 'flushOnExit', {
+  enumerable: true,
+  get: function () {
+    return flushOnExit;
+  }
+});
+Object.defineProperty(exports, 'getActiveOtelContext', {
+  enumerable: true,
+  get: function () {
+    return getActiveOtelContext;
+  }
+});
+Object.defineProperty(exports, 'getCurrentTraceId', {
+  enumerable: true,
+  get: function () {
+    return getCurrentTraceId;
+  }
+});
+Object.defineProperty(exports, 'getOtelMetaFields', {
+  enumerable: true,
+  get: function () {
+    return getOtelMetaFields;
+  }
+});
+Object.defineProperty(exports, 'getTraceContextKey', {
+  enumerable: true,
+  get: function () {
+    return getTraceContextKey;
+  }
+});
+Object.defineProperty(exports, 'globalPluginRegistry', {
+  enumerable: true,
+  get: function () {
+    return globalPluginRegistry;
+  }
+});
+Object.defineProperty(exports, 'initOtelBridge', {
+  enumerable: true,
+  get: function () {
+    return initOtelBridge;
+  }
+});
+Object.defineProperty(exports, 'isError', {
+  enumerable: true,
+  get: function () {
+    return isError;
+  }
+});
+Object.defineProperty(exports, 'normalizeError', {
+  enumerable: true,
+  get: function () {
+    return normalizeError;
+  }
+});
+Object.defineProperty(exports, 'redactObject', {
+  enumerable: true,
+  get: function () {
+    return redactObject;
+  }
+});
+Object.defineProperty(exports, 'registerForShutdown', {
+  enumerable: true,
+  get: function () {
+    return registerForShutdown;
+  }
+});
+Object.defineProperty(exports, 'resetShutdownHandlers', {
+  enumerable: true,
+  get: function () {
+    return resetShutdownHandlers;
+  }
+});
+Object.defineProperty(exports, 'resolveResponseHeader', {
+  enumerable: true,
+  get: function () {
+    return resolveResponseHeader;
+  }
+});
+Object.defineProperty(exports, 'runWithTraceId', {
+  enumerable: true,
+  get: function () {
+    return runWithTraceId;
+  }
+});
+Object.defineProperty(exports, 'serializeError', {
+  enumerable: true,
+  get: function () {
+    return serializeError;
+  }
+});
+Object.defineProperty(exports, 'setTraceId', {
+  enumerable: true,
+  get: function () {
+    return setTraceId;
+  }
+});
+Object.defineProperty(exports, 'traceStorage', {
+  enumerable: true,
+  get: function () {
+    return traceStorage;
+  }
+});
+Object.defineProperty(exports, 'usePlugin', {
+  enumerable: true,
+  get: function () {
+    return usePlugin;
+  }
+});
+//# sourceMappingURL=logitron-logger.module-CMDM61Iz.js.map