logixia 2.0.11 → 2.2.0

package/dist/{builder-C6kKEVrU.mjs → builder-CbttbixM.mjs}

@@ -1,11 +1,13 @@
-import { a as buildNameSet, n as DEFAULT_REDACT_QUERY_PARAMS, o as redactUrlQuery, r as SENSITIVE_KEY_NAMES, s as redactUrlsInText, u as assignOwn } from "./sensitive-names-wv27qBQC.mjs";
-import { o as TraceContext } from "./request-trace-Dekcnenb.mjs";
-import { t as LogixiaContext } from "./async-context-BGUCdYAa.mjs";
-import { n as protectSecrets } from "./secret-config-D1F4MW69.mjs";
+import { t as assignOwn } from "./own-property-CjFw9qwZ.mjs";
+import { s as TraceContext } from "./request-trace-txUhyyre.mjs";
+import { t as LogixiaContext } from "./async-context-1YMPGgJZ.mjs";
+import { a as buildNameSet, n as DEFAULT_REDACT_QUERY_PARAMS, o as redactUrlQuery, r as SENSITIVE_KEY_NAMES, s as redactUrlsInText } from "./sensitive-names-BiBM6R1X.mjs";
+import { n as protectSecrets } from "./secret-config-Cng7XPLx.mjs";
 import { n as internalLog, r as internalWarn, t as internalError } from "./internal-log-Cy5nF1ZL.mjs";
+import { i as stringifyForLog } from "./safe-stringify-B5p5ktFe.mjs";
 import { n as safeToString } from "./csv.utils-ZdxSod5g.mjs";
