logixia 1.12.6 → 1.13.3

package/dist/{logitron-logger.module-Bs3XYZgF.mjs → nestjs-extras-ImbuDhs1.mjs}

@@ -1,14 +1,13 @@
 import { t as __require } from "./chunk-DLSkYcPk.mjs";
 import { n as internalLog, r as internalWarn, t as internalError } from "./internal-log-Cm8SOWSV.mjs";
 import { i as stringifyForLog } from "./safe-stringify-DJ66tW5I.mjs";
-import { t as LogixiaContext } from "./async-context-CwBNMm2E.mjs";
-import { t as safeToString } from "./coerce.utils-Dxv4_ikC.mjs";
-import { t as TransportManager } from "./transport.manager-D6KL3t9V.mjs";
+import { d as sanitizeIncomingId, i as TraceContext, l as getTraceContextKey, s as extractTraceId, t as DEFAULT_TRACE_HEADERS } from "./trace.utils-CvXgaiQT.mjs";
+import { t as LogixiaContext } from "./async-context-BzJrbfQs.mjs";
+import { t as safeToString } from "./coerce.utils-Cu6IUTgX.mjs";
+import { t as TransportManager, u as stripControlChars } from "./transport.manager-CpdVHEGP.mjs";
 import { constants } from "node:os";
-import { AsyncLocalStorage } from "node:async_hooks";
 import buildFastStringify from "fast-json-stringify";
-import crypto from "crypto";
-import { Injectable, Module, Optional, RequestMethod, Scope } from "@nestjs/common";
+import { Catch, Inject, Injectable, Module, Optional, RequestMethod, Scope } from "@nestjs/common";
 import { EMPTY, Observable } from "rxjs";
 
 //#region src/plugin.ts
@@ -386,16 +385,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.
@@ -416,14 +428,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,
@@ -520,32 +542,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);
 	}
