logixia 1.12.6 → 1.13.3

package/dist/{logitron-logger.module-BsDZR5BH.js → nestjs-extras-DnJ6vrIC.js}

@@ -1,17 +1,14 @@
 const require_chunk = require('./chunk-nOFOJqeH.js');
 const require_internal_log = require('./internal-log-BUJYMZbE.js');
 const require_safe_stringify = require('./safe-stringify-DWo3aZp_.js');
-const require_async_context = require('./async-context-CSHWoHMB.js');
-const require_coerce_utils = require('./coerce.utils-BN980Y9V.js');
-const require_transport_manager = require('./transport.manager-BivyUTtU.js');
+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);
-let node_async_hooks = require("node:async_hooks");
-node_async_hooks = require_chunk.__toESM(node_async_hooks);
 let fast_json_stringify = require("fast-json-stringify");
 fast_json_stringify = require_chunk.__toESM(fast_json_stringify);
-let crypto = require("crypto");
-crypto = require_chunk.__toESM(crypto);
 let __nestjs_common = require("@nestjs/common");
 __nestjs_common = require_chunk.__toESM(__nestjs_common);
 let rxjs = require("rxjs");
@@ -392,16 +389,29 @@ function disableOtelBridge() {
 //#endregion
 //#region src/utils/redact.utils.ts
 const DEFAULT_CENSOR = "[REDACTED]";
+/** Maximum nesting depth walked; deeper values are replaced with a marker. */
+const MAX_DEPTH = 32;
+/** Maximum number of objects/arrays visited per redaction pass. */
+const MAX_NODES = 1e4;
+/**
+* Strings longer than this are truncated before pattern scanning. The tail is
+* dropped rather than emitted unscanned, so oversized input can never carry an
+* unredacted secret past the patterns.
+*/
+const MAX_SCAN_LENGTH = 16384;
+const MAX_DEPTH_MARKER = "[MaxDepth]";
+const MAX_NODES_MARKER = "[MaxNodes]";
+const REDACTION_FAILED = "[RedactionFailed]";
 /**
 * 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,
+	/eyJ[A-Za-z0-9_-]{1,1024}\.[A-Za-z0-9_-]{1,16384}\.[A-Za-z0-9_-]{0,1024}/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
+	/secret[_-]?(?:access[_-]?)?key["'\s:=]{1,6}[A-Za-z0-9/+]{40}(?![A-Za-z0-9/+])/gi
 ];
 /**
 * Conservative field-name paths auto-redacted by name regardless of value.
@@ -422,14 +432,24 @@ const PII_CONSERVATIVE_PATHS = [
 	"**.privateKey",
 	"**.private_key",
 	"**.clientSecret",
-	"**.client_secret"
+	"**.client_secret",
+	"**.cookie",
+	"**.set-cookie",
+	"**.x-api-key",
+	"**.session",
+	"**.proxy-authorization",
+	"**.x-auth-token",
+	"**.x-access-token",
+	"**.aws_secret_access_key",
+	"**.awsSecretAccessKey",
+	"**.secretAccessKey"
 ];
 /**
 * 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[A-Za-z0-9._%+-]{1,64}@[A-Za-z0-9.-]{1,255}\.[A-Za-z]{2,24}\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,
@@ -526,32 +546,54 @@ function matchesPath(fullPath, pattern) {
 	}
 	return re.test(fullPath);
 }
+function isTokenChar(code) {
+	return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 46 || code === 95 || code === 126 || code === 43 || code === 47 || code === 61 || code === 45;
+}
 function applyPatterns(value, patterns, censor) {
 	let redacted = value;
+	let suffix = "";
+	if (redacted.length > MAX_SCAN_LENGTH) {
+		let end = MAX_SCAN_LENGTH;
+		while (end > 0 && isTokenChar(redacted.charCodeAt(end - 1))) end--;
+		suffix = `…[truncated ${value.length - end} unscanned chars]`;
+		redacted = redacted.slice(0, end);
+	}
 	for (const pattern of patterns) redacted = redacted.replace(pattern, censor);
-	return redacted;
+	return redacted + suffix;
 }
 const CIRCULAR = "[Circular]";
 function joinPath(parent, key) {
 	return parent ? `${parent}.${key}` : key;
 }
-function walkValue(value, state, fullPath, bare) {
+function walkValue(value, state, fullPath, bare, depth) {
 	const { paths = [], excludePaths = [], patterns = [], censor = DEFAULT_CENSOR } = state.config;
 	if (paths.some((p) => matchesPath(fullPath, p) || matchesPath(bare, p))) return censor;
+	if (typeof value === "object" && value !== null) {
+		if (depth >= MAX_DEPTH) return MAX_DEPTH_MARKER;
+		if (++state.nodes > MAX_NODES) return MAX_NODES_MARKER;
+	}
 	if (typeof value === "string") {
 		if (patterns.length === 0) return value;
 		if (excludePaths.some((p) => matchesPath(fullPath, p) || matchesPath(bare, p))) return value;
 		return applyPatterns(value, patterns, censor);
 	}
-	if (Array.isArray(value)) return walkContainer(value, state, fullPath, bare, walkArray);
-	if (isPlainObject(value)) return walkContainer(value, state, fullPath, bare, walkRecord);
+	if (Array.isArray(value)) return walkContainer(value, state, fullPath, bare, depth, walkArray);
+	if (value instanceof Error) return walkContainer(value, state, fullPath, bare, depth, walkError);
+	if (value instanceof URL) {
+		const url = new URL(value.href);
+		url.username = "";
+		url.password = "";
+		const redacted = walkValue(url.href, state, fullPath, bare, depth);
+		return redacted === value.href ? value : redacted;
+	}
+	if (isPlainObject(value)) return walkContainer(value, state, fullPath, bare, depth, typeof value.toJSON === "function" ? walkToJSON : walkRecord);
 	return value;
 }
-function walkContainer(value, state, fullPath, bare, walk) {
+function walkContainer(value, state, fullPath, bare, depth, walk) {
 	if (state.ancestors.has(value)) return CIRCULAR;
 	state.ancestors.add(value);
 	try {
-		return walk(value, state, fullPath, bare);
+		return walk(value, state, fullPath, bare, depth + 1);
 	} finally {
 		state.ancestors.delete(value);
 	}
@@ -560,26 +602,51 @@ function walkContainer(value, state, fullPath, bare, walk) {
 * Array elements are matched by their indexed path (`users.0.password`) and by
 * the index-free path (`users.password`) that earlier versions used.
 */
-function walkArray(arr, state, fullPath, bare) {
+function walkArray(arr, state, fullPath, bare, depth) {
 	let result;
 	for (const [i, item] of arr.entries()) {
-		const next = walkValue(item, state, joinPath(fullPath, String(i)), bare);
+		const next = walkValue(item, state, joinPath(fullPath, String(i)), bare, depth);
 		if (next !== item && !result) result = arr.slice(0, i);
 		if (result) result.push(next);
 	}
 	return result ?? arr;
 }
-function walkRecord(obj, state, fullPath, bare) {
+function walkRecord(obj, state, fullPath, bare, depth) {
 	let result;
 	const entries = Object.entries(obj);
 	for (const [index, [key, value]] of entries.entries()) {
 		const forbidden = key === "__proto__" || key === "constructor" || key === "prototype";
-		const next = forbidden ? void 0 : walkValue(value, state, joinPath(fullPath, key), joinPath(bare, key));
+		const next = forbidden ? void 0 : walkValue(value, state, joinPath(fullPath, key), joinPath(bare, key), depth);
 		if ((forbidden || next !== value) && !result) result = Object.fromEntries(entries.slice(0, index));
 		if (result && !forbidden) result[key] = next;
 	}
 	return result ?? obj;
 }
+/** Errors are serialized (own props + cause chain) and the result is walked. */
+function walkError(err, state, fullPath, bare, depth) {
+	let serialized;
+	try {
+		serialized = serializeError(err);
+	} catch {
+		return {
+			name: err.name,
+			message: REDACTION_FAILED
+		};
+	}
+	const result = walkRecord(serialized, state, fullPath, bare, depth);
+	return result === serialized ? { ...serialized } : result;
+}
+/** Objects with `toJSON()` are redacted via the value they would serialize to. */
+function walkToJSON(obj, state, fullPath, bare, depth) {
+	let json;
+	try {
+		json = obj.toJSON();
+	} catch {
+		return REDACTION_FAILED;
+	}
+	if (json === obj) return walkRecord(obj, state, fullPath, bare, depth);
+	return walkValue(json, state, fullPath, bare, depth);
+}
 /**
 * Redact an object according to the given RedactConfig and return a new
 * top-level object. Subtrees with nothing to redact are shared with the input,
@@ -588,8 +655,9 @@ function walkRecord(obj, state, fullPath, bare) {
 function redactObject(obj, config, _currentPath = "") {
 	const result = walkRecord(obj, {
 		config,
-		ancestors: new Set([obj])
-	}, _currentPath, _currentPath);
+		ancestors: new Set([obj]),
+		nodes: 0
+	}, _currentPath, _currentPath, 0);
 	return result === obj ? { ...obj } : result;
 }
 /**
@@ -600,12 +668,11 @@ function redactObject(obj, config, _currentPath = "") {
 * stays allocation-free for the common no-redact case.
 */
 function applyRedactionToString(value, config) {
-	if (!config) return value;
+	const text = typeof value === "string" ? value : require_coerce_utils.safeToString(value);
+	if (!config) return text;
 	const resolved = resolveConfig(config);
-	if (!resolved.patterns || resolved.patterns.length === 0) return value;
-	let redacted = value;
-	for (const pattern of resolved.patterns) redacted = redacted.replace(pattern, resolved.censor ?? DEFAULT_CENSOR);
-	return redacted;
+	if (!resolved.patterns || resolved.patterns.length === 0) return text;
+	return applyPatterns(text, resolved.patterns, resolved.censor ?? DEFAULT_CENSOR);
 }
 /**
 * Apply redaction to a log payload (top-level call convenience wrapper).
@@ -645,11 +712,21 @@ const ALWAYS_EMIT_LEVELS = new Set([
 	"warn",
 	"fatal"
 ]);
+const MAX_CACHED_TRACE_ID_LENGTH = 256;
+function isCacheableTraceId(id) {
+	if (typeof id !== "string" || id.length === 0 || id.length > MAX_CACHED_TRACE_ID_LENGTH) return false;
+	for (let i = 0; i < id.length; i++) {
+		const c = id.charCodeAt(i);
+		if (c < 32 || c >= 127 && c <= 159) return false;
+	}
+	return true;
+}
 var Sampler = class {
 	constructor(config, onStats) {
 		this.traceDecisions = /* @__PURE__ */ new Map();
 		this.maxTrackedTraces = 1e5;
 		this.traceTtlMs = 5 * 6e4;
+		this.traceMaxLifetimeMs = 60 * 6e4;
 		this._tokenBucket = 0;
 		this._lastRefillMs = Date.now();
 		this._adaptiveWindow = [];
@@ -769,13 +846,15 @@ var Sampler = class {
 	}
 	/**
 	* Return the cached decision for a trace, or make and cache a new one. Entries
-	* idle past the TTL are re-decided; the least recently used entry is evicted
-	* once the cap is reached.
+	* idle past the TTL, or older than the hard lifetime, are re-decided; the least
+	* recently used entry is evicted once the cap is reached. IDs that are empty,
+	* too long or contain control characters are sampled independently and never cached.
 	*/
 	_decideForTrace(traceId, level) {
+		if (!isCacheableTraceId(traceId)) return this._sampleByRate(level);
 		const now = Date.now();
 		const known = this.traceDecisions.get(traceId);
-		if (known && now - known.seenAt <= this.traceTtlMs) {
+		if (known && now - known.seenAt <= this.traceTtlMs && now - known.firstAt <= this.traceMaxLifetimeMs) {
 			this.traceDecisions.delete(traceId);
 			known.seenAt = now;
 			this.traceDecisions.set(traceId, known);
@@ -785,6 +864,7 @@ var Sampler = class {
 		this.traceDecisions.delete(traceId);
 		this.traceDecisions.set(traceId, {
 			emit,
+			firstAt: now,
 			seenAt: now
 		});
 		if (this.traceDecisions.size > this.maxTrackedTraces) {
@@ -948,318 +1028,6 @@ function resetShutdownHandlers() {
 	shutdownInProgress = 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;
-}
-/** W3C trace-context: `version-traceId(32hex)-spanId(16hex)-flags(2hex)`. */
-const W3C_TRACEPARENT_RE = /^[\da-f]{2}-([\da-f]{32})-[\da-f]{16}-[\da-f]{2}$/i;
-/**
-* Extract the 32-hex trace-id segment from a W3C `traceparent` header value.
-* Returns the parsed trace ID, or the original value unchanged when it is not a
-* well-formed traceparent (so non-W3C propagation still works).
-*/
-function parseTraceparent(value) {
-	const m = W3C_TRACEPARENT_RE.exec(value);
-	return m ? m[1] : value;
-}
-/** 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 lower = header.toLowerCase();
-			const value = toValidTraceId((_req$headers = req.headers) === null || _req$headers === void 0 ? void 0 : _req$headers[lower]);
-			if (value) return lower === "traceparent" ? parseTraceparent(value) : 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;
-		const resObj = res;
-		if (!resObj.headersSent) try {
-			if (typeof resObj.setHeader === "function") resObj.setHeader("X-Trace-Id", traceId);
-			else if (typeof resObj.header === "function") resObj.header("X-Trace-Id", traceId);
-		} catch {}
-		runWithTraceId(traceId, () => next());
-	};
-}
-
 //#endregion
 //#region src/core/logitron-logger.ts
 const _fastStringifyEntry = (0, fast_json_stringify.default)({
@@ -1348,7 +1116,7 @@ var LogixiaLogger = class LogixiaLogger {
 		this.timers = /* @__PURE__ */ new Map();
 		this.contextData = {};
 		this.fieldState = /* @__PURE__ */ new Map();
-		this.fallbackTraceId = TraceContext.instance.generate();
+		this.fallbackTraceId = require_trace_utils.TraceContext.instance.generate();
 		this._levelValues = /* @__PURE__ */ new Map();
 		this._minLevelValue = 2;
 		this._warnedInvalidLevels = /* @__PURE__ */ new Set();
@@ -1799,7 +1567,7 @@ var LogixiaLogger = class LogixiaLogger {
 		if (this.config.silent) return;
 		if (!this.shouldLog(level)) return;
 		if (this._sampler) {
-			const traceId$1 = this.config.traceId ? TraceContext.instance.getCurrentTraceId() : void 0;
+			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();
@@ -1822,9 +1590,21 @@ var LogixiaLogger = class LogixiaLogger {
 			...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 safeMessage = this._hasRedact ? applyRedactionToString(message, this.config.redact) : message;
+		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;
+		const traceId = this.config.traceId ? require_trace_utils.TraceContext.instance.getCurrentTraceId() ?? this.fallbackTraceId : void 0;
+		let safeMessage = message;
+		if (this._hasRedact) try {
+			safeMessage = applyRedactionToString(message, this.config.redact);
+		} catch (error) {
+			require_internal_log.internalError("Redaction failed", error);
+			safeMessage = REDACTION_FAILED;
+		}
 		const entry = {
 			timestamp: nowIso(),
 			level,
@@ -1895,9 +1675,9 @@ var LogixiaLogger = class LogixiaLogger {
 		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.traceId && this._fieldCache.get("traceId") !== false) formatted += `${cyan}[${require_transport_manager.stripControlChars(String(entry.traceId))}]${reset} `;
+		if (entry.context && this._fieldCache.get("context") !== false) formatted += `${yellow}[${require_transport_manager.stripControlChars(String(entry.context))}]${reset} `;
+		if (this._fieldCache.get("message") !== false) formatted += require_transport_manager.stripControlChars(require_coerce_utils.safeToString(entry.message));
 		if (entry.payload !== void 0 && this._fieldCache.get("payload") !== false) formatted += ` ${require_safe_stringify.stringifyForLog(entry.payload)}`;
 		return formatted;
 	}
@@ -2101,11 +1881,11 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService$1
 		return childService;
 	}
 	getCurrentTraceId() {
-		return TraceContext.instance.getCurrentTraceId();
+		return require_trace_utils.TraceContext.instance.getCurrentTraceId();
 	}
 	/** Returns the AsyncLocalStorage key currently used to store the trace ID. */
 	get traceContextKey() {
-		return getTraceContextKey();
+		return require_trace_utils.getTraceContextKey();
 	}
 	async close() {
 		return this.logger.close();
@@ -2156,7 +1936,7 @@ let KafkaTraceInterceptor = class KafkaTraceInterceptor$1 {
 	constructor(config, requireTraceId = false) {
 		this.config = config;
 		this.requireTraceId = requireTraceId;
-		this.ctx = TraceContext.instance;
+		this.ctx = require_trace_utils.TraceContext.instance;
 		this.config = {
 			enabled: true,
 			contextKey: "traceId",
@@ -2178,7 +1958,7 @@ let KafkaTraceInterceptor = class KafkaTraceInterceptor$1 {
 		const data = rpcContext.getData();
 		const rpcData = rpcContext.getContext();
 		let traceId;
-		if (this.config.extractor) traceId = extractTraceId({
+		if (this.config.extractor) traceId = require_trace_utils.extractTraceId({
 			body: data,
 			headers: (rpcData === null || rpcData === void 0 ? void 0 : rpcData.headers) ?? {},
 			query: {},
@@ -2258,9 +2038,9 @@ function writeTraceHeader(res, header, traceId) {
 let TraceMiddleware = class TraceMiddleware$1 {
 	constructor(config) {
 		this.config = config;
-		this.ctx = TraceContext.instance;
+		this.ctx = require_trace_utils.TraceContext.instance;
 		const defaultExtractor = {
-			header: DEFAULT_TRACE_HEADERS,
+			header: require_trace_utils.DEFAULT_TRACE_HEADERS,
 			query: ["traceId", "trace_id"]
 		};
 		this.config = {
@@ -2279,7 +2059,7 @@ let TraceMiddleware = class TraceMiddleware$1 {
 		var _this$config, _req$socket, _req$connection;
 		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next();
 		let traceId;
-		if (this.config.extractor) traceId = extractTraceId(req, this.config.extractor);
+		if (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;
@@ -2308,7 +2088,7 @@ TraceMiddleware = __decorate([
 let WebSocketTraceInterceptor = class WebSocketTraceInterceptor$1 {
 	constructor(config) {
 		this.config = config;
-		this.ctx = TraceContext.instance;
+		this.ctx = require_trace_utils.TraceContext.instance;
 		this.config = {
 			enabled: true,
 			contextKey: "traceId",
@@ -2333,7 +2113,7 @@ let WebSocketTraceInterceptor = class WebSocketTraceInterceptor$1 {
 		let traceId;
 		if (this.config.extractor) {
 			var _client$handshake, _client$handshake2;
-			traceId = extractTraceId({
+			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) || {},
@@ -2434,7 +2214,7 @@ let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
 		else if (_LogixiaLoggerModule.loggerConfig.traceId === true) resolvedTraceConfig = {
 			enabled: true,
 			contextKey: "traceId",
-			generator: () => TraceContext.instance.generate()
+			generator: () => require_trace_utils.TraceContext.instance.generate()
 		};
 		const middleware = new TraceMiddleware(resolvedTraceConfig);
 		const middlewareConfig = (req, res, next) => middleware.use(req, res, next);
@@ -2623,6 +2403,380 @@ let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
 };
 LogixiaLoggerModule = _LogixiaLoggerModule = __decorate([(0, __nestjs_common.Module)({})], LogixiaLoggerModule);
 
+//#endregion
+//#region src/exceptions/exception.ts
+var LogixiaException = class extends Error {
+	constructor(options) {
+		super(options.message, { cause: options.cause });
+		this.name = "LogixiaException";
+		this.errorCode = options.code;
+		this.errorType = options.type;
+		this.httpStatus = options.httpStatus;
+		this.param = options.param;
+		this.details = options.details;
+		this.docUrl = options.docUrl;
+		this.metadata = options.metadata;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/**
+* Returns `true` when `value` is a `LogixiaException` instance.
+*
+* Useful in exception filters or middleware that need to distinguish a
+* `LogixiaException` from a plain `Error` or a framework `HttpException`.
+*
+* @example
+* ```ts
+* if (isLogixiaException(err)) {
+*   console.log(err.errorCode, err.httpStatus);
+* }
+* ```
+*/
+function isLogixiaException(value) {
+	return value instanceof LogixiaException;
+}
+
+//#endregion
+//#region src/exceptions/builder.ts
+/**
+* Generates a trace ID via the shared {@link TraceContext} generator.
+*
+* Delegates to `TraceContext.instance.generate()` so any custom generator
+* configured on `TraceIdConfig.generator` is respected — avoids the silent
+* "builder has its own UUID source" divergence this module had previously.
+*
+* @example `'550e8400-e29b-41d4-a716-446655440000'`
+*/
+function generateTraceId() {
+	return require_trace_utils.TraceContext.instance.generate();
+}
+/** @deprecated Use `generateTraceId` instead. */
+const generateRequestId = generateTraceId;
+/**
+* Maps an HTTP status code to a human-friendly error type string.
+* Used as a fallback when the exception is a generic `HttpException`.
+*/
+function httpStatusToType(status) {
+	if (status === 400) return "api_error";
+	if (status === 401) return "authentication_error";
+	if (status === 402) return "payment_error";
+	if (status === 403) return "authorization_error";
+	if (status === 404) return "not_found_error";
+	if (status === 408) return "timeout_error";
+	if (status === 409) return "conflict_error";
+	if (status === 422) return "validation_error";
+	if (status === 429) return "rate_limit_error";
+	if (status >= 500) return "server_error";
+	if (status >= 400) return "api_error";
+	return "server_error";
+}
+/**
+* Duck-type check for NestJS `HttpException`.
+* Avoids a hard import on `@nestjs/common` so the builder is usable outside NestJS.
+*/
+function isHttpException(value) {
+	return typeof value === "object" && value !== null && typeof value["getStatus"] === "function" && typeof value["getResponse"] === "function";
+}
+/**
+* Builds the optional `debug` block from an error.
+* Returns `undefined` when there is nothing useful to include.
+*/
+function buildDebug(error, service, durationMs, expose) {
+	if (expose.debug !== true) return void 0;
+	const stack = error instanceof Error ? error.stack : void 0;
+	const causeRaw = error instanceof Error ? error.cause : void 0;
+	let cause;
+	if (expose.cause !== true) cause = void 0;
+	else if (causeRaw instanceof Error) cause = causeRaw.message;
+	else if (causeRaw !== void 0 && causeRaw !== null) cause = String(causeRaw);
+	if (!stack && !cause && !service && durationMs === void 0) return void 0;
+	return {
+		...stack !== void 0 ? { stack } : {},
+		...cause !== void 0 ? { cause } : {},
+		...service !== void 0 ? { service } : {},
+		...durationMs !== void 0 ? { duration_ms: durationMs } : {}
+	};
+}
+var ErrorResponseBuilder = class {
+	/**
+	* Build a `LogixiaErrorResponse` from any thrown value.
+	*
+	* @param params - See `BuildParams`.
+	* @returns The unified error response and the HTTP status code to send.
+	*
+	* @remarks
+	* `traceId` does not need to be supplied by the caller in most cases — the
+	* builder reads `TraceContext.instance.getCurrentTraceId()` internally and
+	* falls back to the explicit `traceId` argument only when AsyncLocalStorage
+	* is empty. If neither source yields a value, `meta.trace_id` is omitted.
+	*
+	* @example In a NestJS exception filter
+	* ```ts
+	* const { response, httpStatus } = ErrorResponseBuilder.build<AppCode, AppType>({
+	*   exception,
+	*   // Omit traceId — it will be picked up from ALS automatically.
+	*   path:    request.url,
+	*   service: process.env.SERVICE_NAME,
+	*   startTime: request.startTime,
+	* });
+	*
+	* if (process.env.NODE_ENV === 'production') delete response.debug;
+	* // Echo the resolved traceId back on whatever header your TraceIdConfig says —
+	* // do NOT hardcode 'X-Trace-Id', use `resolveResponseHeader(config)` instead.
+	* if (response.meta.trace_id) {
+	*   response.setHeader(resolveResponseHeader(config) ?? 'X-Trace-Id', response.meta.trace_id);
+	* }
+	* response.status(httpStatus).json(response);
+	* ```
+	*/
+	static build(params) {
+		const { exception, path, service, startTime, traceId: rawTraceId, exposeDebug, exposeCause } = params;
+		const expose = {
+			debug: exposeDebug,
+			cause: exposeCause
+		};
+		const traceId = require_trace_utils.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 errorBlock = {
+				type: exception.errorType,
+				code: exception.errorCode,
+				message: exception.message
+			};
+			if (exception.param !== void 0) errorBlock.param = exception.param;
+			if (exception.details !== void 0 && exception.details.length > 0) errorBlock.details = exception.details;
+			if (exception.docUrl !== void 0) errorBlock.doc_url = exception.docUrl;
+			return {
+				response: {
+					success: false,
+					error: errorBlock,
+					meta: {
+						...traceId !== void 0 ? { trace_id: traceId } : {},
+						timestamp,
+						path,
+						status: exception.httpStatus
+					},
+					...debug$1 !== void 0 ? { debug: debug$1 } : {}
+				},
+				httpStatus: exception.httpStatus
+			};
+		}
+		if (isHttpException(exception)) {
+			const status = exception.getStatus();
+			const exResponse = exception.getResponse();
+			let message;
+			if (typeof exResponse === "string") message = exResponse;
+			else if (typeof exResponse === "object" && exResponse !== null && "message" in exResponse) {
+				const raw = exResponse.message;
+				message = Array.isArray(raw) ? raw.join(", ") : String(raw);
+			} else message = exception.message;
+			const type = httpStatusToType(status);
+			const code = `HTTP_${status}`;
+			const debug$1 = buildDebug(exception, service, durationMs, expose);
+			return {
+				response: {
+					success: false,
+					error: {
+						type,
+						code,
+						message
+					},
+					meta: {
+						...traceId !== void 0 ? { trace_id: traceId } : {},
+						timestamp,
+						path,
+						status
+					},
+					...debug$1 !== void 0 ? { debug: debug$1 } : {}
+				},
+				httpStatus: status
+			};
+		}
+		const debug = buildDebug(exception instanceof Error ? exception : new Error(String(exception)), service, durationMs, expose);
+		return {
+			response: {
+				success: false,
+				error: {
+					type: "server_error",
+					code: "INTERNAL_SERVER_ERROR",
+					message: "An unexpected error occurred."
+				},
+				meta: {
+					...traceId !== void 0 ? { trace_id: traceId } : {},
+					timestamp,
+					path,
+					status: 500
+				},
+				...debug !== void 0 ? { debug } : {}
+			},
+			httpStatus: 500
+		};
+	}
+};
+
+//#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);
+	}
+};
+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,
@@ -2636,10 +2790,16 @@ Object.defineProperty(exports, 'DEFAULT_LOG_LEVELS', {
     return DEFAULT_LOG_LEVELS;
   }
 });
-Object.defineProperty(exports, 'DEFAULT_TRACE_HEADERS', {
+Object.defineProperty(exports, 'ErrorResponseBuilder', {
+  enumerable: true,
+  get: function () {
+    return ErrorResponseBuilder;
+  }
+});
+Object.defineProperty(exports, 'InjectLogger', {
   enumerable: true,
   get: function () {
-    return DEFAULT_TRACE_HEADERS;
+    return InjectLogger;
   }
 });
 Object.defineProperty(exports, 'KafkaTraceInterceptor', {
@@ -2648,6 +2808,12 @@ Object.defineProperty(exports, 'KafkaTraceInterceptor', {
     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 () {
@@ -2672,76 +2838,58 @@ Object.defineProperty(exports, 'LogLevel', {
     return LogLevel;
   }
 });
-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', {
+Object.defineProperty(exports, 'LogMethod', {
   enumerable: true,
   get: function () {
-    return PluginRegistry;
+    return LogMethod;
   }
 });
-Object.defineProperty(exports, 'TRACE_CONTEXT_KEY', {
+Object.defineProperty(exports, 'LogixiaException', {
   enumerable: true,
   get: function () {
-    return TRACE_CONTEXT_KEY;
+    return LogixiaException;
   }
 });
-Object.defineProperty(exports, 'TraceContext', {
+Object.defineProperty(exports, 'LogixiaExceptionFilter', {
   enumerable: true,
   get: function () {
-    return TraceContext;
+    return LogixiaExceptionFilter;
   }
 });
-Object.defineProperty(exports, 'TraceMiddleware', {
+Object.defineProperty(exports, 'LogixiaLogger', {
   enumerable: true,
   get: function () {
-    return TraceMiddleware;
+    return LogixiaLogger;
   }
 });
-Object.defineProperty(exports, 'WebSocketTraceInterceptor', {
+Object.defineProperty(exports, 'LogixiaLoggerModule', {
   enumerable: true,
   get: function () {
-    return WebSocketTraceInterceptor;
+    return LogixiaLoggerModule;
   }
 });
-Object.defineProperty(exports, '__decorate', {
+Object.defineProperty(exports, 'LogixiaLoggerService', {
   enumerable: true,
   get: function () {
-    return __decorate;
+    return LogixiaLoggerService;
   }
 });
-Object.defineProperty(exports, '__decorateMetadata', {
+Object.defineProperty(exports, 'PluginRegistry', {
   enumerable: true,
   get: function () {
-    return __decorateMetadata;
+    return PluginRegistry;
   }
 });
-Object.defineProperty(exports, '__decorateParam', {
+Object.defineProperty(exports, 'TraceMiddleware', {
   enumerable: true,
   get: function () {
-    return __decorateParam;
+    return TraceMiddleware;
   }
 });
-Object.defineProperty(exports, '_setActiveContextKey', {
+Object.defineProperty(exports, 'WebSocketTraceInterceptor', {
   enumerable: true,
   get: function () {
-    return _setActiveContextKey;
+    return WebSocketTraceInterceptor;
   }
 });
 Object.defineProperty(exports, '_shutdownRegistrySize', {
@@ -2762,12 +2910,6 @@ Object.defineProperty(exports, 'createLogger', {
     return createLogger;
   }
 });
-Object.defineProperty(exports, 'createTraceMiddleware', {
-  enumerable: true,
-  get: function () {
-    return createTraceMiddleware;
-  }
-});
 Object.defineProperty(exports, 'deregisterFromShutdown', {
   enumerable: true,
   get: function () {
@@ -2780,40 +2922,34 @@ Object.defineProperty(exports, 'disableOtelBridge', {
     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', {
+Object.defineProperty(exports, 'generateRequestId', {
   enumerable: true,
   get: function () {
-    return getActiveOtelContext;
+    return generateRequestId;
   }
 });
-Object.defineProperty(exports, 'getCurrentTraceId', {
+Object.defineProperty(exports, 'generateTraceId', {
   enumerable: true,
   get: function () {
-    return getCurrentTraceId;
+    return generateTraceId;
   }
 });
-Object.defineProperty(exports, 'getOtelMetaFields', {
+Object.defineProperty(exports, 'getActiveOtelContext', {
   enumerable: true,
   get: function () {
-    return getOtelMetaFields;
+    return getActiveOtelContext;
   }
 });
-Object.defineProperty(exports, 'getTraceContextKey', {
+Object.defineProperty(exports, 'getOtelMetaFields', {
   enumerable: true,
   get: function () {
-    return getTraceContextKey;
+    return getOtelMetaFields;
   }
 });
 Object.defineProperty(exports, 'globalPluginRegistry', {
@@ -2834,6 +2970,12 @@ Object.defineProperty(exports, 'isError', {
     return isError;
   }
 });
+Object.defineProperty(exports, 'isLogixiaException', {
+  enumerable: true,
+  get: function () {
+    return isLogixiaException;
+  }
+});
 Object.defineProperty(exports, 'normalizeError', {
   enumerable: true,
   get: function () {
@@ -2858,40 +3000,16 @@ Object.defineProperty(exports, 'resetShutdownHandlers', {
     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-BsDZR5BH.js.map
+//# sourceMappingURL=nestjs-extras-DnJ6vrIC.js.map