-import { i as stringifyForLog } from "./safe-stringify-pZOnzGRJ.mjs";
-import { c as TransportManager, n as _getOtelPayloadIfEnabled, r as _isOtelBridgeEnabled, v as stripControlChars } from "./otel-DAVxpArV.mjs";
+import { c as TransportManager, n as _getOtelPayloadIfEnabled, r as _isOtelBridgeEnabled, v as stripControlChars } from "./otel-C5jBV_l_.mjs";
+import { i as serializeNestedErrors, r as serializeError, t as isError } from "./error.utils-B8_CwESF.mjs";
 import { constants } from "node:os";
 // src/types/index.ts
 const LogLevel = {
@@ -179,191 +181,6 @@ const globalPluginRegistry = new PluginRegistry();
 function usePlugin(plugin) {
 	globalPluginRegistry.register(plugin);
 }
-// src/utils/error.utils.ts
-const EXTRA_FIELDS = [
-	"code",
-	"statusCode",
-	"status",
-	"errno",
-	"syscall",
-	"path",
-	"address",
-	"port",
-	"type"
-];
-const SKIPPED_FIELDS = /* @__PURE__ */ new Set([
-	"name",
-	"message",
-	"stack",
-	"cause",
-	"errors",
-	...EXTRA_FIELDS
-]);
-const NO_OPTIONS = Object.freeze({});
-const NO_FIELDS = [];
-/**
-* Serialize an Error into a plain JSON-safe object, including:
-*  - `name`, `message`, `stack`
-*  - `cause` (recursively serialized, full ES2022 chain)
-*  - `errors` (for AggregateError)
-*  - standard Node.js error fields (`code`, `statusCode`, `errno`, …)
-*  - any other enumerable own properties
-*/
-function serializeError(error, options = NO_OPTIONS) {
-	const { includeStack = true, maxDepth = 5, excludeFields = NO_FIELDS } = options;
-	return _serializeError(error, includeStack, maxDepth, excludeFields, 0, /* @__PURE__ */ new WeakSet());
-}
-function _serializeError(error, includeStack, maxDepth, excludeFields, depth, seen) {
-	if (depth >= maxDepth) return {
-		name: error.name,
-		message: error.message,
-		_truncated: true
-	};
-	if (seen.has(error)) return {
-		name: error.name,
-		message: error.message,
-		_circular: true
-	};
-	seen.add(error);
-	const serialized = {
-		name: error.name,
-		message: error.message
-	};
-	if (includeStack && error.stack) serialized.stack = error.stack;
-	const errorWithCause = error;
-	if (errorWithCause.cause !== void 0) {
-		if (errorWithCause.cause instanceof Error) serialized.cause = _serializeError(errorWithCause.cause, includeStack, maxDepth, excludeFields, depth + 1, seen);
-		else serialized.cause = serializeValue(errorWithCause.cause, maxDepth - depth - 1, seen);
-	}
-	const aggregateError = error;
-	if (Array.isArray(aggregateError.errors)) serialized.errors = aggregateError.errors.map((e) => e instanceof Error ? _serializeError(e, includeStack, maxDepth, excludeFields, depth + 1, seen) : serializeValue(e, maxDepth - depth - 1, seen));
-	const errorRecord = error;
-	for (const field of EXTRA_FIELDS) if (!excludeFields.includes(field) && errorRecord[field] !== void 0) serialized[field] = errorRecord[field];
-	const skip = excludeFields.length === 0 ? SKIPPED_FIELDS : /* @__PURE__ */ new Set([...SKIPPED_FIELDS, ...excludeFields]);
-	for (const key of Object.getOwnPropertyNames(error)) {
-		if (skip.has(key)) continue;
-		try {
-			assignOwn(serialized, key, serializeValue(errorRecord[key], maxDepth - depth - 1, seen));
-		} catch {
-			assignOwn(serialized, key, "[Unserializable]");
-		}
-	}
-	return serialized;
-}
-/**
-* Recursively serialize an arbitrary value to a JSON-safe representation.
-*
-* The `seen` guard is threaded through (not recreated) so cross-referencing
-* errors nested inside plain objects/arrays are caught by the same circular
-* check that protects the top-level error tree, rather than only relying on the
-* depth limit.
-*/
-function serializeValue(value, remainingDepth, seen) {
-	if (remainingDepth <= 0) return "[Max Depth]";
-	if (value === null || value === void 0) return value;
-	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
-	if (value instanceof Date) return value.toISOString();
-	if (value instanceof Error) {
-		if (seen.has(value)) return {
-			name: value.name,
-			message: value.message,
-			_circular: true
-		};
-		return _serializeError(value, true, remainingDepth, [], 0, seen);
-	}
-	if (Array.isArray(value)) {
-		if (seen.has(value)) return "[Circular]";
-		seen.add(value);
-		return value.map((item) => serializeValue(item, remainingDepth - 1, seen));
-	}
-	if (typeof value === "object") {
-		if (seen.has(value)) return "[Circular]";
-		seen.add(value);
-		const out = {};
-		for (const [k, v] of Object.entries(value)) try {
-			assignOwn(out, k, serializeValue(v, remainingDepth - 1, seen));
-		} catch {
-			assignOwn(out, k, "[Unserializable]");
-		}
-		return out;
-	}
-	return String(value);
-}
-/**
-* Type guard: returns true if the value looks like an Error object.
-*/
-function isError(value) {
-	return value instanceof Error || Boolean(value) && typeof value === "object" && "name" in value && "message" in value;
-}
-const MAX_ERROR_SEARCH_DEPTH = 3;
-const MAX_ERROR_SEARCH_NODES = 2e3;
-/**
-* Replaces real Error instances inside a log payload with their serialized form,
-* because JSON output drops an Error's non-enumerable `message` and `stack`. Runs on
-* every log call, so its work is capped and it copies nothing until it finds one.
-* Duck-typed objects are data, and an Error with its own toJSON has already chosen
-* what to show. The caller's objects are never mutated.
-*/
-function serializeNestedErrors(data) {
-	const outerBudget = errorSearchBudget;
-	errorSearchBudget = MAX_ERROR_SEARCH_NODES;
-	try {
-		return walkForErrors(data, MAX_ERROR_SEARCH_DEPTH, void 0, void 0);
-	} finally {
-		errorSearchBudget = outerBudget;
-	}
-}
-let errorSearchBudget = 0;
-const hasOwn = Object.prototype.hasOwnProperty;
-function walkForErrors(value, depth, parent, grandparent) {
-	if (value instanceof Error) return typeof value.toJSON === "function" ? value : serializeError(value);
-	if (depth === 0 || --errorSearchBudget < 0 || value === parent || value === grandparent) return value;
-	let copy;
-	if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
-		const item = value[i];
-		if (item === null || typeof item !== "object") continue;
-		const next = walkForErrors(item, depth - 1, value, parent);
-		if (next !== item) {
-			copy ??= value.slice();
-			copy[i] = next;
-		}
-	}
-	else {
-		const proto = Object.getPrototypeOf(value);
-		if (proto !== Object.prototype && proto !== null) return value;
-		const record = value;
-		for (const key in record) {
-			if (!hasOwn.call(record, key)) continue;
-			let item;
-			try {
-				item = record[key];
-			} catch {
-				continue;
-			}
-			if (item === null || typeof item !== "object") continue;
-			const next = walkForErrors(item, depth - 1, record, parent);
-			if (next !== item) {
-				copy ??= { ...record };
-				assignOwn(copy, key, next);
-			}
-		}
-	}
-	return copy ?? value;
-}
-/**
-* Coerce any thrown value into a proper Error instance.
-*/
-function normalizeError(error) {
-	if (isError(error)) return error;
-	if (typeof error === "string") return new Error(error);
-	if (typeof error === "object" && error !== null) {
-		const e = error;
-		const err = new Error(typeof e["message"] === "string" ? e["message"] : "Unknown error");
-		Object.assign(err, error);
-		return err;
-	}
-	return new Error(String(error));
-}
 // src/utils/redact.utils.ts
 const DEFAULT_CENSOR = "[REDACTED]";
 /** Maximum nesting depth walked; deeper values are replaced with a marker. */
