logixia 1.13.0 → 2.0.0

package/dist/{logitron-logger.module-BsDZR5BH.js → builder-D44QktIo.js}

@@ -1,22 +1,88 @@
 const require_chunk = require('./chunk-nOFOJqeH.js');
 const require_internal_log = require('./internal-log-BUJYMZbE.js');
 const require_safe_stringify = require('./safe-stringify-DWo3aZp_.js');
-const require_async_context = require('./async-context-CSHWoHMB.js');
-const require_coerce_utils = require('./coerce.utils-BN980Y9V.js');
-const require_transport_manager = require('./transport.manager-BivyUTtU.js');
+const require_trace_utils = require('./trace.utils-DpBOLDtq.js');
+const require_async_context = require('./async-context-DyQQYq3I.js');
+const require_coerce_utils = require('./coerce.utils-B-LilukN.js');
+const require_transport_manager = require('./transport.manager-CXbKKdVE.js');
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
-let node_async_hooks = require("node:async_hooks");
-node_async_hooks = require_chunk.__toESM(node_async_hooks);
 let fast_json_stringify = require("fast-json-stringify");
 fast_json_stringify = require_chunk.__toESM(fast_json_stringify);
-let crypto = require("crypto");
-crypto = require_chunk.__toESM(crypto);
-let __nestjs_common = require("@nestjs/common");
-__nestjs_common = require_chunk.__toESM(__nestjs_common);
-let rxjs = require("rxjs");
-rxjs = require_chunk.__toESM(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
@@ -123,33 +189,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 = [
@@ -392,16 +431,29 @@ function disableOtelBridge() {
 //#endregion
 //#region src/utils/redact.utils.ts
 const DEFAULT_CENSOR = "[REDACTED]";
+/** Maximum nesting depth walked; deeper values are replaced with a marker. */
+const MAX_DEPTH = 32;
+/** Maximum number of objects/arrays visited per redaction pass. */
+const MAX_NODES = 1e4;
+/**
+* Strings longer than this are truncated before pattern scanning. The tail is
+* dropped rather than emitted unscanned, so oversized input can never carry an
+* unredacted secret past the patterns.
+*/
+const MAX_SCAN_LENGTH = 16384;
+const MAX_DEPTH_MARKER = "[MaxDepth]";
+const MAX_NODES_MARKER = "[MaxNodes]";
+const REDACTION_FAILED = "[RedactionFailed]";
 /**
 * Conservative patterns: tokens and secrets that should NEVER appear in logs.
 * Applied when `autoDetect: true` or `autoDetect: 'conservative'`.
 */
 const PII_CONSERVATIVE_PATTERNS = [
-	/eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g,
+	/eyJ[A-Za-z0-9_-]{1,1024}\.[A-Za-z0-9_-]{1,16384}\.[A-Za-z0-9_-]{0,1024}/g,
 	/Bearer\s+[A-Za-z0-9._~+/-]+=*/gi,
 	/\b(?:sk|pk|api|key|secret|token)-[A-Za-z0-9_-]{16,}/gi,
 	/\bAKIA[0-9A-Z]{16}\b/g,
-	/\b[A-Za-z0-9/+]{40}\b(?=.*aws)/gi
+	/secret[_-]?(?:access[_-]?)?key["'\s:=]{1,6}[A-Za-z0-9/+]{40}(?![A-Za-z0-9/+])/gi
 ];
 /**
 * Conservative field-name paths auto-redacted by name regardless of value.
@@ -422,14 +474,24 @@ const PII_CONSERVATIVE_PATHS = [
 	"**.privateKey",
 	"**.private_key",
 	"**.clientSecret",
-	"**.client_secret"
+	"**.client_secret",
+	"**.cookie",
+	"**.set-cookie",
+	"**.x-api-key",
+	"**.session",
+	"**.proxy-authorization",
+	"**.x-auth-token",
+	"**.x-access-token",
+	"**.aws_secret_access_key",
+	"**.awsSecretAccessKey",
+	"**.secretAccessKey"
 ];
 /**
 * Aggressive patterns: also catch personal data that could identify a person.
 * Applied when `autoDetect: 'aggressive'`.
 */
 const PII_AGGRESSIVE_PATTERNS = [
-	/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+	/\b[A-Za-z0-9._%+-]{1,64}@[A-Za-z0-9.-]{1,255}\.[A-Za-z]{2,24}\b/g,
 	/\b\d{3}-?\d{2}-?\d{4}\b/g,
 	/\b(?:\d[ -]?){13,19}\b/g,
 	/\b(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
@@ -526,32 +588,54 @@ function matchesPath(fullPath, pattern) {
 	}
 	return re.test(fullPath);
 }
+function isTokenChar(code) {
+	return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 46 || code === 95 || code === 126 || code === 43 || code === 47 || code === 61 || code === 45;
+}
 function applyPatterns(value, patterns, censor) {
 	let redacted = value;
+	let suffix = "";
+	if (redacted.length > MAX_SCAN_LENGTH) {
+		let end = MAX_SCAN_LENGTH;
+		while (end > 0 && isTokenChar(redacted.charCodeAt(end - 1))) end--;
+		suffix = `…[truncated ${value.length - end} unscanned chars]`;
+		redacted = redacted.slice(0, end);
+	}
 	for (const pattern of patterns) redacted = redacted.replace(pattern, censor);
-	return redacted;
+	return redacted + suffix;
 }
 const CIRCULAR = "[Circular]";
 function joinPath(parent, key) {
 	return parent ? `${parent}.${key}` : key;
 }
-function walkValue(value, state, fullPath, bare) {
+function walkValue(value, state, fullPath, bare, depth) {
 	const { paths = [], excludePaths = [], patterns = [], censor = DEFAULT_CENSOR } = state.config;
 	if (paths.some((p) => matchesPath(fullPath, p) || matchesPath(bare, p))) return censor;
+	if (typeof value === "object" && value !== null) {
+		if (depth >= MAX_DEPTH) return MAX_DEPTH_MARKER;
+		if (++state.nodes > MAX_NODES) return MAX_NODES_MARKER;
+	}
 	if (typeof value === "string") {
 		if (patterns.length === 0) return value;
 		if (excludePaths.some((p) => matchesPath(fullPath, p) || matchesPath(bare, p))) return value;
 		return applyPatterns(value, patterns, censor);
 	}
-	if (Array.isArray(value)) return walkContainer(value, state, fullPath, bare, walkArray);
-	if (isPlainObject(value)) return walkContainer(value, state, fullPath, bare, walkRecord);
+	if (Array.isArray(value)) return walkContainer(value, state, fullPath, bare, depth, walkArray);
+	if (value instanceof Error) return walkContainer(value, state, fullPath, bare, depth, walkError);
+	if (value instanceof URL) {
+		const url = new URL(value.href);
+		url.username = "";
+		url.password = "";
+		const redacted = walkValue(url.href, state, fullPath, bare, depth);
+		return redacted === value.href ? value : redacted;
+	}
+	if (isPlainObject(value)) return walkContainer(value, state, fullPath, bare, depth, typeof value.toJSON === "function" ? walkToJSON : walkRecord);
 	return value;
 }
-function walkContainer(value, state, fullPath, bare, walk) {
+function walkContainer(value, state, fullPath, bare, depth, walk) {
 	if (state.ancestors.has(value)) return CIRCULAR;
 	state.ancestors.add(value);
 	try {
-		return walk(value, state, fullPath, bare);
+		return walk(value, state, fullPath, bare, depth + 1);
 	} finally {
 		state.ancestors.delete(value);
 	}
@@ -560,26 +644,51 @@ function walkContainer(value, state, fullPath, bare, walk) {
 * Array elements are matched by their indexed path (`users.0.password`) and by
 * the index-free path (`users.password`) that earlier versions used.
 */
-function walkArray(arr, state, fullPath, bare) {
+function walkArray(arr, state, fullPath, bare, depth) {
 	let result;
 	for (const [i, item] of arr.entries()) {
-		const next = walkValue(item, state, joinPath(fullPath, String(i)), bare);
+		const next = walkValue(item, state, joinPath(fullPath, String(i)), bare, depth);
 		if (next !== item && !result) result = arr.slice(0, i);
 		if (result) result.push(next);
 	}
 	return result ?? arr;
 }
-function walkRecord(obj, state, fullPath, bare) {
+function walkRecord(obj, state, fullPath, bare, depth) {
 	let result;
 	const entries = Object.entries(obj);
 	for (const [index, [key, value]] of entries.entries()) {
 		const forbidden = key === "__proto__" || key === "constructor" || key === "prototype";
-		const next = forbidden ? void 0 : walkValue(value, state, joinPath(fullPath, key), joinPath(bare, key));
+		const next = forbidden ? void 0 : walkValue(value, state, joinPath(fullPath, key), joinPath(bare, key), depth);
 		if ((forbidden || next !== value) && !result) result = Object.fromEntries(entries.slice(0, index));
 		if (result && !forbidden) result[key] = next;
 	}
 	return result ?? obj;
 }
+/** Errors are serialized (own props + cause chain) and the result is walked. */
+function walkError(err, state, fullPath, bare, depth) {
+	let serialized;
+	try {
+		serialized = serializeError(err);
+	} catch {
+		return {
+			name: err.name,
+			message: REDACTION_FAILED
+		};
+	}
+	const result = walkRecord(serialized, state, fullPath, bare, depth);
+	return result === serialized ? { ...serialized } : result;
+}
+/** Objects with `toJSON()` are redacted via the value they would serialize to. */
+function walkToJSON(obj, state, fullPath, bare, depth) {
+	let json;
+	try {
+		json = obj.toJSON();
+	} catch {
+		return REDACTION_FAILED;
+	}
+	if (json === obj) return walkRecord(obj, state, fullPath, bare, depth);
+	return walkValue(json, state, fullPath, bare, depth);
+}
 /**
 * Redact an object according to the given RedactConfig and return a new
 * top-level object. Subtrees with nothing to redact are shared with the input,
@@ -588,8 +697,9 @@ function walkRecord(obj, state, fullPath, bare) {
 function redactObject(obj, config, _currentPath = "") {
 	const result = walkRecord(obj, {
 		config,
-		ancestors: new Set([obj])
-	}, _currentPath, _currentPath);
+		ancestors: new Set([obj]),
+		nodes: 0
+	}, _currentPath, _currentPath, 0);
 	return result === obj ? { ...obj } : result;
 }
 /**
@@ -600,12 +710,11 @@ function redactObject(obj, config, _currentPath = "") {
 * stays allocation-free for the common no-redact case.
 */
 function applyRedactionToString(value, config) {
-	if (!config) return value;
+	const text = typeof value === "string" ? value : require_coerce_utils.safeToString(value);
+	if (!config) return text;
 	const resolved = resolveConfig(config);
-	if (!resolved.patterns || resolved.patterns.length === 0) return value;
-	let redacted = value;
-	for (const pattern of resolved.patterns) redacted = redacted.replace(pattern, resolved.censor ?? DEFAULT_CENSOR);
-	return redacted;
+	if (!resolved.patterns || resolved.patterns.length === 0) return text;
+	return applyPatterns(text, resolved.patterns, resolved.censor ?? DEFAULT_CENSOR);
 }
 /**
 * Apply redaction to a log payload (top-level call convenience wrapper).
@@ -645,11 +754,21 @@ const ALWAYS_EMIT_LEVELS = new Set([
 	"warn",
 	"fatal"
 ]);
+const MAX_CACHED_TRACE_ID_LENGTH = 256;
+function isCacheableTraceId(id) {
+	if (typeof id !== "string" || id.length === 0 || id.length > MAX_CACHED_TRACE_ID_LENGTH) return false;
+	for (let i = 0; i < id.length; i++) {
+		const c = id.charCodeAt(i);
+		if (c < 32 || c >= 127 && c <= 159) return false;
+	}
+	return true;
+}
 var Sampler = class {
 	constructor(config, onStats) {
 		this.traceDecisions = /* @__PURE__ */ new Map();
 		this.maxTrackedTraces = 1e5;
 		this.traceTtlMs = 5 * 6e4;
+		this.traceMaxLifetimeMs = 60 * 6e4;
 		this._tokenBucket = 0;
 		this._lastRefillMs = Date.now();
 		this._adaptiveWindow = [];
@@ -769,13 +888,15 @@ var Sampler = class {
 	}
 	/**
 	* Return the cached decision for a trace, or make and cache a new one. Entries
-	* idle past the TTL are re-decided; the least recently used entry is evicted
-	* once the cap is reached.
+	* idle past the TTL, or older than the hard lifetime, are re-decided; the least
+	* recently used entry is evicted once the cap is reached. IDs that are empty,
+	* too long or contain control characters are sampled independently and never cached.
 	*/
 	_decideForTrace(traceId, level) {
+		if (!isCacheableTraceId(traceId)) return this._sampleByRate(level);
 		const now = Date.now();
 		const known = this.traceDecisions.get(traceId);
-		if (known && now - known.seenAt <= this.traceTtlMs) {
+		if (known && now - known.seenAt <= this.traceTtlMs && now - known.firstAt <= this.traceMaxLifetimeMs) {
 			this.traceDecisions.delete(traceId);
 			known.seenAt = now;
 			this.traceDecisions.set(traceId, known);
@@ -785,6 +906,7 @@ var Sampler = class {
 		this.traceDecisions.delete(traceId);
 		this.traceDecisions.set(traceId, {
 			emit,
+			firstAt: now,
 			seenAt: now
 		});
 		if (this.traceDecisions.size > this.maxTrackedTraces) {
@@ -948,318 +1070,6 @@ function resetShutdownHandlers() {
 	shutdownInProgress = false;
 }
 
-//#endregion
-//#region node_modules/uuid/dist/esm-node/rng.js
-const rnds8Pool = new Uint8Array(256);
-let poolPtr = rnds8Pool.length;
-function rng() {
-	if (poolPtr > rnds8Pool.length - 16) {
-		crypto.default.randomFillSync(rnds8Pool);
-		poolPtr = 0;
-	}
-	return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-
-//#endregion
-//#region node_modules/uuid/dist/esm-node/stringify.js
-/**
-* Convert array of 16 byte values to UUID string format of the form:
-* XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
-*/
-const byteToHex = [];
-for (let i = 0; i < 256; ++i) byteToHex.push((i + 256).toString(16).slice(1));
-function unsafeStringify(arr, offset = 0) {
-	return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
-}
-
-//#endregion
-//#region node_modules/uuid/dist/esm-node/native.js
-var native_default = { randomUUID: crypto.default.randomUUID };
-
-//#endregion
-//#region node_modules/uuid/dist/esm-node/v4.js
-function v4(options, buf, offset) {
-	if (native_default.randomUUID && !buf && !options) return native_default.randomUUID();
-	options = options || {};
-	const rnds = options.random || (options.rng || rng)();
-	rnds[6] = rnds[6] & 15 | 64;
-	rnds[8] = rnds[8] & 63 | 128;
-	if (buf) {
-		offset = offset || 0;
-		for (let i = 0; i < 16; ++i) buf[offset + i] = rnds[i];
-		return buf;
-	}
-	return unsafeStringify(rnds);
-}
-var v4_default = v4;
-
-//#endregion
-//#region src/utils/trace.utils.ts
-/** Default key used to store the trace ID in AsyncLocalStorage. */
-const TRACE_CONTEXT_KEY = "traceId";
-/**
-* Singleton that owns the AsyncLocalStorage and the active contextKey.
-*
-* Why a class instead of bare module-level variables?
-*  - The contextKey is user-configurable; encapsulating it here means there is
-*    exactly one place that reads and writes it.
-*  - All helpers (getCurrentTraceId, runWithTraceId, etc.) delegate to this
-*    instance, so the key is always in sync without hidden global state.
-*  - Easier to test: you can reset the singleton between test cases.
-*
-* Usage (advanced):
-*   import { TraceContext } from 'logixia';
-*   TraceContext.instance.contextKey          // → 'traceId' (or custom)
-*   TraceContext.instance.getCurrentTraceId() // same as standalone fn
-*/
-var TraceContext = class TraceContext {
-	static #_ = this._instance = null;
-	constructor() {
-		this.storage = new node_async_hooks.AsyncLocalStorage();
-		this._contextKey = TRACE_CONTEXT_KEY;
-	}
-	/** The process-wide singleton. */
-	static get instance() {
-		if (!TraceContext._instance) TraceContext._instance = new TraceContext();
-		return TraceContext._instance;
-	}
-	/** @internal Reset the singleton (useful in tests). */
-	static _reset() {
-		TraceContext._instance = null;
-	}
-	/** The AsyncLocalStorage key that holds the trace ID value. */
-	get contextKey() {
-		return this._contextKey;
-	}
-	/** @internal Called by TraceMiddleware when it boots to register the user's key. */
-	setContextKey(key) {
-		this._contextKey = key;
-	}
-	/** UUID v4 generator (default). */
-	generate() {
-		return v4_default();
-	}
-	/** Read the trace ID from the current async context. */
-	getCurrentTraceId() {
-		var _this$storage$getStor;
-		return (_this$storage$getStor = this.storage.getStore()) === null || _this$storage$getStor === void 0 ? void 0 : _this$storage$getStor[this._contextKey];
-	}
-	/**
-	* Mutate the CURRENT async context in-place.
-	*
-	* ⚠️  DEPRECATED — unsafe for concurrent requests.
-	*
-	* Uses `AsyncLocalStorage.enterWith()`, which mutates the current async
-	* execution context and every Promise chain spawned from it. In a server
-	* processing overlapping requests this can cause a trace ID set for one
-	* request to bleed into *other* in-flight requests that share the same
-	* async parent (e.g. a module-level setup function or a cached handler).
-	*
-	* Use {@link run} instead — it scopes the context to a callback so there
-	* is no risk of cross-request leakage.
-	*
-	* @deprecated Use `TraceContext.instance.run(traceId, fn)` — do not call
-	*             `setTraceId` from request-handling code.
-	*/
-	setTraceId(traceId, data) {
-		const current = this.storage.getStore() ?? {};
-		this.storage.enterWith({
-			...current,
-			[this._contextKey]: traceId,
-			...data
-		});
-	}
-	/** Run `fn` inside a new async context that carries `traceId`. */
-	run(traceId, fn, data) {
-		return this.storage.run({
-			[this._contextKey]: traceId,
-			...data
-		}, fn);
-	}
-};
-/**
-* The shared AsyncLocalStorage instance.
-* @deprecated Prefer `TraceContext.instance.storage` for new code.
-*/
-const traceStorage = TraceContext.instance.storage;
-/** Returns the key currently used to store the trace ID in AsyncLocalStorage. */
-function getTraceContextKey() {
-	return TraceContext.instance.contextKey;
-}
-/** @internal Called by TraceMiddleware / traceMiddleware() when they boot. */
-function _setActiveContextKey(key) {
-	TraceContext.instance.setContextKey(key);
-}
-/** Generate a UUID v4 trace ID. */
-function generateTraceId() {
-	return TraceContext.instance.generate();
-}
-/**
-* Get the current trace ID from async context.
-* Returns `undefined` when called outside a traced request.
-*/
-function getCurrentTraceId() {
-	return TraceContext.instance.getCurrentTraceId();
-}
-/**
-* Set trace ID in the CURRENT async context without starting a new one.
-*
-* ⚠️  DEPRECATED — unsafe for concurrent requests.
-*
-* Uses `AsyncLocalStorage.enterWith()`, which mutates the current async
-* execution context and every Promise chain spawned from it. Under load this
-* can cause a trace ID from one request to bleed into others sharing the same
-* async parent.
-*
-* Use {@link runWithTraceId} instead. Migration patterns:
-*
-* **Express / Fastify middleware — before:**
-* ```ts
-* app.use((req, _res, next) => {
-*   setTraceId(req.headers['x-trace-id'] ?? generateTraceId());
-*   next();
-* });
-* ```
-* **after:**
-* ```ts
-* app.use((req, _res, next) => {
-*   runWithTraceId(req.headers['x-trace-id'] ?? generateTraceId(), () => next());
-* });
-* ```
-*
-* **Kafka / queue consumer — before:**
-* ```ts
-* async function handle(msg) {
-*   setTraceId(msg.headers['x-trace-id']);
-*   await processMessage(msg);
-* }
-* ```
-* **after:**
-* ```ts
-* async function handle(msg) {
-*   await runWithTraceId(msg.headers['x-trace-id'], () => processMessage(msg));
-* }
-* ```
-*
-* **Background job — before:**
-* ```ts
-* setTraceId(generateTraceId(), { jobId: job.id });
-* await job.run();
-* ```
-* **after:**
-* ```ts
-* await runWithTraceId(generateTraceId(), () => job.run(), { jobId: job.id });
-* ```
-*
-* @deprecated Use `runWithTraceId(traceId, fn)` — do not call `setTraceId`
-*             from request-handling code.
-*/
-function setTraceId(traceId, data) {
-	TraceContext.instance.setTraceId(traceId, data);
-}
-/** Run `fn` inside a new async context carrying `traceId`. */
-function runWithTraceId(traceId, fn, data) {
-	return TraceContext.instance.run(traceId, fn, data);
-}
-/**
-* Coerce an arbitrary value to a non-empty trace ID string, or `undefined`.
-* Rejects empty/whitespace-only strings, non-strings, and non-first array elements.
-*/
-function toValidTraceId(value) {
-	const first = Array.isArray(value) ? value[0] : value;
-	if (typeof first !== "string") return void 0;
-	const trimmed = first.trim();
-	return trimmed.length > 0 ? trimmed : void 0;
-}
-/** W3C trace-context: `version-traceId(32hex)-spanId(16hex)-flags(2hex)`. */
-const W3C_TRACEPARENT_RE = /^[\da-f]{2}-([\da-f]{32})-[\da-f]{16}-[\da-f]{2}$/i;
-/**
-* Extract the 32-hex trace-id segment from a W3C `traceparent` header value.
-* Returns the parsed trace ID, or the original value unchanged when it is not a
-* well-formed traceparent (so non-W3C propagation still works).
-*/
-function parseTraceparent(value) {
-	const m = W3C_TRACEPARENT_RE.exec(value);
-	return m ? m[1] : value;
-}
-/** Extract trace ID from request using configuration (header → query → body → params). */
-function extractTraceId(request, config) {
-	const req = request;
-	if (config.header) {
-		const headers = Array.isArray(config.header) ? config.header : [config.header];
-		for (const header of headers) {
-			var _req$headers;
-			const lower = header.toLowerCase();
-			const value = toValidTraceId((_req$headers = req.headers) === null || _req$headers === void 0 ? void 0 : _req$headers[lower]);
-			if (value) return lower === "traceparent" ? parseTraceparent(value) : value;
-		}
-	}
-	if (config.query) {
-		const queries = Array.isArray(config.query) ? config.query : [config.query];
-		for (const query of queries) {
-			var _req$query;
-			const value = toValidTraceId((_req$query = req.query) === null || _req$query === void 0 ? void 0 : _req$query[query]);
-			if (value) return value;
-		}
-	}
-	if (config.body) {
-		const bodyFields = Array.isArray(config.body) ? config.body : [config.body];
-		for (const field of bodyFields) {
-			var _req$body;
-			const value = toValidTraceId((_req$body = req.body) === null || _req$body === void 0 ? void 0 : _req$body[field]);
-			if (value) return value;
-		}
-	}
-	if (config.params) {
-		const paramFields = Array.isArray(config.params) ? config.params : [config.params];
-		for (const param of paramFields) {
-			var _req$params;
-			const value = toValidTraceId((_req$params = req.params) === null || _req$params === void 0 ? void 0 : _req$params[param]);
-			if (value) return value;
-		}
-	}
-}
-/**
-* Default headers checked for incoming trace ID propagation, in priority order:
-*   traceparent (W3C/OTel) → x-trace-id → x-request-id → x-correlation-id → trace-id
-*/
-const DEFAULT_TRACE_HEADERS = [
-	"traceparent",
-	"x-trace-id",
-	"x-request-id",
-	"x-correlation-id",
-	"trace-id"
-];
-/**
-* Create trace ID middleware for Express/NestJS
-*/
-function createTraceMiddleware(config) {
-	const defaultExtractor = {
-		header: DEFAULT_TRACE_HEADERS,
-		query: ["traceId", "trace_id"]
-	};
-	const resolvedConfig = {
-		...config,
-		extractor: (config === null || config === void 0 ? void 0 : config.extractor) ? {
-			...defaultExtractor,
-			...config.extractor
-		} : defaultExtractor
-	};
-	_setActiveContextKey(resolvedConfig.contextKey ?? TRACE_CONTEXT_KEY);
-	return (req, res, next) => {
-		let traceId;
-		if (resolvedConfig.extractor) traceId = extractTraceId(req, resolvedConfig.extractor);
-		if (!traceId) traceId = resolvedConfig.generator ? resolvedConfig.generator() : generateTraceId();
-		req.traceId = traceId;
-		const resObj = res;
-		if (!resObj.headersSent) try {
-			if (typeof resObj.setHeader === "function") resObj.setHeader("X-Trace-Id", traceId);
-			else if (typeof resObj.header === "function") resObj.header("X-Trace-Id", traceId);
-		} catch {}
-		runWithTraceId(traceId, () => next());
-	};
-}
-
 //#endregion
 //#region src/core/logitron-logger.ts
 const _fastStringifyEntry = (0, fast_json_stringify.default)({
@@ -1348,7 +1158,7 @@ var LogixiaLogger = class LogixiaLogger {
 		this.timers = /* @__PURE__ */ new Map();
 		this.contextData = {};
 		this.fieldState = /* @__PURE__ */ new Map();
-		this.fallbackTraceId = TraceContext.instance.generate();
+		this.fallbackTraceId = require_trace_utils.TraceContext.instance.generate();
 		this._levelValues = /* @__PURE__ */ new Map();
 		this._minLevelValue = 2;
 		this._warnedInvalidLevels = /* @__PURE__ */ new Set();
@@ -1799,7 +1609,7 @@ var LogixiaLogger = class LogixiaLogger {
 		if (this.config.silent) return;
 		if (!this.shouldLog(level)) return;
 		if (this._sampler) {
-			const traceId$1 = this.config.traceId ? TraceContext.instance.getCurrentTraceId() : void 0;
+			const traceId$1 = this.config.traceId ? require_trace_utils.TraceContext.instance.getCurrentTraceId() : void 0;
 			if (!this._sampler.shouldEmit(level, traceId$1)) return;
 		}
 		const alsContext = require_async_context.LogixiaContext.get();
@@ -1822,9 +1632,21 @@ var LogixiaLogger = class LogixiaLogger {
 			...mergedData
 		} : mergedData;
 		let payload;
-		if (rawPayload !== void 0 && rawPayload !== null) payload = this._hasRedact ? applyRedaction(rawPayload, this.config.redact) ?? rawPayload : rawPayload;
-		const traceId = this.config.traceId ? TraceContext.instance.getCurrentTraceId() ?? this.fallbackTraceId : void 0;
-		const safeMessage = this._hasRedact ? applyRedactionToString(message, this.config.redact) : message;
+		if (rawPayload !== void 0 && rawPayload !== null) if (this._hasRedact) try {
+			payload = applyRedaction(rawPayload, this.config.redact) ?? rawPayload;
+		} catch (error) {
+			require_internal_log.internalError("Redaction failed", error);
+			payload = { redaction: REDACTION_FAILED };
+		}
+		else payload = rawPayload;
+		const traceId = this.config.traceId ? require_trace_utils.TraceContext.instance.getCurrentTraceId() ?? this.fallbackTraceId : void 0;
+		let safeMessage = message;
+		if (this._hasRedact) try {
+			safeMessage = applyRedactionToString(message, this.config.redact);
+		} catch (error) {
+			require_internal_log.internalError("Redaction failed", error);
+			safeMessage = REDACTION_FAILED;
+		}
 		const entry = {
 			timestamp: nowIso(),
 			level,
@@ -1895,9 +1717,9 @@ var LogixiaLogger = class LogixiaLogger {
 		if (((_this$config$format4 = this.config.format) === null || _this$config$format4 === void 0 ? void 0 : _this$config$format4.timestamp) !== false && this._fieldCache.get("timestamp") !== false) formatted += `${gray}[${entry.timestamp}]${reset} `;
 		if (this._fieldCache.get("level") !== false) formatted += this._formattedLevels.get(entry.level) ?? `[${entry.level.toUpperCase()}] `;
 		formatted += this._formattedAppName;
-		if (entry.traceId && this._fieldCache.get("traceId") !== false) formatted += `${cyan}[${entry.traceId}]${reset} `;
-		if (entry.context && this._fieldCache.get("context") !== false) formatted += `${yellow}[${entry.context}]${reset} `;
-		if (this._fieldCache.get("message") !== false) formatted += entry.message;
+		if (entry.traceId && this._fieldCache.get("traceId") !== false) formatted += `${cyan}[${require_transport_manager.stripControlChars(String(entry.traceId))}]${reset} `;
+		if (entry.context && this._fieldCache.get("context") !== false) formatted += `${yellow}[${require_transport_manager.stripControlChars(String(entry.context))}]${reset} `;
+		if (this._fieldCache.get("message") !== false) formatted += require_transport_manager.stripControlChars(require_coerce_utils.safeToString(entry.message));
 		if (entry.payload !== void 0 && this._fieldCache.get("payload") !== false) formatted += ` ${require_safe_stringify.stringifyForLog(entry.payload)}`;
 		return formatted;
 	}
@@ -1947,723 +1769,241 @@ 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) => require_internal_log.internalError("LogixiaLoggerService.log failed", err));
-	}
-	/**
-	* Native async `info` — structured data, returns `Promise<void>`.
-	*
-	* @example `await logger.info('User signed up', { userId: 'u_abc' })`
-	*/
-	async info(message, data) {
-		return this.logger.info(message, data);
-	}
-	error(message, dataOrTrace, context) {
-		if (typeof dataOrTrace === "object" && dataOrTrace !== null) return message instanceof Error ? this.logger.error(message, dataOrTrace) : this.logger.error(this.formatMessage(message), dataOrTrace);
-		this.setContextIfProvided(context);
-		const errorData = {};
-		if (typeof dataOrTrace === "string" && dataOrTrace) errorData.stack = dataOrTrace;
-		(message instanceof Error ? this.logger.error(message, errorData) : this.logger.error(this.formatMessage(message), errorData)).catch((err) => require_internal_log.internalError("LogixiaLoggerService.error failed", err));
-	}
-	warn(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.warn(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.warn(this.formatMessage(message)).catch((err) => require_internal_log.internalError("LogixiaLoggerService.warn failed", err));
-	}
-	debug(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.debug(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.debug(this.formatMessage(message)).catch((err) => require_internal_log.internalError("LogixiaLoggerService.debug failed", err));
-	}
-	verbose(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.trace(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.trace(this.formatMessage(message)).catch((err) => require_internal_log.internalError("LogixiaLoggerService.verbose failed", err));
-	}
-	/**
-	* Native async `trace` — lowest verbosity level, structured data.
-	*/
-	async trace(message, data) {
-		return this.logger.trace(message, data);
-	}
-	/**
-	* Log at any named level with structured data.
-	*/
-	logLevel(level, message, data) {
-		return this.logger.logLevel(level, message, data);
-	}
-	time(label) {
-		this.logger.time(label);
-	}
-	async timeEnd(label) {
-		return this.logger.timeEnd(label);
-	}
-	async timeAsync(label, fn) {
-		return this.logger.timeAsync(label, fn);
-	}
-	setContext(context) {
-		const coerced = typeof context === "string" ? context : require_coerce_utils.safeToString(context);
-		this.context = coerced;
-		this.logger.setContext(coerced);
-	}
-	getContext() {
-		return this.context;
-	}
-	setLevel(level) {
-		this.logger.setLevel(level);
-	}
-	getLevel() {
-		return this.logger.getLevel();
-	}
-	child(context, data) {
-		const childService = new _LogixiaLoggerService(this._mergedConfig);
-		childService.logger = this.logger.child(context, data);
-		childService.context = context;
-		return childService;
-	}
-	getCurrentTraceId() {
-		return 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 require_coerce_utils.safeToString(message);
-	}
-};
-LogixiaLoggerService = _LogixiaLoggerService = __decorate([(0, __nestjs_common.Injectable)({ scope: __nestjs_common.Scope.TRANSIENT }), __decorateMetadata("design:paramtypes", [Object])], LogixiaLoggerService);
-
-//#endregion
-//#region src/core/kafka-trace.interceptor.ts
-var _KafkaTraceInterceptor;
-let KafkaTraceInterceptor = class KafkaTraceInterceptor$1 {
-	static {
-		_KafkaTraceInterceptor = this;
-	}
-	static #_ = this.metrics = {
-		accepted: 0,
-		acceptedWithoutTrace: 0,
-		dropped: 0
-	};
-	/** Reset counters (tests). */
-	static resetMetrics() {
-		_KafkaTraceInterceptor.metrics.accepted = 0;
-		_KafkaTraceInterceptor.metrics.acceptedWithoutTrace = 0;
-		_KafkaTraceInterceptor.metrics.dropped = 0;
-	}
-	/**
-	* @param config        - TraceIdConfig options (extractor keys, contextKey, etc.)
-	* @param requireTraceId - When true, messages with no traceId are silently skipped
-	*                         (EMPTY Observable — message is ack'd, consumer stays alive).
-	*                         A WARN is logged AND `KafkaTraceInterceptor.metrics.dropped`
-	*                         increments so the missing traceId is observable end-to-end.
-	*                         Default: false (handler runs without trace context).
-	*/
-	constructor(config, requireTraceId = false) {
-		this.config = config;
-		this.requireTraceId = requireTraceId;
-		this.ctx = TraceContext.instance;
-		this.config = {
-			enabled: true,
-			contextKey: "traceId",
-			extractor: {
-				body: [
-					"traceId",
-					"trace_id",
-					"x-trace-id"
-				],
-				header: ["x-trace-id", "trace-id"]
-			},
-			...config
-		};
-	}
-	intercept(context, next) {
-		var _this$config;
-		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next.handle();
-		const rpcContext = context.switchToRpc();
-		const data = rpcContext.getData();
-		const rpcData = rpcContext.getContext();
-		let traceId;
-		if (this.config.extractor) traceId = extractTraceId({
-			body: data,
-			headers: (rpcData === null || rpcData === void 0 ? void 0 : rpcData.headers) ?? {},
-			query: {},
-			params: {}
-		}, this.config.extractor);
-		if (!traceId) traceId = this.ctx.getCurrentTraceId();
-		if (!traceId) {
-			if (this.requireTraceId) {
-				var _LogixiaLoggerModule$;
-				_KafkaTraceInterceptor.metrics.dropped++;
-				(_LogixiaLoggerModule$ = LogixiaLoggerModule.getGlobalLogger()) === null || _LogixiaLoggerModule$ === void 0 || _LogixiaLoggerModule$.warn(`[KafkaTraceInterceptor] Missing traceId on topic "${rpcData === null || rpcData === void 0 ? void 0 : rpcData.topic}" — message skipped.`);
-				return rxjs.EMPTY;
-			}
-			_KafkaTraceInterceptor.metrics.acceptedWithoutTrace++;
-			return next.handle();
-		}
-		_KafkaTraceInterceptor.metrics.accepted++;
-		const kafkaContext = {
-			messageType: "kafka",
-			topic: rpcData === null || rpcData === void 0 ? void 0 : rpcData.topic,
-			partition: rpcData === null || rpcData === void 0 ? void 0 : rpcData.partition,
-			offset: rpcData === null || rpcData === void 0 ? void 0 : rpcData.offset,
-			key: rpcData === null || rpcData === void 0 ? void 0 : rpcData.key,
-			timestamp: rpcData === null || rpcData === void 0 ? void 0 : rpcData.timestamp
-		};
-		return new rxjs.Observable((subscriber) => {
-			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([(0, __nestjs_common.Injectable)(), __decorateMetadata("design:paramtypes", [Object, Boolean])], KafkaTraceInterceptor);
-
-//#endregion
-//#region \0@oxc-project+runtime@0.95.0/helpers/decorateParam.js
-function __decorateParam(paramIndex, decorator) {
-	return function(target, key) {
-		decorator(target, key, paramIndex);
-	};
+/**
+* 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
+/**
+* Generates a trace ID via the shared {@link TraceContext} generator.
+*
+* Delegates to `TraceContext.instance.generate()` so any custom generator
+* configured on `TraceIdConfig.generator` is respected — avoids the silent
+* "builder has its own UUID source" divergence this module had previously.
+*
+* @example `'550e8400-e29b-41d4-a716-446655440000'`
+*/
+function generateTraceId() {
+	return require_trace_utils.TraceContext.instance.generate();
+}
+/** @deprecated Use `generateTraceId` instead. */
+const generateRequestId = generateTraceId;
 /**
-* Resolve the response header name from config.
-* - `undefined`   → default `'X-Trace-Id'`
-* - `string`      → user's custom header
-* - `false`       → `null` (suppress entirely)
+* Maps an HTTP status code to a human-friendly error type string.
+* Used as a fallback when the exception is a generic `HttpException`.
 */
-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 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";
 }
 /**
-* 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.
+* Duck-type check for NestJS `HttpException`.
+* Avoids a hard import on `@nestjs/common` so the builder is usable outside NestJS.
 */
-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 isHttpException(value) {
+	return typeof value === "object" && value !== null && typeof value["getStatus"] === "function" && typeof value["getResponse"] === "function";
 }
-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 require_internal_log.internalWarn("TraceIdConfig.generator returned a non-string/empty value — using built-in generator.");
-		}
-		if (!traceId) traceId = this.ctx.generate();
-		req.traceId = traceId;
-		const header = resolveResponseHeader(this.config);
-		if (header) writeTraceHeader(res, header, traceId);
-		this.ctx.run(traceId, () => next(), {
-			method: req.method,
-			url: req.url,
-			userAgent: req.get("User-Agent"),
-			ip: req.ip || ((_req$socket = req.socket) === null || _req$socket === void 0 ? void 0 : _req$socket.remoteAddress) || ((_req$connection = req.connection) === null || _req$connection === void 0 ? void 0 : _req$connection.remoteAddress)
-		});
-	}
-};
-TraceMiddleware = __decorate([
-	(0, __nestjs_common.Injectable)(),
-	__decorateParam(0, (0, __nestjs_common.Optional)()),
-	__decorateMetadata("design:paramtypes", [Object])
-], TraceMiddleware);
-
-//#endregion
-//#region src/core/websocket-trace.interceptor.ts
-let WebSocketTraceInterceptor = class WebSocketTraceInterceptor$1 {
-	constructor(config) {
-		this.config = config;
-		this.ctx = TraceContext.instance;
-		this.config = {
-			enabled: true,
-			contextKey: "traceId",
-			extractor: {
-				body: [
-					"traceId",
-					"trace_id",
-					"x-trace-id"
-				],
-				header: ["x-trace-id", "trace-id"],
-				query: ["traceId", "trace_id"]
-			},
-			...config
-		};
-	}
-	intercept(context, next) {
-		var _this$config, _client$handshake3;
-		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next.handle();
-		const wsContext = context.switchToWs();
-		const data = wsContext.getData();
-		const client = wsContext.getClient();
-		let traceId;
-		if (this.config.extractor) {
-			var _client$handshake, _client$handshake2;
-			traceId = extractTraceId({
-				body: data,
-				headers: (client === null || client === void 0 || (_client$handshake = client.handshake) === null || _client$handshake === void 0 ? void 0 : _client$handshake.headers) || {},
-				query: (client === null || client === void 0 || (_client$handshake2 = client.handshake) === null || _client$handshake2 === void 0 ? void 0 : _client$handshake2.query) || {},
-				params: {}
-			}, this.config.extractor);
-		}
-		if (!traceId) traceId = this.ctx.getCurrentTraceId();
-		if (!traceId) return next.handle();
-		const wsContextData = {
-			messageType: "websocket",
-			event: data === null || data === void 0 ? void 0 : data.event,
-			socketId: client === null || client === void 0 ? void 0 : client.id,
-			rooms: (client === null || client === void 0 ? void 0 : client.rooms) ? Array.from(client.rooms) : [],
-			clientAddress: client === null || client === void 0 || (_client$handshake3 = client.handshake) === null || _client$handshake3 === void 0 ? void 0 : _client$handshake3.address
-		};
-		return new rxjs.Observable((observer) => {
-			let inner;
-			this.ctx.run(traceId, () => {
-				inner = next.handle().subscribe({
-					next: (value) => observer.next(value),
-					error: (err) => observer.error(err),
-					complete: () => observer.complete()
-				});
-			}, wsContextData);
-			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
-		});
-	}
-};
-WebSocketTraceInterceptor = __decorate([(0, __nestjs_common.Injectable)(), __decorateMetadata("design:paramtypes", [Object])], WebSocketTraceInterceptor);
-
-//#endregion
-//#region src/core/logitron-logger.module.ts
-var _LogixiaLoggerModule;
-const DEFAULT_ROUTES = [{
-	path: "*",
-	method: __nestjs_common.RequestMethod.ALL
-}];
-const LOGIXIA_LOGGER_CONFIG = "LOGIXIA_LOGGER_CONFIG";
-const LOGIXIA_TRACE_CONFIG = "TRACE_CONFIG";
-const LOGIXIA_LOGGER_PREFIX = "LOGIXIA_LOGGER_";
-let LogixiaLoggerModule = class LogixiaLoggerModule$1 {
-	static {
-		_LogixiaLoggerModule = this;
-	}
-	constructor() {
-		this.config = {};
-	}
-	static #_ = this.loggerConfig = {};
-	static #_2 = this._globalLogger = null;
+/**
+* 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) {
-			require_internal_log.internalWarn("LogixiaLoggerModule.forRoot() was called more than once — ignoring the second init. If this is intentional (e.g. in tests), call LogixiaLoggerModule._resetGlobalLogger() first.");
-			return;
-		}
-		_LogixiaLoggerModule._globalLogger = service;
-	}
-	/** @internal Clear the global logger. Tests only. */
-	static _resetGlobalLogger() {
-		_LogixiaLoggerModule._globalLogger = null;
-	}
-	/**
-	* Returns the global LogixiaLoggerService instance that was created when the
-	* module booted. Useful for logging outside of NestJS DI — utility functions,
-	* plain scripts, decorators — without injecting the service everywhere.
+	* @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 = require_trace_utils.TraceContext.instance.getCurrentTraceId() ?? rawTraceId;
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		const durationMs = startTime !== void 0 ? Date.now() - startTime : void 0;
+		if (isLogixiaException(exception)) {
+			const debug$1 = buildDebug(exception, service, durationMs, expose);
+			const errorBlock = {
+				type: exception.errorType,
+				code: exception.errorCode,
+				message: exception.message
+			};
+			if (exception.param !== void 0) errorBlock.param = exception.param;
+			if (exception.details !== void 0 && exception.details.length > 0) errorBlock.details = exception.details;
+			if (exception.docUrl !== void 0) errorBlock.doc_url = exception.docUrl;
+			return {
+				response: {
+					success: false,
+					error: errorBlock,
+					meta: {
+						...traceId !== void 0 ? { trace_id: traceId } : {},
+						timestamp,
+						path,
+						status: exception.httpStatus
 					},
-					inject: [LOGIXIA_LOGGER_CONFIG]
-				},
-				{
-					provide: KafkaTraceInterceptor,
-					useFactory: (traceConfig$1) => new KafkaTraceInterceptor(traceConfig$1),
-					inject: [LOGIXIA_TRACE_CONFIG]
+					...debug$1 !== void 0 ? { debug: debug$1 } : {}
 				},
-				{
-					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]
+					...debug$1 !== void 0 ? { debug: debug$1 } : {}
 				},
-				{
-					provide: KafkaTraceInterceptor,
-					useFactory: (traceConfig) => new KafkaTraceInterceptor(traceConfig),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				},
-				{
-					provide: WebSocketTraceInterceptor,
-					useFactory: (traceConfig) => new WebSocketTraceInterceptor(traceConfig),
-					inject: [LOGIXIA_TRACE_CONFIG]
-				}
-			],
-			exports: [
-				LogixiaLoggerService,
-				LOGIXIA_LOGGER_CONFIG,
-				KafkaTraceInterceptor,
-				WebSocketTraceInterceptor
-			],
-			global: true
-		};
-	}
-	/**
-	* Create feature-specific logger instances
-	*/
-	static forFeature(context) {
-		const providerToken = `${LOGIXIA_LOGGER_PREFIX}${context.toUpperCase()}`;
+				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([(0, __nestjs_common.Module)({})], LogixiaLoggerModule);
 
 //#endregion
-Object.defineProperty(exports, 'DEFAULT_LOG_COLORS', {
-  enumerable: true,
-  get: function () {
-    return DEFAULT_LOG_COLORS;
-  }
-});
-Object.defineProperty(exports, 'DEFAULT_LOG_LEVELS', {
+Object.defineProperty(exports, 'DEFAULT_CONFIG', {
   enumerable: true,
   get: function () {
-    return DEFAULT_LOG_LEVELS;
+    return DEFAULT_CONFIG;
   }
 });
-Object.defineProperty(exports, 'DEFAULT_TRACE_HEADERS', {
-  enumerable: true,
-  get: function () {
-    return DEFAULT_TRACE_HEADERS;
-  }
-});
-Object.defineProperty(exports, 'KafkaTraceInterceptor', {
-  enumerable: true,
-  get: function () {
-    return KafkaTraceInterceptor;
-  }
-});
-Object.defineProperty(exports, 'LOGIXIA_LOGGER_CONFIG', {
+Object.defineProperty(exports, 'DEFAULT_LOG_COLORS', {
   enumerable: true,
   get: function () {
-    return LOGIXIA_LOGGER_CONFIG;
+    return DEFAULT_LOG_COLORS;
   }
 });
-Object.defineProperty(exports, 'LOGIXIA_LOGGER_PREFIX', {
+Object.defineProperty(exports, 'DEFAULT_LOG_LEVELS', {
   enumerable: true,
   get: function () {
-    return LOGIXIA_LOGGER_PREFIX;
+    return DEFAULT_LOG_LEVELS;
   }
 });
-Object.defineProperty(exports, 'LOGIXIA_TRACE_CONFIG', {
+Object.defineProperty(exports, 'ErrorResponseBuilder', {
   enumerable: true,
   get: function () {
-    return LOGIXIA_TRACE_CONFIG;
+    return ErrorResponseBuilder;
   }
 });
 Object.defineProperty(exports, 'LogLevel', {
@@ -2672,22 +2012,16 @@ Object.defineProperty(exports, 'LogLevel', {
     return LogLevel;
   }
 });
-Object.defineProperty(exports, 'LogixiaLogger', {
-  enumerable: true,
-  get: function () {
-    return LogixiaLogger;
-  }
-});
-Object.defineProperty(exports, 'LogixiaLoggerModule', {
+Object.defineProperty(exports, 'LogixiaException', {
   enumerable: true,
   get: function () {
-    return LogixiaLoggerModule;
+    return LogixiaException;
   }
 });
-Object.defineProperty(exports, 'LogixiaLoggerService', {
+Object.defineProperty(exports, 'LogixiaLogger', {
   enumerable: true,
   get: function () {
-    return LogixiaLoggerService;
+    return LogixiaLogger;
   }
 });
 Object.defineProperty(exports, 'PluginRegistry', {
@@ -2696,54 +2030,6 @@ Object.defineProperty(exports, 'PluginRegistry', {
     return PluginRegistry;
   }
 });
-Object.defineProperty(exports, 'TRACE_CONTEXT_KEY', {
-  enumerable: true,
-  get: function () {
-    return TRACE_CONTEXT_KEY;
-  }
-});
-Object.defineProperty(exports, 'TraceContext', {
-  enumerable: true,
-  get: function () {
-    return TraceContext;
-  }
-});
-Object.defineProperty(exports, 'TraceMiddleware', {
-  enumerable: true,
-  get: function () {
-    return TraceMiddleware;
-  }
-});
-Object.defineProperty(exports, 'WebSocketTraceInterceptor', {
-  enumerable: true,
-  get: function () {
-    return WebSocketTraceInterceptor;
-  }
-});
-Object.defineProperty(exports, '__decorate', {
-  enumerable: true,
-  get: function () {
-    return __decorate;
-  }
-});
-Object.defineProperty(exports, '__decorateMetadata', {
-  enumerable: true,
-  get: function () {
-    return __decorateMetadata;
-  }
-});
-Object.defineProperty(exports, '__decorateParam', {
-  enumerable: true,
-  get: function () {
-    return __decorateParam;
-  }
-});
-Object.defineProperty(exports, '_setActiveContextKey', {
-  enumerable: true,
-  get: function () {
-    return _setActiveContextKey;
-  }
-});
 Object.defineProperty(exports, '_shutdownRegistrySize', {
   enumerable: true,
   get: function () {
@@ -2762,12 +2048,6 @@ Object.defineProperty(exports, 'createLogger', {
     return createLogger;
   }
 });
-Object.defineProperty(exports, 'createTraceMiddleware', {
-  enumerable: true,
-  get: function () {
-    return createTraceMiddleware;
-  }
-});
 Object.defineProperty(exports, 'deregisterFromShutdown', {
   enumerable: true,
   get: function () {
@@ -2780,40 +2060,34 @@ Object.defineProperty(exports, 'disableOtelBridge', {
     return disableOtelBridge;
   }
 });
-Object.defineProperty(exports, 'extractTraceId', {
-  enumerable: true,
-  get: function () {
-    return extractTraceId;
-  }
-});
 Object.defineProperty(exports, 'flushOnExit', {
   enumerable: true,
   get: function () {
     return flushOnExit;
   }
 });
-Object.defineProperty(exports, 'getActiveOtelContext', {
+Object.defineProperty(exports, 'generateRequestId', {
   enumerable: true,
   get: function () {
-    return getActiveOtelContext;
+    return generateRequestId;
   }
 });
-Object.defineProperty(exports, 'getCurrentTraceId', {
+Object.defineProperty(exports, 'generateTraceId', {
   enumerable: true,
   get: function () {
-    return getCurrentTraceId;
+    return generateTraceId;
   }
 });
-Object.defineProperty(exports, 'getOtelMetaFields', {
+Object.defineProperty(exports, 'getActiveOtelContext', {
   enumerable: true,
   get: function () {
-    return getOtelMetaFields;
+    return getActiveOtelContext;
   }
 });
-Object.defineProperty(exports, 'getTraceContextKey', {
+Object.defineProperty(exports, 'getOtelMetaFields', {
   enumerable: true,
   get: function () {
-    return getTraceContextKey;
+    return getOtelMetaFields;
   }
 });
 Object.defineProperty(exports, 'globalPluginRegistry', {
@@ -2834,6 +2108,12 @@ Object.defineProperty(exports, 'isError', {
     return isError;
   }
 });
+Object.defineProperty(exports, 'isLogixiaException', {
+  enumerable: true,
+  get: function () {
+    return isLogixiaException;
+  }
+});
 Object.defineProperty(exports, 'normalizeError', {
   enumerable: true,
   get: function () {
@@ -2858,40 +2138,16 @@ Object.defineProperty(exports, 'resetShutdownHandlers', {
     return resetShutdownHandlers;
   }
 });
-Object.defineProperty(exports, 'resolveResponseHeader', {
-  enumerable: true,
-  get: function () {
-    return resolveResponseHeader;
-  }
-});
-Object.defineProperty(exports, 'runWithTraceId', {
-  enumerable: true,
-  get: function () {
-    return runWithTraceId;
-  }
-});
 Object.defineProperty(exports, 'serializeError', {
   enumerable: true,
   get: function () {
     return serializeError;
   }
 });
-Object.defineProperty(exports, 'setTraceId', {
-  enumerable: true,
-  get: function () {
-    return setTraceId;
-  }
-});
-Object.defineProperty(exports, 'traceStorage', {
-  enumerable: true,
-  get: function () {
-    return traceStorage;
-  }
-});
 Object.defineProperty(exports, 'usePlugin', {
   enumerable: true,
   get: function () {
     return usePlugin;
   }
 });
-//# sourceMappingURL=logitron-logger.module-BsDZR5BH.js.map
+//# sourceMappingURL=builder-D44QktIo.js.map