@@ -554,26 +598,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,
@@ -582,8 +651,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;
 }
 /**
@@ -594,12 +664,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 : 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).
@@ -639,11 +708,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 = [];
@@ -763,13 +842,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);
@@ -779,6 +860,7 @@ var Sampler = class {
 		this.traceDecisions.delete(traceId);
 		this.traceDecisions.set(traceId, {
 			emit,
+			firstAt: now,
 			seenAt: now
 		});
 		if (this.traceDecisions.size > this.maxTrackedTraces) {
@@ -942,318 +1024,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.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.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 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 = buildFastStringify({
@@ -1816,9 +1586,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;
+		if (rawPayload !== void 0 && rawPayload !== null) if (this._hasRedact) try {
+			payload = applyRedaction(rawPayload, this.config.redact) ?? rawPayload;
+		} catch (error) {
+			internalError("Redaction failed", error);
+			payload = { redaction: REDACTION_FAILED };
+		}
+		else payload = rawPayload;
 		const traceId = this.config.traceId ? TraceContext.instance.getCurrentTraceId() ?? this.fallbackTraceId : void 0;
-		const safeMessage = this._hasRedact ? applyRedactionToString(message, this.config.redact) : message;
+		let safeMessage = message;
+		if (this._hasRedact) try {
+			safeMessage = applyRedactionToString(message, this.config.redact);
+		} catch (error) {
+			internalError("Redaction failed", error);
+			safeMessage = REDACTION_FAILED;
+		}
 		const entry = {
 			timestamp: nowIso(),
 			level,
@@ -1889,9 +1671,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}[${stripControlChars(String(entry.traceId))}]${reset} `;
+		if (entry.context && this._fieldCache.get("context") !== false) formatted += `${yellow}[${stripControlChars(String(entry.context))}]${reset} `;
+		if (this._fieldCache.get("message") !== false) formatted += stripControlChars(safeToString(entry.message));
 		if (entry.payload !== void 0 && this._fieldCache.get("payload") !== false) formatted += ` ${stringifyForLog(entry.payload)}`;
 		return formatted;
 	}
@@ -2618,5 +2400,379 @@ let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
 LogixiaLoggerModule = _LogixiaLoggerModule = __decorate([Module({})], LogixiaLoggerModule);
 
 //#endregion
-export { resetShutdownHandlers as A, DEFAULT_LOG_COLORS as B, runWithTraceId as C, deregisterFromShutdown as D, _shutdownRegistrySize as E, getOtelMetaFields as F, usePlugin as G, LogLevel as H, initOtelBridge as I, isError as L, redactObject as M, disableOtelBridge as N, flushOnExit as O, getActiveOtelContext as P, normalizeError as R, getTraceContextKey as S, traceStorage as T, PluginRegistry as U, DEFAULT_LOG_LEVELS as V, globalPluginRegistry as W, TraceContext as _, WebSocketTraceInterceptor as a, extractTraceId as b, __decorateParam as c, __decorate as d, __decorateMetadata as f, TRACE_CONTEXT_KEY as g, DEFAULT_TRACE_HEADERS as h, LogixiaLoggerModule as i, applyRedaction as j, registerForShutdown as k, KafkaTraceInterceptor as l, createLogger as m, LOGIXIA_LOGGER_PREFIX as n, TraceMiddleware as o, LogixiaLogger as p, LOGIXIA_TRACE_CONFIG as r, resolveResponseHeader as s, LOGIXIA_LOGGER_CONFIG as t, LogixiaLoggerService as u, _setActiveContextKey as v, setTraceId as w, getCurrentTraceId as x, createTraceMiddleware as y, serializeError as z };
-//# sourceMappingURL=logitron-logger.module-Bs3XYZgF.mjs.map
+//#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 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 = 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 = () => Inject(`${LOGIXIA_LOGGER_PREFIX}SERVICE`);
+/**
+* Method decorator that auto-logs entry, exit, duration, and errors.
+*
+* Preserves the original method's sync/async contract: a synchronous method
+* stays synchronous (returns its value directly, with logs emitted
+* fire-and-forget), and an async method is awaited so exit/error logs reflect
+* the resolved result. Attaches to the logger found on the class instance via a
+* `logger` property (the conventional NestJS name).
+*
+* @example
+* ```ts
+* @LogMethod({ level: 'info', logArgs: true })
+* async processPayment(orderId: string): Promise<void> { … }
+* ```
+*/
+function LogMethod(options = {}) {
+	const { level = "debug", logArgs = true, logResult = false, logErrors = true } = options;
+	return function(target, propertyKey, descriptor) {
+		var _constructor;
+		const originalMethod = descriptor.value;
+		if (typeof originalMethod !== "function") return descriptor;
+		const methodName = String(propertyKey);
+		const className = ((_constructor = target.constructor) === null || _constructor === void 0 ? void 0 : _constructor.name) ?? "Unknown";
+		const label = options.label ?? `${className}.${methodName}`;
+		let _warnedNoLogger = false;
+		const reportLogFailure = (phase, err) => {
+			internalError(`@LogMethod(${label}) ${phase} log failed: ${String(err)}`);
+		};
+		const emit = (logger, phase, message, data) => {
+			const logFnRaw = logger[level];
+			const p = (typeof logFnRaw === "function" ? logFnRaw : logger.debug).bind(logger)(message, data);
+			if (p && typeof p.catch === "function") p.catch((e) => reportLogFailure(phase, e));
+		};
+		const emitError = (logger, error, start) => {
+			const err = error instanceof Error ? error : new Error(String(error));
+			const errLog = logger.error(err, {
+				method: label,
+				durationMs: Date.now() - start
+			});
+			if (errLog && typeof errLog.catch === "function") errLog.catch((e) => reportLogFailure("error", e));
+		};
+		descriptor.value = function(...args) {
+			const logger = this.logger ?? LogixiaLoggerModule._globalLogger ?? void 0;
+			if (!logger && !_warnedNoLogger) {
+				_warnedNoLogger = true;
+				internalWarn(`@LogMethod on ${label}: no logger available. Either inject LogixiaLoggerService as this.logger or ensure LogixiaLoggerModule is initialised.`);
+			}
+			const start = Date.now();
+			const entry = { method: label };
+			if (logArgs && args.length > 0) entry["args"] = args;
+			if (logger) emit(logger, "entry", `→ ${label}`, entry);
+			const buildExit = (result$1) => {
+				const exit = {
+					method: label,
+					durationMs: Date.now() - start
+				};
+				if (logResult) exit["result"] = result$1;
+				return exit;
+			};
+			let result;
+			try {
+				result = originalMethod.apply(this, args);
+			} catch (error) {
+				if (logger && logErrors) emitError(logger, error, start);
+				throw error;
+			}
+			if (result && typeof result.then === "function") return result.then((resolved) => {
+				if (logger) emit(logger, "exit", `← ${label}`, buildExit(resolved));
+				return resolved;
+			}, (error) => {
+				if (logger && logErrors) emitError(logger, error, start);
+				throw error;
+			});
+			if (logger) emit(logger, "exit", `← ${label}`, buildExit(result));
+			return result;
+		};
+		return descriptor;
+	};
+}
+/** Injection token for {@link LogixiaExceptionFilterOptions}. */
+const LOGIXIA_EXCEPTION_FILTER_OPTIONS = "LOGIXIA_EXCEPTION_FILTER_OPTIONS";
+let LogixiaExceptionFilter = class LogixiaExceptionFilter$1 {
+	constructor(logger, loggerConfig, options) {
+		this._options = options ?? {};
+		this._logger = logger ?? LogixiaLoggerModule._globalLogger ?? void 0;
+		this._traceConfig = typeof (loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) === "object" ? loggerConfig.traceId : void 0;
+	}
+	catch(exception, host) {
+		var _request$headers;
+		const ctx = host.switchToHttp();
+		const request = ctx.getRequest();
+		const response = ctx.getResponse();
+		const traceId = TraceContext.instance.getCurrentTraceId() ?? sanitizeIncomingId((_request$headers = request.headers) === null || _request$headers === void 0 ? void 0 : _request$headers["x-trace-id"]) ?? sanitizeIncomingId(request.id) ?? void 0;
+		const { response: errorResponse, httpStatus } = ErrorResponseBuilder.build({
+			exception,
+			traceId,
+			path: request.url ?? "/",
+			startTime: request.startTime,
+			exposeDebug: this._options.exposeDebug === true,
+			exposeCause: this._options.exposeCause === true
+		});
+		if (this._logger) {
+			const requestMeta = {
+				method: request.method ?? "",
+				url: request.url ?? "",
+				status: httpStatus,
+				...errorResponse.meta.trace_id !== void 0 ? { trace_id: errorResponse.meta.trace_id } : {}
+			};
+			const onLogFailure = (err) => {
+				internalError(`ExceptionFilter failed to write log entry: ${String(err)}`);
+			};
+			let logPromise;
+			if (httpStatus >= 500) {
+				const err = exception instanceof Error ? exception : new Error(String(exception));
+				logPromise = this._logger.error(err, requestMeta);
+			} else if (isLogixiaException(exception)) logPromise = this._logger.warn(`[${errorResponse.error.code}] ${errorResponse.error.message}`, requestMeta);
+			else logPromise = this._logger.warn(`[${httpStatus}] ${errorResponse.error.message}`, requestMeta);
+			if (logPromise && typeof logPromise.catch === "function") logPromise.catch(onLogFailure);
+		}
+		if (errorResponse.meta.trace_id) {
+			const traceHeader = resolveResponseHeader(this._traceConfig);
+			if (traceHeader) try {
+				response.setHeader(traceHeader, errorResponse.meta.trace_id);
+			} catch {}
+		}
+		if (httpStatus === 429) try {
+			response.setHeader("Retry-After", "60");
+		} catch {}
+		response.status(httpStatus).json(errorResponse);
+	}
+};
+LogixiaExceptionFilter = __decorate([
+	Catch(),
+	__decorateParam(0, Optional()),
+	__decorateParam(0, Inject(`${LOGIXIA_LOGGER_PREFIX}SERVICE`)),
+	__decorateParam(1, Optional()),
+	__decorateParam(1, Inject(LOGIXIA_LOGGER_CONFIG)),
+	__decorateParam(2, Optional()),
+	__decorateParam(2, Inject(LOGIXIA_EXCEPTION_FILTER_OPTIONS)),
+	__decorateMetadata("design:paramtypes", [
+		Object,
+		typeof (_ref = typeof Partial !== "undefined" && Partial) === "function" ? _ref : Object,
+		Object
+	])
+], LogixiaExceptionFilter);
+
+//#endregion
+export { initOtelBridge as A, registerForShutdown as C, disableOtelBridge as D, redactObject as E, DEFAULT_LOG_LEVELS as F, LogLevel as I, PluginRegistry as L, normalizeError as M, serializeError as N, getActiveOtelContext as O, DEFAULT_LOG_COLORS as P, globalPluginRegistry as R, flushOnExit as S, applyRedaction as T, LogixiaLoggerService as _, ErrorResponseBuilder as a, _shutdownRegistrySize as b, LogixiaException as c, LOGIXIA_LOGGER_PREFIX as d, LOGIXIA_TRACE_CONFIG as f, KafkaTraceInterceptor as g, TraceMiddleware as h, LogixiaExceptionFilter as i, isError as j, getOtelMetaFields as k, isLogixiaException as l, WebSocketTraceInterceptor as m, LOGIXIA_EXCEPTION_FILTER_OPTIONS as n, generateRequestId as o, LogixiaLoggerModule as p, LogMethod as r, generateTraceId as s, InjectLogger as t, LOGIXIA_LOGGER_CONFIG as u, LogixiaLogger as v, resetShutdownHandlers as w, deregisterFromShutdown as x, createLogger as y, usePlugin as z };
+//# sourceMappingURL=nestjs-extras-ImbuDhs1.mjs.map