@@ -711,12 +528,28 @@ 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 decisions in LRU order (Map preserves insertion order; a hit
-	* re-inserts the key). Survives resetStats() so a long trace is not re-decided
-	* mid-flight. Bounded by size, by an idle TTL (refreshed on hit) and by a hard
+	* 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();
@@ -725,8 +558,11 @@ var Sampler = class {
 	traceMaxLifetimeMs = 36e5;
 	_tokenBucket = 0;
 	_lastRefillMs = Date.now();
-	_adaptiveWindow = [];
-	_adaptiveHead = 0;
+	_adaptiveBucketMs;
+	_adaptiveTotals = new Float64Array(ADAPTIVE_BUCKETS);
+	_adaptiveErrorCounts = new Float64Array(ADAPTIVE_BUCKETS);
+	_adaptiveBucket = 0;
+	_adaptiveTotal = 0;
 	_adaptiveErrors = 0;
 	_stats = {
 		evaluated: 0,
@@ -737,7 +573,9 @@ var Sampler = class {
 	};
 	_statsTimer;
 	constructor(config, onStats) {
+		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) {
@@ -795,34 +633,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;
 		}
 	}
 	/**
@@ -833,8 +675,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;
 	}
@@ -843,8 +686,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.
 	*/
@@ -856,12 +700,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
 		});
@@ -869,7 +713,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();
@@ -946,7 +790,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
@@ -973,7 +818,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`);
@@ -1094,6 +940,27 @@ function nowIso() {
 	return _tsCacheStr;
 }
 const RESOLVED = Promise.resolve();
+const UNSERIALIZABLE = "[Unserializable]";
+const ANSI_COLORS = /* @__PURE__ */ new Map([
+	["black", "\x1B[30m"],
+	["red", "\x1B[31m"],
+	["green", "\x1B[32m"],
+	["yellow", "\x1B[33m"],
+	["blue", "\x1B[34m"],
+	["magenta", "\x1B[35m"],
+	["cyan", "\x1B[36m"],
+	["white", "\x1B[37m"],
+	["gray", "\x1B[90m"],
+	["grey", "\x1B[90m"],
+	["brightred", "\x1B[91m"],
+	["brightgreen", "\x1B[92m"],
+	["brightyellow", "\x1B[93m"],
+	["brightblue", "\x1B[94m"],
+	["brightmagenta", "\x1B[95m"],
+	["brightcyan", "\x1B[96m"],
+	["brightwhite", "\x1B[97m"],
+	["reset", "\x1B[0m"]
+]);
 const JSON_STRING_FIELDS = [
 	"timestamp",
 	"level",
@@ -1130,6 +997,21 @@ function toContextLabel(context) {
 	if (context === void 0 || context === null) return "";
 	return typeof context === "string" ? context : safeToString(context);
 }
+function serializeErrorSafely(error) {
+	try {
+		return serializeError(error);
+	} catch (cause) {
+		internalError("Error serialization failed", cause);
+		return UNSERIALIZABLE;
+	}
+}
+function errorMessageSafely(error) {
+	try {
+		return safeToString(error.message);
+	} catch {
+		return UNSERIALIZABLE;
+	}
+}
 function namespacePatternToRegex(pattern) {
 	const escaped = pattern.split(".").map((s) => s === "*" ? "[^.]+" : s.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&")).join("\\.");
 	return new RegExp(`^${escaped}$`);
@@ -1215,7 +1097,7 @@ var LogixiaLogger = class LogixiaLogger {
 	/** `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();
+	_colorMap = ANSI_COLORS;
 	/** 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. */
@@ -1287,15 +1169,21 @@ var LogixiaLogger = class LogixiaLogger {
 				}
 			}
 		};
