logixia 1.13.0 → 2.0.0

package/dist/{logitron-logger.module-Bs3XYZgF.mjs → builder-0gEzRopq.mjs}

@@ -1,16 +1,86 @@
 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 { i as TraceContext } from "./trace.utils-CvXgaiQT.mjs";
+import { t as LogixiaContext } from "./async-context-BzJrbfQs.mjs";
+import { t as safeToString } from "./coerce.utils-Cu6IUTgX.mjs";
+import { d as stripControlChars, t as TransportManager } from "./transport.manager-BiuCAJd2.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 { EMPTY, Observable } from "rxjs";
 
+//#region src/types/index.ts
+const LogLevel = {
+	ERROR: "error",
+	WARN: "warn",
+	INFO: "info",
+	DEBUG: "debug",
+	TRACE: "trace",
+	VERBOSE: "verbose"
+};
+const DEFAULT_LOG_LEVELS = {
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3,
+	trace: 4,
+	verbose: 5
+};
+const DEFAULT_LOG_COLORS = {
+	error: "red",
+	warn: "yellow",
+	info: "green",
+	debug: "blue",
+	trace: "magenta",
+	verbose: "cyan"
+};
+
+//#endregion
+//#region src/core/default-config.ts
+/**
+* Default configuration for Logixia logger
+*/
+const DEFAULT_CONFIG = {
+	appName: "App",
+	environment: "development",
+	traceId: true,
+	format: {
+		timestamp: true,
+		colorize: true,
+		json: false
+	},
+	silent: false,
+	levelOptions: {
+		level: LogLevel.INFO,
+		levels: {
+			[LogLevel.ERROR]: 0,
+			[LogLevel.WARN]: 1,
+			[LogLevel.INFO]: 2,
+			[LogLevel.DEBUG]: 3,
+			[LogLevel.TRACE]: 4,
+			[LogLevel.VERBOSE]: 5
+		},
+		colors: {
+			[LogLevel.ERROR]: "red",
+			[LogLevel.WARN]: "yellow",
+			[LogLevel.INFO]: "blue",
+			[LogLevel.DEBUG]: "green",
+			[LogLevel.TRACE]: "gray",
+			[LogLevel.VERBOSE]: "cyan"
+		}
+	},
+	fields: {
+		timestamp: true,
+		level: true,
+		appName: true,
+		traceId: true,
+		message: true,
+		payload: true,
+		timeTaken: true
+	},
+	outputs: ["console"]
+};
+
+//#endregion
 //#region src/plugin.ts
 /**
 * Holds an ordered list of `LogixiaPlugin` instances and dispatches lifecycle
@@ -117,33 +187,6 @@ function usePlugin(plugin) {
 	globalPluginRegistry.register(plugin);
 }
 
-//#endregion
-//#region src/types/index.ts
-const LogLevel = {
-	ERROR: "error",
-	WARN: "warn",
-	INFO: "info",
-	DEBUG: "debug",
-	TRACE: "trace",
-	VERBOSE: "verbose"
-};
-const DEFAULT_LOG_LEVELS = {
-	error: 0,
-	warn: 1,
-	info: 2,
-	debug: 3,
-	trace: 4,
-	verbose: 5
-};
-const DEFAULT_LOG_COLORS = {
-	error: "red",
-	warn: "yellow",
-	info: "green",
-	debug: "blue",
-	trace: "magenta",
-	verbose: "cyan"
-};
-
 //#endregion
 //#region src/utils/error.utils.ts
 const EXTRA_FIELDS = [
@@ -386,16 +429,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 +472,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 +586,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 +642,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 +695,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 +708,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 +752,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 +886,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 +904,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 +1068,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 +1630,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 +1715,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;
 	}
@@ -1941,682 +1767,218 @@ function createLogger(config, context) {
 }
 
 //#endregion
-//#region \0@oxc-project+runtime@0.95.0/helpers/decorateMetadata.js
-function __decorateMetadata(k, v) {
-	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.95.0/helpers/decorate.js
-function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-//#endregion
-//#region src/core/logitron-nestjs.service.ts
-var _LogixiaLoggerService;
-let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService$1 {
-	constructor(config) {
-		this._mergedConfig = {
-			appName: "NestJS-App",
-			environment: "development",
-			traceId: true,
-			format: {
-				timestamp: true,
-				colorize: true,
-				json: false
-			},
-			silent: false,
-			levelOptions: {
-				level: LogLevel.INFO,
-				levels: {
-					error: 0,
-					warn: 1,
-					log: 2,
-					debug: 3,
-					verbose: 4
-				},
-				colors: {
-					error: "red",
-					warn: "yellow",
-					log: "green",
-					debug: "blue",
-					verbose: "cyan"
-				}
-			},
-			fields: {
-				timestamp: "[yyyy-mm-dd HH:MM:ss.MS]",
-				level: "[log_level]",
-				appName: "[app_name]",
-				traceId: "[trace_id]",
-				message: "[message]",
-				payload: "[payload]",
-				timeTaken: "[time_taken_MS]"
-			},
-			...config
-		};
-		this.logger = new LogixiaLogger(this._mergedConfig);
-		this._createCustomLevelMethods();
-	}
-	_createCustomLevelMethods() {
-		var _this$_mergedConfig$l;
-		const levels = (_this$_mergedConfig$l = this._mergedConfig.levelOptions) === null || _this$_mergedConfig$l === void 0 ? void 0 : _this$_mergedConfig$l.levels;
-		if (!levels) return;
-		for (const levelName of Object.keys(levels)) {
-			const lower = levelName.toLowerCase();
-			if (typeof this[lower] !== "undefined") continue;
-			this[lower] = async (message, data) => {
-				return this.logger.logLevel(lower, message, data);
-			};
-		}
-	}
-	/**
-	* NestJS `LoggerService.log` — void, string context.
-	* Maps internally to `info`.
-	*
-	* @example `logger.log('User signed up', 'AuthService')`
-	*/
-	log(message, context) {
-		this.setContextIfProvided(context);
-		this.logger.info(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.log failed", err));
-	}
-	/**
-	* Native async `info` — structured data, returns `Promise<void>`.
-	*
-	* @example `await logger.info('User signed up', { userId: 'u_abc' })`
-	*/
-	async info(message, data) {
-		return this.logger.info(message, data);
-	}
-	error(message, dataOrTrace, context) {
-		if (typeof dataOrTrace === "object" && dataOrTrace !== null) return message instanceof Error ? this.logger.error(message, dataOrTrace) : this.logger.error(this.formatMessage(message), dataOrTrace);
-		this.setContextIfProvided(context);
-		const errorData = {};
-		if (typeof dataOrTrace === "string" && dataOrTrace) errorData.stack = dataOrTrace;
-		(message instanceof Error ? this.logger.error(message, errorData) : this.logger.error(this.formatMessage(message), errorData)).catch((err) => internalError("LogixiaLoggerService.error failed", err));
-	}
-	warn(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.warn(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.warn(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.warn failed", err));
-	}
-	debug(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.debug(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.debug(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.debug failed", err));
-	}
-	verbose(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.trace(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.trace(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.verbose failed", err));
-	}
-	/**
-	* Native async `trace` — lowest verbosity level, structured data.
-	*/
-	async trace(message, data) {
-		return this.logger.trace(message, data);
-	}
-	/**
-	* Log at any named level with structured data.
-	*/
-	logLevel(level, message, data) {
-		return this.logger.logLevel(level, message, data);
-	}
-	time(label) {
-		this.logger.time(label);
-	}
-	async timeEnd(label) {
-		return this.logger.timeEnd(label);
-	}
-	async timeAsync(label, fn) {
-		return this.logger.timeAsync(label, fn);
-	}
-	setContext(context) {
-		const coerced = typeof context === "string" ? context : safeToString(context);
-		this.context = coerced;
-		this.logger.setContext(coerced);
-	}
-	getContext() {
-		return this.context;
-	}
-	setLevel(level) {
-		this.logger.setLevel(level);
-	}
-	getLevel() {
-		return this.logger.getLevel();
-	}
-	child(context, data) {
-		const childService = new _LogixiaLoggerService(this._mergedConfig);
-		childService.logger = this.logger.child(context, data);
-		childService.context = context;
-		return childService;
-	}
-	getCurrentTraceId() {
-		return TraceContext.instance.getCurrentTraceId();
-	}
-	/** Returns the AsyncLocalStorage key currently used to store the trace ID. */
-	get traceContextKey() {
-		return getTraceContextKey();
-	}
-	async close() {
-		return this.logger.close();
-	}
-	static create(config) {
-		return new _LogixiaLoggerService(config);
-	}
-	getLogger() {
-		return this.logger;
-	}
-	setContextIfProvided(context) {
-		if (typeof context !== "string" || context.length === 0) return;
-		if (context !== this.context) this.setContext(context);
-	}
-	formatMessage(message) {
-		if (typeof message === "string") return message;
-		return safeToString(message);
-	}
-};
-LogixiaLoggerService = _LogixiaLoggerService = __decorate([Injectable({ scope: Scope.TRANSIENT }), __decorateMetadata("design:paramtypes", [Object])], LogixiaLoggerService);
-
-//#endregion
-//#region src/core/kafka-trace.interceptor.ts
-var _KafkaTraceInterceptor;
-let KafkaTraceInterceptor = class KafkaTraceInterceptor$1 {
-	static {
-		_KafkaTraceInterceptor = this;
-	}
-	static #_ = this.metrics = {
-		accepted: 0,
-		acceptedWithoutTrace: 0,
-		dropped: 0
-	};
-	/** Reset counters (tests). */
-	static resetMetrics() {
-		_KafkaTraceInterceptor.metrics.accepted = 0;
-		_KafkaTraceInterceptor.metrics.acceptedWithoutTrace = 0;
-		_KafkaTraceInterceptor.metrics.dropped = 0;
-	}
-	/**
-	* @param config        - TraceIdConfig options (extractor keys, contextKey, etc.)
-	* @param requireTraceId - When true, messages with no traceId are silently skipped
-	*                         (EMPTY Observable — message is ack'd, consumer stays alive).
-	*                         A WARN is logged AND `KafkaTraceInterceptor.metrics.dropped`
-	*                         increments so the missing traceId is observable end-to-end.
-	*                         Default: false (handler runs without trace context).
-	*/
-	constructor(config, requireTraceId = false) {
-		this.config = config;
-		this.requireTraceId = requireTraceId;
-		this.ctx = TraceContext.instance;
-		this.config = {
-			enabled: true,
-			contextKey: "traceId",
-			extractor: {
-				body: [
-					"traceId",
-					"trace_id",
-					"x-trace-id"
-				],
-				header: ["x-trace-id", "trace-id"]
-			},
-			...config
-		};
-	}
-	intercept(context, next) {
-		var _this$config;
-		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next.handle();
-		const rpcContext = context.switchToRpc();
-		const data = rpcContext.getData();
-		const rpcData = rpcContext.getContext();
-		let traceId;
-		if (this.config.extractor) traceId = extractTraceId({
-			body: data,
-			headers: (rpcData === null || rpcData === void 0 ? void 0 : rpcData.headers) ?? {},
-			query: {},
-			params: {}
-		}, this.config.extractor);
-		if (!traceId) traceId = this.ctx.getCurrentTraceId();
-		if (!traceId) {
-			if (this.requireTraceId) {
-				var _LogixiaLoggerModule$;
-				_KafkaTraceInterceptor.metrics.dropped++;
-				(_LogixiaLoggerModule$ = LogixiaLoggerModule.getGlobalLogger()) === null || _LogixiaLoggerModule$ === void 0 || _LogixiaLoggerModule$.warn(`[KafkaTraceInterceptor] Missing traceId on topic "${rpcData === null || rpcData === void 0 ? void 0 : rpcData.topic}" — message skipped.`);
-				return EMPTY;
-			}
-			_KafkaTraceInterceptor.metrics.acceptedWithoutTrace++;
-			return next.handle();
-		}
-		_KafkaTraceInterceptor.metrics.accepted++;
-		const kafkaContext = {
-			messageType: "kafka",
-			topic: rpcData === null || rpcData === void 0 ? void 0 : rpcData.topic,
-			partition: rpcData === null || rpcData === void 0 ? void 0 : rpcData.partition,
-			offset: rpcData === null || rpcData === void 0 ? void 0 : rpcData.offset,
-			key: rpcData === null || rpcData === void 0 ? void 0 : rpcData.key,
-			timestamp: rpcData === null || rpcData === void 0 ? void 0 : rpcData.timestamp
-		};
-		return new Observable((subscriber) => {
-			let inner;
-			this.ctx.run(traceId, () => {
-				inner = next.handle().subscribe({
-					next: (value) => subscriber.next(value),
-					error: (err) => subscriber.error(err),
-					complete: () => subscriber.complete()
-				});
-			}, kafkaContext);
-			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
-		});
+//#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);
 	}
 };
-KafkaTraceInterceptor = _KafkaTraceInterceptor = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [Object, Boolean])], KafkaTraceInterceptor);
-
-//#endregion
-//#region \0@oxc-project+runtime@0.95.0/helpers/decorateParam.js
-function __decorateParam(paramIndex, decorator) {
-	return function(target, key) {
-		decorator(target, key, paramIndex);
-	};
+/**
+* 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/core/trace.middleware.ts
-/** Default response header used to echo the resolved traceId back to the caller. */
-const DEFAULT_TRACE_RESPONSE_HEADER = "X-Trace-Id";
+//#region src/exceptions/builder.ts
 /**
-* Resolve the response header name from config.
-* - `undefined`   → default `'X-Trace-Id'`
-* - `string`      → user's custom header
-* - `false`       → `null` (suppress entirely)
+* 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 resolveResponseHeader(config) {
-	if ((config === null || config === void 0 ? void 0 : config.responseHeader) === false) return null;
-	return (config === null || config === void 0 ? void 0 : config.responseHeader) ?? DEFAULT_TRACE_RESPONSE_HEADER;
+function generateTraceId() {
+	return TraceContext.instance.generate();
 }
+/** @deprecated Use `generateTraceId` instead. */
+const generateRequestId = generateTraceId;
 /**
-* Echo the trace ID on the response, tolerating non-Express responses and
-* already-sent headers. NestJS can run on Fastify (reply.header() instead of
-* res.setHeader()), and on a closed/sent response setHeader throws — neither
-* should crash the request. The trace ID is still propagated via async context.
+* Maps an HTTP status code to a human-friendly error type string.
+* Used as a fallback when the exception is a generic `HttpException`.
 */
-function writeTraceHeader(res, header, traceId) {
-	const r = res;
-	if (r.headersSent) return;
-	try {
-		if (typeof r.setHeader === "function") r.setHeader(header, traceId);
-		else if (typeof r.header === "function") r.header(header, traceId);
-	} catch {}
+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";
 }
-let TraceMiddleware = class TraceMiddleware$1 {
-	constructor(config) {
-		this.config = config;
-		this.ctx = TraceContext.instance;
-		const defaultExtractor = {
-			header: DEFAULT_TRACE_HEADERS,
-			query: ["traceId", "trace_id"]
-		};
-		this.config = {
-			enabled: true,
-			generator: () => this.ctx.generate(),
-			contextKey: "traceId",
-			...config,
-			extractor: (config === null || config === void 0 ? void 0 : config.extractor) ? {
-				...defaultExtractor,
-				...config.extractor
-			} : defaultExtractor
-		};
-		if (this.config.enabled) this.ctx.setContextKey(this.config.contextKey ?? "traceId");
-	}
-	use(req, res, next) {
-		var _this$config, _req$socket, _req$connection;
-		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next();
-		let traceId;
-		if (this.config.extractor) traceId = extractTraceId(req, this.config.extractor);
-		if (!traceId && this.config.generator) {
-			const candidate = this.config.generator();
-			if (typeof candidate === "string" && candidate.trim().length > 0) traceId = candidate;
-			else internalWarn("TraceIdConfig.generator returned a non-string/empty value — using built-in generator.");
-		}
-		if (!traceId) traceId = this.ctx.generate();
-		req.traceId = traceId;
-		const header = resolveResponseHeader(this.config);
-		if (header) writeTraceHeader(res, header, traceId);
-		this.ctx.run(traceId, () => next(), {
-			method: req.method,
-			url: req.url,
-			userAgent: req.get("User-Agent"),
-			ip: req.ip || ((_req$socket = req.socket) === null || _req$socket === void 0 ? void 0 : _req$socket.remoteAddress) || ((_req$connection = req.connection) === null || _req$connection === void 0 ? void 0 : _req$connection.remoteAddress)
-		});
-	}
-};
-TraceMiddleware = __decorate([
-	Injectable(),
-	__decorateParam(0, Optional()),
-	__decorateMetadata("design:paramtypes", [Object])
-], TraceMiddleware);
-
-//#endregion
-//#region src/core/websocket-trace.interceptor.ts
-let WebSocketTraceInterceptor = class WebSocketTraceInterceptor$1 {
-	constructor(config) {
-		this.config = config;
-		this.ctx = TraceContext.instance;
-		this.config = {
-			enabled: true,
-			contextKey: "traceId",
-			extractor: {
-				body: [
-					"traceId",
-					"trace_id",
-					"x-trace-id"
-				],
-				header: ["x-trace-id", "trace-id"],
-				query: ["traceId", "trace_id"]
-			},
-			...config
-		};
-	}
-	intercept(context, next) {
-		var _this$config, _client$handshake3;
-		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next.handle();
-		const wsContext = context.switchToWs();
-		const data = wsContext.getData();
-		const client = wsContext.getClient();
-		let traceId;
-		if (this.config.extractor) {
-			var _client$handshake, _client$handshake2;
-			traceId = extractTraceId({
-				body: data,
-				headers: (client === null || client === void 0 || (_client$handshake = client.handshake) === null || _client$handshake === void 0 ? void 0 : _client$handshake.headers) || {},
-				query: (client === null || client === void 0 || (_client$handshake2 = client.handshake) === null || _client$handshake2 === void 0 ? void 0 : _client$handshake2.query) || {},
-				params: {}
-			}, this.config.extractor);
-		}
-		if (!traceId) traceId = this.ctx.getCurrentTraceId();
-		if (!traceId) return next.handle();
-		const wsContextData = {
-			messageType: "websocket",
-			event: data === null || data === void 0 ? void 0 : data.event,
-			socketId: client === null || client === void 0 ? void 0 : client.id,
-			rooms: (client === null || client === void 0 ? void 0 : client.rooms) ? Array.from(client.rooms) : [],
-			clientAddress: client === null || client === void 0 || (_client$handshake3 = client.handshake) === null || _client$handshake3 === void 0 ? void 0 : _client$handshake3.address
-		};
-		return new Observable((observer) => {
-			let inner;
-			this.ctx.run(traceId, () => {
-				inner = next.handle().subscribe({
-					next: (value) => observer.next(value),
-					error: (err) => observer.error(err),
-					complete: () => observer.complete()
-				});
-			}, wsContextData);
-			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
-		});
-	}
-};
-WebSocketTraceInterceptor = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [Object])], WebSocketTraceInterceptor);
-
-//#endregion
-//#region src/core/logitron-logger.module.ts
-var _LogixiaLoggerModule;
-const DEFAULT_ROUTES = [{
-	path: "*",
-	method: RequestMethod.ALL
-}];
-const LOGIXIA_LOGGER_CONFIG = "LOGIXIA_LOGGER_CONFIG";
-const LOGIXIA_TRACE_CONFIG = "TRACE_CONFIG";
-const LOGIXIA_LOGGER_PREFIX = "LOGIXIA_LOGGER_";
-let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
-	static {
-		_LogixiaLoggerModule = this;
-	}
-	constructor() {
-		this.config = {};
-	}
-	static #_ = this.loggerConfig = {};
-	static #_2 = this._globalLogger = null;
+/**
+* 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 {
 	/**
-	* @internal Set the global logger exactly once.
-	*
-	* Called from the module's forRoot / forRootAsync factory. If the module is
-	* initialised more than once in the same process (nested DI context, test
-	* harness creating multiple apps, hot reload, etc.) a warning is written to
-	* stderr and the first logger wins — silently overwriting would allow the
-	* newer instance's transport config to replace the live one while the old
-	* one is still being used by registered shutdown hooks, decorators, etc.
+	* Build a `LogixiaErrorResponse` from any thrown value.
 	*
-	* Use {@link _resetGlobalLogger} in tests to reset between runs.
-	*/
-	static _setGlobalLogger(service) {
-		if (_LogixiaLoggerModule._globalLogger !== null) {
-			internalWarn("LogixiaLoggerModule.forRoot() was called more than once — ignoring the second init. If this is intentional (e.g. in tests), call LogixiaLoggerModule._resetGlobalLogger() first.");
-			return;
-		}
-		_LogixiaLoggerModule._globalLogger = service;
-	}
-	/** @internal Clear the global logger. Tests only. */
-	static _resetGlobalLogger() {
-		_LogixiaLoggerModule._globalLogger = null;
-	}
-	/**
-	* Returns the global LogixiaLoggerService instance that was created when the
-	* module booted. Useful for logging outside of NestJS DI — utility functions,
-	* plain scripts, decorators — without injecting the service everywhere.
+	* @param params - See `BuildParams`.
+	* @returns The unified error response and the HTTP status code to send.
 	*
-	* Returns `null` if called before `LogixiaLoggerModule.forRoot[Async]()` has
-	* been initialised (i.e. before the NestJS app has started).
+	* @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
+	* @example In a NestJS exception filter
 	* ```ts
-	* // some-util.ts
-	* import { LogixiaLoggerModule } from 'logixia/nest';
+	* 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,
+	* });
 	*
-	* export function doSomething() {
-	*   LogixiaLoggerModule.getGlobalLogger()?.info('doing something');
+	* 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 getGlobalLogger() {
-		return _LogixiaLoggerModule._globalLogger;
-	}
-	configure(consumer) {
-		const { forRoutes = DEFAULT_ROUTES, exclude } = this.config;
-		let resolvedTraceConfig;
-		if (typeof _LogixiaLoggerModule.loggerConfig.traceId === "object") resolvedTraceConfig = _LogixiaLoggerModule.loggerConfig.traceId;
-		else if (_LogixiaLoggerModule.loggerConfig.traceId === true) resolvedTraceConfig = {
-			enabled: true,
-			contextKey: "traceId",
-			generator: () => TraceContext.instance.generate()
+	static build(params) {
+		const { exception, path, service, startTime, traceId: rawTraceId, exposeDebug, exposeCause } = params;
+		const expose = {
+			debug: exposeDebug,
+			cause: exposeCause
 		};
-		const middleware = new TraceMiddleware(resolvedTraceConfig);
-		const middlewareConfig = (req, res, next) => middleware.use(req, res, next);
-		if (exclude) consumer.apply(middlewareConfig).exclude(...exclude).forRoutes(...forRoutes);
-		else consumer.apply(middlewareConfig).forRoutes(...forRoutes);
-	}
-	/**
-	* Configure the module with synchronous options
-	*/
-	static forRoot(config) {
-		_LogixiaLoggerModule.loggerConfig = config || {};
-		const traceConfig = (config === null || config === void 0 ? void 0 : config.traceId) && typeof config.traceId === "object" ? config.traceId : { enabled: !!(config === null || config === void 0 ? void 0 : config.traceId) };
-		return {
-			module: _LogixiaLoggerModule,
-			providers: [
-				{
-					provide: LOGIXIA_LOGGER_CONFIG,
-					useValue: config || {}
-				},
-				{
-					provide: LOGIXIA_TRACE_CONFIG,
-					useValue: traceConfig
-				},
-				{
-					provide: LogixiaLoggerService,
-					useFactory: (loggerConfig) => {
-						const service = new LogixiaLoggerService({
-							level: "info",
-							service: "NestJSApp",
-							environment: "development",
-							fields: {},
-							formatters: ["text"],
-							outputs: ["console"],
-							levelOptions: {
-								level: "info",
-								levels: {
-									error: 0,
-									warn: 1,
-									info: 2,
-									debug: 3,
-									verbose: 4
-								},
-								colors: {
-									error: "red",
-									warn: "yellow",
-									info: "green",
-									debug: "blue",
-									verbose: "cyan"
-								}
-							},
-							...loggerConfig
-						});
-						_LogixiaLoggerModule._setGlobalLogger(service);
-						return service;
+		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
 					},
-					inject: [LOGIXIA_LOGGER_CONFIG]
+					...debug$1 !== void 0 ? { debug: debug$1 } : {}
 				},
-				{
-					provide: KafkaTraceInterceptor,
-					useFactory: (traceConfig$1) => new KafkaTraceInterceptor(traceConfig$1),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				},
-				{
-					provide: WebSocketTraceInterceptor,
-					useFactory: (traceConfig$1) => new WebSocketTraceInterceptor(traceConfig$1),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				}
-			],
-			exports: [
-				LogixiaLoggerService,
-				LOGIXIA_LOGGER_CONFIG,
-				KafkaTraceInterceptor,
-				WebSocketTraceInterceptor
-			],
-			global: true
-		};
-	}
-	/**
-	* Configure the module with asynchronous options
-	*/
-	static forRootAsync(options) {
-		return {
-			module: _LogixiaLoggerModule,
-			imports: options.imports || [],
-			providers: [
-				...this.createAsyncProviders(options),
-				{
-					provide: LOGIXIA_TRACE_CONFIG,
-					useFactory: (loggerConfig) => {
-						return typeof (loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) === "object" ? loggerConfig.traceId : { enabled: !!(loggerConfig === null || loggerConfig === void 0 ? void 0 : loggerConfig.traceId) };
+				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
 					},
-					inject: [LOGIXIA_LOGGER_CONFIG]
-				},
-				{
-					provide: LogixiaLoggerService,
-					useFactory: (loggerConfig) => {
-						const defaultConfig = {
-							level: "info",
-							service: "NestJSApp",
-							environment: "development",
-							fields: {},
-							formatters: ["text"],
-							outputs: ["console"],
-							levelOptions: {
-								level: "info",
-								levels: {
-									error: 0,
-									warn: 1,
-									info: 2,
-									debug: 3,
-									verbose: 4
-								},
-								colors: {
-									error: "red",
-									warn: "yellow",
-									info: "green",
-									debug: "blue",
-									verbose: "cyan"
-								}
-							},
-							...loggerConfig
-						};
-						_LogixiaLoggerModule.loggerConfig = defaultConfig;
-						const service = new LogixiaLoggerService(defaultConfig);
-						_LogixiaLoggerModule._setGlobalLogger(service);
-						return service;
+					meta: {
+						...traceId !== void 0 ? { trace_id: traceId } : {},
+						timestamp,
+						path,
+						status
 					},
-					inject: [LOGIXIA_LOGGER_CONFIG]
-				},
-				{
-					provide: KafkaTraceInterceptor,
-					useFactory: (traceConfig) => new KafkaTraceInterceptor(traceConfig),
-					inject: [LOGIXIA_TRACE_CONFIG]
+					...debug$1 !== void 0 ? { debug: debug$1 } : {}
 				},
-				{
-					provide: WebSocketTraceInterceptor,
-					useFactory: (traceConfig) => new WebSocketTraceInterceptor(traceConfig),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				}
-			],
-			exports: [
-				LogixiaLoggerService,
-				LOGIXIA_LOGGER_CONFIG,
-				KafkaTraceInterceptor,
-				WebSocketTraceInterceptor
-			],
-			global: true
-		};
-	}
-	/**
-	* Create feature-specific logger instances
-	*/
-	static forFeature(context) {
-		const providerToken = `${LOGIXIA_LOGGER_PREFIX}${context.toUpperCase()}`;
+				httpStatus: status
+			};
+		}
+		const debug = buildDebug(exception instanceof Error ? exception : new Error(String(exception)), service, durationMs, expose);
 		return {
-			module: _LogixiaLoggerModule,
-			providers: [{
-				provide: providerToken,
-				useFactory: (baseLogger) => {
-					return baseLogger.child(context);
+			response: {
+				success: false,
+				error: {
+					type: "server_error",
+					code: "INTERNAL_SERVER_ERROR",
+					message: "An unexpected error occurred."
 				},
-				inject: [LogixiaLoggerService]
-			}],
-			exports: [providerToken]
-		};
-	}
-	static createAsyncProviders(options) {
-		if (options.useExisting || options.useFactory) return [this.createAsyncOptionsProvider(options)];
-		return [this.createAsyncOptionsProvider(options), {
-			provide: options.useClass,
-			useClass: options.useClass
-		}];
-	}
-	static createAsyncOptionsProvider(options) {
-		if (options.useFactory) return {
-			provide: LOGIXIA_LOGGER_CONFIG,
-			useFactory: options.useFactory,
-			inject: options.inject || []
-		};
-		return {
-			provide: LOGIXIA_LOGGER_CONFIG,
-			useFactory: async (optionsFactory) => await optionsFactory.createLogixiaOptions(),
-			inject: [options.useExisting || options.useClass]
+				meta: {
+					...traceId !== void 0 ? { trace_id: traceId } : {},
+					timestamp,
+					path,
+					status: 500
+				},
+				...debug !== void 0 ? { debug } : {}
+			},
+			httpStatus: 500
 		};
 	}
 };
-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
+export { globalPluginRegistry as C, DEFAULT_LOG_LEVELS as D, DEFAULT_LOG_COLORS as E, LogLevel as O, PluginRegistry as S, DEFAULT_CONFIG as T, getOtelMetaFields as _, isLogixiaException as a, normalizeError as b, _shutdownRegistrySize as c, registerForShutdown as d, resetShutdownHandlers as f, getActiveOtelContext as g, disableOtelBridge as h, LogixiaException as i, deregisterFromShutdown as l, redactObject as m, generateRequestId as n, LogixiaLogger as o, applyRedaction as p, generateTraceId as r, createLogger as s, ErrorResponseBuilder as t, flushOnExit as u, initOtelBridge as v, usePlugin as w, serializeError as x, isError as y };
+//# sourceMappingURL=builder-0gEzRopq.mjs.map