logixia 2.0.10 → 2.1.0

package/dist/{builder-BLIStsCK.js → builder-jMlVYaQa.js}

@@ -1,11 +1,12 @@
-const require_secret_config = require("./secret-config-BvFl2dC8.js");
-const require_sensitive_names = require("./sensitive-names-CHMowujD.js");
-const require_request_trace = require("./request-trace-ByujsUZk.js");
-const require_async_context = require("./async-context-Dv0bmPC-.js");
+const require_secret_config = require("./secret-config--cVTOWwp.js");
+const require_own_property = require("./own-property-BWkibepN.js");
+const require_request_trace = require("./request-trace-C7kXMjx5.js");
+const require_async_context = require("./async-context-Dgl3ZLyb.js");
+const require_sensitive_names = require("./sensitive-names-NiKIRhp5.js");
 const require_internal_log = require("./internal-log-DwqTjhpb.js");
-const require_coerce_utils = require("./coerce.utils-C1C5sIX0.js");
-const require_safe_stringify = require("./safe-stringify-CN7icp8S.js");
-const require_otel = require("./otel-ChnVYRLA.js");
+const require_safe_stringify = require("./safe-stringify-J3sh-7YM.js");
+const require_csv_utils = require("./csv.utils-CbVHY1pd.js");
+const require_otel = require("./otel-8ypFGG19.js");
 let node_os = require("node:os");
 // src/types/index.ts
 const LogLevel = {
@@ -83,9 +84,7 @@ const DEFAULT_CONFIG = {
 * singleton is also exported for process-wide registration.
 */
 var PluginRegistry = class {
-	constructor() {
-		this._plugins = [];
-	}
+	_plugins = [];
 	/**
 	* Register a plugin. Silently skips if a plugin with the same `name` is
 	* already registered on this registry.
@@ -245,9 +244,9 @@ function _serializeError(error, includeStack, maxDepth, excludeFields, depth, se
 	for (const key of Object.getOwnPropertyNames(error)) {
 		if (skip.has(key)) continue;
 		try {
-			require_sensitive_names.assignOwn(serialized, key, serializeValue(errorRecord[key], maxDepth - depth - 1, seen));
+			require_own_property.assignOwn(serialized, key, serializeValue(errorRecord[key], maxDepth - depth - 1, seen));
 		} catch {
-			require_sensitive_names.assignOwn(serialized, key, "[Unserializable]");
+			require_own_property.assignOwn(serialized, key, "[Unserializable]");
 		}
 	}
 	return serialized;
@@ -283,9 +282,9 @@ function serializeValue(value, remainingDepth, seen) {
 		seen.add(value);
 		const out = {};
 		for (const [k, v] of Object.entries(value)) try {
-			require_sensitive_names.assignOwn(out, k, serializeValue(v, remainingDepth - 1, seen));
+			require_own_property.assignOwn(out, k, serializeValue(v, remainingDepth - 1, seen));
 		} catch {
-			require_sensitive_names.assignOwn(out, k, "[Unserializable]");
+			require_own_property.assignOwn(out, k, "[Unserializable]");
 		}
 		return out;
 	}
@@ -346,7 +345,7 @@ function walkForErrors(value, depth, parent, grandparent) {
 			const next = walkForErrors(item, depth - 1, record, parent);
 			if (next !== item) {
 				copy ??= { ...record };
-				require_sensitive_names.assignOwn(copy, key, next);
+				require_own_property.assignOwn(copy, key, next);
 			}
 		}
 	}
@@ -517,6 +516,35 @@ const CIRCULAR = "[Circular]";
 function joinPath(parent, key) {
 	return parent ? `${parent}.${key}` : key;
 }
+const CORRELATION_ID_KEYS = /* @__PURE__ */ new Set([
+	"traceid",
+	"spanid",
+	"parentspanid",
+	"requestid",
+	"correlationid",
+	"traceparent",
+	"xrequestid",
+	"xcorrelationid",
+	"xtraceid",
+	"xamzntraceid"
+]);
+const ID_SHAPED = /^[\w.:;=-]{1,256}$/;
+const DEFAULT_QUERY_NAMES = require_sensitive_names.buildNameSet(require_sensitive_names.DEFAULT_REDACT_QUERY_PARAMS, void 0);
+const queryNameSets = /* @__PURE__ */ new WeakMap();
+function queryNamesOf(config) {
+	const extra = config.queryParams;
+	if (!extra || extra.length === 0) return DEFAULT_QUERY_NAMES;
+	let names = queryNameSets.get(extra);
+	if (!names) {
+		names = require_sensitive_names.buildNameSet(require_sensitive_names.DEFAULT_REDACT_QUERY_PARAMS, extra);
+		queryNameSets.set(extra, names);
+	}
+	return names;
+}
+function isCorrelationId(fullPath, value) {
+	const key = fullPath.slice(fullPath.lastIndexOf(".") + 1);
+	return CORRELATION_ID_KEYS.has(key.toLowerCase().replace(/[-_]/g, "")) && ID_SHAPED.test(value);
+}
 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;
@@ -526,8 +554,9 @@ function walkValue(value, state, fullPath, bare, depth) {
 	}
 	if (typeof value === "string") {
 		if (patterns.length === 0) return value;
+		if (isCorrelationId(fullPath, value)) return value;
 		if (excludePaths.some((p) => matchesPath(fullPath, p) || matchesPath(bare, p))) return value;
-		return applyPatterns(value, patterns, censor);
+		return applyPatterns(value.includes("?") ? require_sensitive_names.redactUrlsInText(value, queryNamesOf(state.config)) : value, patterns, censor);
 	}
 	if (Array.isArray(value)) return walkContainer(value, state, fullPath, bare, depth, walkArray);
 	if (value instanceof Error) return walkContainer(value, state, fullPath, bare, depth, walkError);
@@ -535,7 +564,7 @@ function walkValue(value, state, fullPath, bare, depth) {
 		const url = new URL(value.href);
 		url.username = "";
 		url.password = "";
-		const redacted = walkValue(url.href, state, fullPath, bare, depth);
+		const redacted = walkValue(require_sensitive_names.redactUrlQuery(url.href, queryNamesOf(state.config)), 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);
@@ -569,7 +598,7 @@ function walkRecord(obj, state, fullPath, bare, depth) {
 	for (const [index, [key, value]] of entries.entries()) {
 		const next = walkValue(value, state, joinPath(fullPath, key), joinPath(bare, key), depth);
 		if (next !== value && !result) result = Object.fromEntries(entries.slice(0, index));
-		if (result) require_sensitive_names.assignOwn(result, key, next);
+		if (result) require_own_property.assignOwn(result, key, next);
 	}
 	return result ?? obj;
 }
@@ -611,15 +640,28 @@ function redactObject(obj, config, _currentPath = "") {
 	}, _currentPath, _currentPath, 0);
 	return result === obj ? { ...obj } : result;
 }
+function redactMessageObject(value, config) {
+	if (!Array.isArray(value)) return applyRedaction(value, config);
+	return value.map((item) => {
+		var _applyRedaction;
+		if (typeof item === "string") return applyRedactionToString(item, config);
+		if (item === null || typeof item !== "object") return item;
+		if (!Array.isArray(item)) return applyRedaction(item, config);
+		return (_applyRedaction = applyRedaction({ items: item }, config)) === null || _applyRedaction === void 0 ? void 0 : _applyRedaction["items"];
+	});
+}
 /**
-* Apply pattern-based redaction to a single string (e.g. the log message).
+* Apply redaction to the log message and return it as a string.
 *
-* Path-based rules don't apply to a bare string — only the `patterns` are run.
+* A string message gets only the `patterns`, because path rules don't apply to a
+* bare string. An object logged as the message (`logger.log(dto)` in NestJS) gets
+* every rule, as a payload would, before it is turned into a string.
 * Returns the input unchanged when no patterns are configured, so the hot path
 * stays allocation-free for the common no-redact case.
 */
 function applyRedactionToString(value, config) {
-	const text = typeof value === "string" ? value : require_coerce_utils.safeToString(value);
+	if (config && value !== null && typeof value === "object") return require_csv_utils.safeToString(redactMessageObject(value, config));
+	const text = typeof value === "string" ? value : require_csv_utils.safeToString(value);
 	if (!config) return text;
 	const resolved = resolveConfig(config);
 	if (!resolved.patterns || resolved.patterns.length === 0) return text;
@@ -670,25 +712,54 @@ function isCacheableTraceId(id) {
 	}
 	return true;
 }
+/** Maps a trace id to a stable number in [0, 1): FNV-1a followed by a murmur3 finalizer. */
+function traceFraction(id) {
+	let h = 2166136261;
+	for (let i = 0; i < id.length; i++) {
+		h ^= id.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	h ^= h >>> 16;
+	h = Math.imul(h, 2246822507);
+	h ^= h >>> 13;
+	h = Math.imul(h, 3266489909);
+	h ^= h >>> 16;
+	return (h >>> 0) / 4294967296;
+}
+const ADAPTIVE_BUCKETS = 100;
 var Sampler = class {
+	config;
+	/**
+	* Per-trace sampling fractions in LRU order (Map preserves insertion order; a
+	* hit re-inserts the key). A trace is kept at a level when its fraction is below
+	* that level's rate, so it is never fixed by the first level seen. Survives
+	* resetStats() so a long trace is not re-evaluated mid-flight. Bounded by size, by an idle TTL (refreshed on hit) and by a hard
+	* lifetime measured from the first decision.
+	*/
+	traceDecisions = /* @__PURE__ */ new Map();
+	maxTrackedTraces = 1e5;
+	traceTtlMs = 3e5;
+	traceMaxLifetimeMs = 36e5;
+	_tokenBucket = 0;
+	_lastRefillMs = Date.now();
+	_adaptiveBucketMs;
+	_adaptiveTotals = new Float64Array(ADAPTIVE_BUCKETS);
+	_adaptiveErrorCounts = new Float64Array(ADAPTIVE_BUCKETS);
+	_adaptiveBucket = 0;
+	_adaptiveTotal = 0;
+	_adaptiveErrors = 0;
+	_stats = {
+		evaluated: 0,
+		emitted: 0,
+		dropped: 0,
+		byLevel: {},
+		windowStart: Date.now()
+	};
+	_statsTimer;
 	constructor(config, onStats) {
-		this.traceDecisions = /* @__PURE__ */ new Map();
-		this.maxTrackedTraces = 1e5;
-		this.traceTtlMs = 3e5;
-		this.traceMaxLifetimeMs = 36e5;
-		this._tokenBucket = 0;
-		this._lastRefillMs = Date.now();
-		this._adaptiveWindow = [];
-		this._adaptiveHead = 0;
-		this._adaptiveErrors = 0;
-		this._stats = {
-			evaluated: 0,
-			emitted: 0,
-			dropped: 0,
-			byLevel: {},
-			windowStart: Date.now()
-		};
+		var _config$adaptive;
 		this.config = config;
+		this._adaptiveBucketMs = Math.max(1, Math.ceil((((_config$adaptive = config.adaptive) === null || _config$adaptive === void 0 ? void 0 : _config$adaptive.windowMs) ?? 1e4) / ADAPTIVE_BUCKETS));
 		if (config.maxLogsPerSecond && config.maxLogsPerSecond > 0) this._tokenBucket = config.maxLogsPerSecond;
 		const interval = config.statsIntervalMs ?? 6e4;
 		if (interval > 0 && onStats) {
@@ -746,34 +817,38 @@ var Sampler = class {
 	destroy() {
 		if (this._statsTimer) clearInterval(this._statsTimer);
 	}
-	_sampleByRate(level) {
+	_sampleByRate(level, fraction) {
 		var _this$config$perLevel2, _this$config$perLevel3;
 		const baseRate = ((_this$config$perLevel2 = this.config.perLevel) === null || _this$config$perLevel2 === void 0 ? void 0 : _this$config$perLevel2[level]) ?? ((_this$config$perLevel3 = this.config.perLevel) === null || _this$config$perLevel3 === void 0 ? void 0 : _this$config$perLevel3["*"]) ?? this.config.rate ?? 1;
 		const rate = Math.max(baseRate, this._adaptiveBoostRate());
 		if (rate >= 1) return true;
 		if (rate <= 0) return false;
+		if (fraction !== void 0) return fraction < rate;
 		return Math.random() < rate;
 	}
-	/** Record one evaluated sample and evict entries older than the window. O(1) amortized. */
-	_recordAdaptiveSample(level) {
-		var _this$config$adaptive;
-		const now = Date.now();
-		const windowMs = ((_this$config$adaptive = this.config.adaptive) === null || _this$config$adaptive === void 0 ? void 0 : _this$config$adaptive.windowMs) ?? 1e4;
-		const err = level === "error" || level === "fatal";
-		this._adaptiveWindow.push({
-			t: now,
-			err
-		});
-		if (err) this._adaptiveErrors += 1;
-		const cutoff = now - windowMs;
-		const win = this._adaptiveWindow;
-		while (this._adaptiveHead < win.length && win[this._adaptiveHead].t < cutoff) {
-			if (win[this._adaptiveHead].err) this._adaptiveErrors -= 1;
-			this._adaptiveHead += 1;
+	/** Moves the ring forward to the bucket holding `now`, dropping buckets that left the window. */
+	_advanceAdaptive(now) {
+		const target = Math.floor(now / this._adaptiveBucketMs);
+		if (target <= this._adaptiveBucket) return this._adaptiveBucket;
+		const steps = Math.min(target - this._adaptiveBucket, ADAPTIVE_BUCKETS);
+		for (let i = 1; i <= steps; i++) {
+			const slot = (this._adaptiveBucket + i) % ADAPTIVE_BUCKETS;
+			this._adaptiveTotal -= this._adaptiveTotals[slot];
+			this._adaptiveErrors -= this._adaptiveErrorCounts[slot];
+			this._adaptiveTotals[slot] = 0;
+			this._adaptiveErrorCounts[slot] = 0;
 		}
-		if (this._adaptiveHead >= 1024 && this._adaptiveHead * 2 >= win.length) {
-			this._adaptiveWindow = win.slice(this._adaptiveHead);
-			this._adaptiveHead = 0;
+		this._adaptiveBucket = target;
+		return target;
+	}
+	/** Record one evaluated sample in the current bucket. O(1). */
+	_recordAdaptiveSample(level) {
+		const slot = this._advanceAdaptive(Date.now()) % ADAPTIVE_BUCKETS;
+		this._adaptiveTotals[slot] += 1;
+		this._adaptiveTotal += 1;
+		if (level === "error" || level === "fatal") {
+			this._adaptiveErrorCounts[slot] += 1;
+			this._adaptiveErrors += 1;
 		}
 	}
 	/**
@@ -784,8 +859,9 @@ var Sampler = class {
 	_adaptiveBoostRate() {
 		const cfg = this.config.adaptive;
 		if (!cfg) return 0;
+		this._advanceAdaptive(Date.now());
 		const minSamples = cfg.minSamples ?? 20;
-		const total = this._adaptiveWindow.length - this._adaptiveHead;
+		const total = this._adaptiveTotal;
 		if (total < minSamples) return 0;
 		return this._adaptiveErrors / total >= (cfg.errorRateThreshold ?? .05) ? cfg.boostRate ?? 1 : 0;
 	}
@@ -794,8 +870,9 @@ var Sampler = class {
 		return this._adaptiveBoostRate() > 0;
 	}
 	/**
-	* Return the cached decision for a trace, or make and cache a new one. Entries
-	* idle past the TTL, or older than the hard lifetime, are re-decided; the least
+	* Decide a trace by comparing its stable fraction with the level's rate, caching
+	* the fraction. Entries idle past the TTL, or older than the hard lifetime, are
+	* recomputed; 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.
 	*/
@@ -807,12 +884,12 @@ var Sampler = class {
 			this.traceDecisions.delete(traceId);
 			known.seenAt = now;
 			this.traceDecisions.set(traceId, known);
-			return known.emit;
+			return this._sampleByRate(level, known.fraction);
 		}
-		const emit = this._sampleByRate(level);
+		const fraction = traceFraction(traceId);
 		this.traceDecisions.delete(traceId);
 		this.traceDecisions.set(traceId, {
-			emit,
+			fraction,
 			firstAt: now,
 			seenAt: now
 		});
@@ -820,7 +897,7 @@ var Sampler = class {
 			const oldest = this.traceDecisions.keys().next().value;
 			if (oldest !== void 0) this.traceDecisions.delete(oldest);
 		}
-		return emit;
+		return this._sampleByRate(level, fraction);
 	}
 	_consumeToken() {
 		const now = Date.now();
@@ -897,7 +974,8 @@ function deregisterFromShutdown(logger) {
 * the process exits. Idempotent — the first call wins and later calls with
 * conflicting options print a warning. The process is ended with 128 + signal
 * number only when logixia's handler is the sole listener for that signal (see
-* `exit`); otherwise it just flushes and leaves shutdown to the application.
+* `exit`), closing the loggers first; otherwise it only flushes them and leaves
+* shutdown to the application.
 * Loggers are also flushed (not closed) on `beforeExit`.
 *
 * @example
@@ -924,7 +1002,8 @@ function flushOnExit(options = {}) {
 		}, timeout).unref() : void 0;
 		try {
 			if (beforeFlush) await beforeFlush();
-			await Promise.allSettled([...registry].map((logger) => logger.close()));
+			const ownsExit = shouldExit(signal);
+			await Promise.allSettled([...registry].map((logger) => ownsExit || !logger.flush ? logger.close() : logger.flush()));
 			if (afterFlush) await afterFlush();
 		} catch (err) {
 			process.stderr.write(`[logixia] Shutdown hook failed: ${String(err)}\n`);
@@ -1045,6 +1124,7 @@ function nowIso() {
 	return _tsCacheStr;
 }
 const RESOLVED = Promise.resolve();
+const UNSERIALIZABLE = "[Unserializable]";
 const JSON_STRING_FIELDS = [
 	"timestamp",
 	"level",
@@ -1079,7 +1159,22 @@ function toJsonEntry(entry) {
 }
 function toContextLabel(context) {
 	if (context === void 0 || context === null) return "";
-	return typeof context === "string" ? context : require_coerce_utils.safeToString(context);
+	return typeof context === "string" ? context : require_csv_utils.safeToString(context);
+}
+function serializeErrorSafely(error) {
+	try {
+		return serializeError(error);
+	} catch (cause) {
+		require_internal_log.internalError("Error serialization failed", cause);
+		return UNSERIALIZABLE;
+	}
+}
+function errorMessageSafely(error) {
+	try {
+		return require_csv_utils.safeToString(error.message);
+	} catch {
+		return UNSERIALIZABLE;
+	}
 }
 function namespacePatternToRegex(pattern) {
 	const escaped = pattern.split(".").map((s) => s === "*" ? "[^.]+" : s.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&")).join("\\.");
@@ -1149,26 +1244,58 @@ function resolveInitialLevel(config) {
 * ```
 */
 var LogixiaLogger = class LogixiaLogger {
+	config;
+	context;
+	timers = /* @__PURE__ */ new Map();
+	contextData = {};
+	transportManager;
+	fieldState = /* @__PURE__ */ new Map();
+	/** Stable fallback trace ID generated ONCE per logger instance. */
+	fallbackTraceId = require_request_trace.TraceContext.instance.generate();
+	/** Numeric value for each known log level — built once, read on every log call. */
+	_levelValues = /* @__PURE__ */ new Map();
+	/** Numeric threshold for the currently active log level. */
+	_minLevelValue = 2;
+	/** Level set via setLevel(); outranks every other level source until the process ends. */
+	_runtimeLevel;
+	/** `source=value` pairs already reported as unknown levels — warn once per logger. */
+	_warnedInvalidLevels = /* @__PURE__ */ new Set();
+	/** Pre-built ANSI color codes to avoid recreating the object in colorize(). */
+	_colorMap = /* @__PURE__ */ new Map();
+	/** Pre-computed field-enabled booleans so isFieldEnabled() isn't called per log. */
+	_fieldCache = /* @__PURE__ */ new Map();
+	/** True when contextData is non-empty — avoids Object.keys() check on hot path. */
+	_hasContextData = false;
+	/**
+	* Pre-computed `[INFO] `, `[WARN] ` etc. strings — avoids a colorize() call per log.
+	* Key: lowercase level name. Value: formatted bracket string ready to concatenate.
+	*/
+	_formattedLevels = /* @__PURE__ */ new Map();
+	/** Pre-computed `[appName] ` string — avoids template literal allocation per log. */
+	_formattedAppName = "";
+	/**
+	* JSON line pieces between the timestamp and the message, keyed by level, for the
+	* appName and environment they were built from. Rebuilt when either changes.
+	*/
+	_jsonHeads = /* @__PURE__ */ new Map();
+	_jsonHeadsApp = "";
+	_jsonHeadsEnv = "";
+	/** The `,"context":"..."` piece for `_jsonContextKey`. */
+	_jsonContextKey = void 0;
+	_jsonContext = "";
+	/** True when a redact config is present — short-circuits applyRedaction when false. */
+	_hasRedact = false;
+	/** Sampling engine — only created when sampling config is present. */
+	_sampler;
+	/** Per-instance plugin registry — also inherits from the global registry at creation time. */
+	_pluginRegistry;
+	/** Set on loggers created by child(); they borrow the root's transports, sampler and plugins. */
+	_parent;
+	/** Namespace level map shared by a logger and all its children; `version` bumps on every change. */
+	_nsStore;
+	/** Store version this logger's threshold was last computed against. */
+	_nsSeenVersion = 0;
 	constructor(config, context, parent) {
-		this.timers = /* @__PURE__ */ new Map();
-		this.contextData = {};
-		this.fieldState = /* @__PURE__ */ new Map();
-		this.fallbackTraceId = require_request_trace.TraceContext.instance.generate();
-		this._levelValues = /* @__PURE__ */ new Map();
-		this._minLevelValue = 2;
-		this._warnedInvalidLevels = /* @__PURE__ */ new Set();
-		this._colorMap = /* @__PURE__ */ new Map();
-		this._fieldCache = /* @__PURE__ */ new Map();
-		this._hasContextData = false;
-		this._formattedLevels = /* @__PURE__ */ new Map();
-		this._formattedAppName = "";
-		this._jsonHeads = /* @__PURE__ */ new Map();
-		this._jsonHeadsApp = "";
-		this._jsonHeadsEnv = "";
-		this._jsonContextKey = void 0;
-		this._jsonContext = "";
-		this._hasRedact = false;
-		this._nsSeenVersion = 0;
 		this._parent = parent;
 		this._nsStore = parent ? parent._nsStore : {
 			levels: { ...config.namespaceLevels },
@@ -1264,19 +1391,25 @@ var LogixiaLogger = class LogixiaLogger {
 		});
 	}
 	createCustomLevelMethods() {
-		var _this$config$levelOpt3, _this$config$levelOpt4;
-		warnOnReservedLevelNames((_this$config$levelOpt3 = this.config.levelOptions) === null || _this$config$levelOpt3 === void 0 ? void 0 : _this$config$levelOpt3.levels);
-		if ((_this$config$levelOpt4 = this.config.levelOptions) === null || _this$config$levelOpt4 === void 0 ? void 0 : _this$config$levelOpt4.levels) {
-			for (const levelName of Object.keys(this.config.levelOptions.levels)) if (!this[levelName.toLowerCase()]) this[levelName.toLowerCase()] = (message, data) => this.logLevel(levelName.toLowerCase(), message, data);
-		}
+		var _this$config$levelOpt3;
+		const levels = (_this$config$levelOpt3 = this.config.levelOptions) === null || _this$config$levelOpt3 === void 0 ? void 0 : _this$config$levelOpt3.levels;
+		warnOnReservedLevelNames(levels);
+		if (!levels) return;
+		const self = this;
+		const names = Object.keys(levels);
+		const define = (method, levelName) => {
+			if (!self[method]) self[method] = (message, data) => this.logLevel(levelName, message, data);
+		};
+		for (const levelName of names) define(levelName, levelName);
+		for (const levelName of names) define(levelName.toLowerCase(), levelName);
 	}
 	/**
 	* Rebuild all hot-path caches after any config mutation or level change.
 	* Keeps the actual log() call free of allocations in the common case.
 	*/
 	_buildPerfCaches() {
-		var _this$config$levelOpt5, _this$config$format, _this$config$redact$p, _this$config$redact$p2;
-		const customLevelEntries = Object.entries(((_this$config$levelOpt5 = this.config.levelOptions) === null || _this$config$levelOpt5 === void 0 ? void 0 : _this$config$levelOpt5.levels) ?? {});
+		var _this$config$levelOpt4, _this$config$format, _this$config$redact$p, _this$config$redact$p2;
+		const customLevelEntries = Object.entries(((_this$config$levelOpt4 = this.config.levelOptions) === null || _this$config$levelOpt4 === void 0 ? void 0 : _this$config$levelOpt4.levels) ?? {});
 		this._levelValues = new Map([
 			[LogLevel.ERROR, 0],
 			[LogLevel.WARN, 1],
@@ -1345,8 +1478,8 @@ var LogixiaLogger = class LogixiaLogger {
 		for (const [lvl] of this._levelValues) {
 			const upper = lvl.toUpperCase();
 			if (colorize && this._fieldCache.get("level") !== false) {
-				var _this$config$levelOpt6;
-				let colorName = (_this$config$levelOpt6 = this.config.levelOptions) === null || _this$config$levelOpt6 === void 0 || (_this$config$levelOpt6 = _this$config$levelOpt6.colors) === null || _this$config$levelOpt6 === void 0 ? void 0 : _this$config$levelOpt6[lvl];
+				var _this$config$levelOpt5;
+				let colorName = (_this$config$levelOpt5 = this.config.levelOptions) === null || _this$config$levelOpt5 === void 0 || (_this$config$levelOpt5 = _this$config$levelOpt5.colors) === null || _this$config$levelOpt5 === void 0 ? void 0 : _this$config$levelOpt5[lvl];
 				if (!colorName) {
 					if (_BUILTIN_LEVELS.has(lvl)) colorName = "white";
 					else {
@@ -1371,9 +1504,9 @@ var LogixiaLogger = class LogixiaLogger {
 	*/
 	error(messageOrError, data) {
 		try {
-			return isError(messageOrError) ? this._run("error", messageOrError.message, {
+			return isError(messageOrError) ? this._run("error", errorMessageSafely(messageOrError), {
 				...data,
-				error: serializeError(messageOrError)
+				error: serializeErrorSafely(messageOrError)
 			}) : this._run("error", messageOrError, data);
 		} catch (error) {
 			return Promise.reject(error);
@@ -1493,8 +1626,8 @@ var LogixiaLogger = class LogixiaLogger {
 	* else a `NODE_ENV` default (`debug` in development, `warn` in test), else `info`.
 	*/
 	getLevel() {
-		var _this$config$levelOpt7;
-		return ((_this$config$levelOpt7 = this.config.levelOptions) === null || _this$config$levelOpt7 === void 0 ? void 0 : _this$config$levelOpt7.level) ?? LogLevel.INFO;
+		var _this$config$levelOpt6;
+		return ((_this$config$levelOpt6 = this.config.levelOptions) === null || _this$config$levelOpt6 === void 0 ? void 0 : _this$config$levelOpt6.level) ?? LogLevel.INFO;
 	}
 	_validLevelList() {
 		return [...this._levelValues.keys()].join(", ");
@@ -1557,7 +1690,8 @@ var LogixiaLogger = class LogixiaLogger {
 	}
 	/** Set the context label (e.g. a class or module name) attached to every subsequent entry. */
 	setContext(context) {
-		this.context = typeof context === "string" ? context : require_coerce_utils.safeToString(context);
+		this.context = typeof context === "string" ? context : require_csv_utils.safeToString(context);
+		this._syncNamespaceLevels();
 	}
 	/** Return the current context label, or `undefined` if none is set. */
 	getContext() {
@@ -1726,7 +1860,7 @@ var LogixiaLogger = class LogixiaLogger {
 		const config = this.config;
 		if (config.silent) return;
 		if (!this.shouldLog(level)) return;
-		const data = rawData instanceof Error ? { error: serializeError(rawData) } : rawData;
+		const data = rawData instanceof Error ? { error: serializeErrorSafely(rawData) } : rawData;
 		const alsContext = require_async_context.LogixiaContext.get();
 		let activeTraceId;
 		if (config.traceId) {
@@ -1771,7 +1905,8 @@ var LogixiaLogger = class LogixiaLogger {
 			}
 			else payload = rawPayload;
 		}
-		let safeMessage = message;
+		const rawMessage = message;
+		let safeMessage = rawMessage !== null && typeof rawMessage === "object" ? require_csv_utils.safeToString(rawMessage) : message;
 		if (this._hasRedact) try {
 			safeMessage = applyRedactionToString(message, config.redact);
 		} catch (error) {
@@ -1861,7 +1996,7 @@ var LogixiaLogger = class LogixiaLogger {
 		formatted += this._formattedAppName;
 		if (entry.traceId && this._fieldCache.get("traceId") !== false) formatted += `${cyan}[${require_otel.stripControlChars(String(entry.traceId))}]${reset} `;
 		if (entry.context && this._fieldCache.get("context") !== false) formatted += `${yellow}[${require_otel.stripControlChars(String(entry.context))}]${reset} `;
-		if (this._fieldCache.get("message") !== false) formatted += require_otel.stripControlChars(require_coerce_utils.safeToString(entry.message));
+		if (this._fieldCache.get("message") !== false) formatted += require_otel.stripControlChars(require_csv_utils.safeToString(entry.message));
 		if (entry.payload !== void 0 && this._fieldCache.get("payload") !== false) formatted += ` ${require_safe_stringify.stringifyForLog(entry.payload)}`;
 		return formatted;
 	}
@@ -1952,16 +2087,26 @@ var LogixiaLogger = class LogixiaLogger {
 * ```
 */
 function createLogger(config, context) {
-	var _config$levelOptions3;
-	const logger = new LogixiaLogger(config, context);
-	const mutableLogger = logger;
-	if ((_config$levelOptions3 = config.levelOptions) === null || _config$levelOptions3 === void 0 ? void 0 : _config$levelOptions3.levels) {
-		for (const levelName of Object.keys(config.levelOptions.levels)) if (!mutableLogger[levelName]) mutableLogger[levelName] = (message, data) => logger.logLevel(levelName, message, data);
-	}
-	return logger;
+	return new LogixiaLogger(config, context);
 }
 // src/exceptions/exception.ts
 var LogixiaException = class extends Error {
+	/** @readonly The machine-readable error code supplied by the caller. */
+	errorCode;
+	/** @readonly The error type category supplied by the caller. */
+	errorType;
+	/** @readonly HTTP status code to respond with. */
+	httpStatus;
+	/** @readonly Field pointer that caused this error (Stripe pattern). */
+	param;
+	/** @readonly Field-level validation errors (GitHub pattern). */
+	details;
+	/** @readonly Documentation URL for this error (Twilio pattern). */
+	docUrl;
+	/**
+	* @readonly Extra context for your logger — never serialised into the HTTP response.
+	*/
+	metadata;
 	constructor(options) {
 		super(options.message, { cause: options.cause });
 		this.name = "LogixiaException";
@@ -2334,4 +2479,4 @@ Object.defineProperty(exports, "usePlugin", {
 	}
 });
 
-//# sourceMappingURL=builder-BLIStsCK.js.map
+//# sourceMappingURL=builder-jMlVYaQa.js.map