-		this.config = {
-			...defaultConfig,
-			...config
-		};
-		const resolvedLevel = resolveInitialLevel(this.config);
-		this.config.levelOptions = {
-			...this.config.levelOptions,
-			level: resolvedLevel
+		if (parent) this.config = {
+			...config,
+			levelOptions: { ...config.levelOptions }
 		};
+		else {
+			this.config = {
+				...defaultConfig,
+				...config
+			};
+			const resolvedLevel = resolveInitialLevel(this.config);
+			this.config.levelOptions = {
+				...this.config.levelOptions,
+				level: resolvedLevel
+			};
+		}
 		this.config.fields ??= {
 			timestamp: "[yyyy-mm-dd HH:MM:ss.MS]",
 			level: "[log_level]",
@@ -1330,7 +1218,7 @@ var LogixiaLogger = class LogixiaLogger {
 		if (!parent) this.setupGracefulShutdown();
 		this.createCustomLevelMethods();
 		if (!parent) for (const p of globalPluginRegistry._plugins) this._pluginRegistry.register(p);
-		this._buildPerfCaches();
+		this._buildPerfCaches(parent);
 	}
 	setupGracefulShutdown() {
 		const shutdownCfg = this.config.gracefulShutdown;
@@ -1345,19 +1233,34 @@ 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) ?? {});
+	_buildPerfCaches(inheritFrom) {
+		var _this$config$levelOpt4, _this$config$format, _this$config$redact$p, _this$config$redact$p2;
+		if (inheritFrom && inheritFrom.fieldState.size === 0) {
+			this._levelValues = inheritFrom._levelValues;
+			this._fieldCache = new Map(inheritFrom._fieldCache);
+			this._formattedLevels = inheritFrom._formattedLevels;
+			this._formattedAppName = inheritFrom._formattedAppName;
+			this._hasRedact = inheritFrom._hasRedact;
+			this._minLevelValue = this._levelValues.get(this.resolveEffectiveLevel()) ?? 2;
+			return;
+		}
+		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],
@@ -1371,26 +1274,7 @@ var LogixiaLogger = class LogixiaLogger {
 		this.config.levelOptions.level = this._validLevel(this.config.levelOptions.level, "levelOptions.level") ?? LogLevel.INFO;
 		const effectiveLevel = this.resolveEffectiveLevel();
 		this._minLevelValue = this._levelValues.get(effectiveLevel) ?? 2;
-		this._colorMap = /* @__PURE__ */ new Map([
-			["black", "\x1B[30m"],
-			["red", "\x1B[31m"],
-			["green", "\x1B[32m"],
-			["yellow", "\x1B[33m"],
-			["blue", "\x1B[34m"],
-			["magenta", "\x1B[35m"],
-			["cyan", "\x1B[36m"],
-			["white", "\x1B[37m"],
-			["gray", "\x1B[90m"],
-			["grey", "\x1B[90m"],
-			["brightred", "\x1B[91m"],
-			["brightgreen", "\x1B[92m"],
-			["brightyellow", "\x1B[93m"],
-			["brightblue", "\x1B[94m"],
-			["brightmagenta", "\x1B[95m"],
-			["brightcyan", "\x1B[96m"],
-			["brightwhite", "\x1B[97m"],
-			["reset", "\x1B[0m"]
-		]);
+		this._colorMap = ANSI_COLORS;
 		for (const f of [
 			"timestamp",
 			"level",
@@ -1426,8 +1310,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 {
@@ -1452,9 +1336,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);
@@ -1574,8 +1458,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(", ");
@@ -1639,6 +1523,7 @@ 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 : safeToString(context);
+		this._syncNamespaceLevels();
 	}
 	/** Return the current context label, or `undefined` if none is set. */
 	getContext() {
@@ -1807,7 +1692,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 = LogixiaContext.get();
 		let activeTraceId;
 		if (config.traceId) {
@@ -2034,13 +1919,7 @@ 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 {
@@ -2281,6 +2160,6 @@ var ErrorResponseBuilder = class {
 		};
 	}
 };
-export { DEFAULT_LOG_COLORS as C, DEFAULT_CONFIG as S, LogLevel as T, serializeError as _, isLogixiaException as a, globalPluginRegistry as b, _shutdownRegistrySize as c, registerForShutdown as d, resetShutdownHandlers as f, normalizeError as g, isError as h, LogixiaException as i, deregisterFromShutdown as l, redactObject as m, generateRequestId as n, LogixiaLogger as o, applyRedaction as p, generateTraceId as r, createLogger as s, ErrorResponseBuilder as t, flushOnExit as u, serializeNestedErrors as v, DEFAULT_LOG_LEVELS as w, usePlugin as x, PluginRegistry as y };
+export { usePlugin as _, isLogixiaException as a, DEFAULT_LOG_LEVELS as b, _shutdownRegistrySize as c, registerForShutdown as d, resetShutdownHandlers as f, globalPluginRegistry as g, PluginRegistry as h, LogixiaException as i, deregisterFromShutdown as l, redactObject as m, generateRequestId as n, LogixiaLogger as o, applyRedaction as p, generateTraceId as r, createLogger as s, ErrorResponseBuilder as t, flushOnExit as u, DEFAULT_CONFIG as v, LogLevel as x, DEFAULT_LOG_COLORS as y };
 
-//# sourceMappingURL=builder-C6kKEVrU.mjs.map
+//# sourceMappingURL=builder-CbttbixM.mjs.map