@mks2508/better-logger 0.18.2-alpha.1 → 0.18.3

package/dist/chunks/SerializerBridge-Ba43Mk7j.js

@@ -0,0 +1,393 @@
+//#region src/serializers/SerializerRegistry.ts
+/**
+* Configuración por defecto del registry. Se merguea con la config que reciba
+* el constructor (gana la del caller).
+*
+* @internal Constante de módulo; no es API pública.
+*/
+const DEFAULT_CONFIG = {
+	maxDepth: 5,
+	circular: "placeholder",
+	preserveUndefined: false
+};
+/**
+* Registry de serializers tipados por constructor.
+*
+* Mantiene un mapa ordenado por `priority` (mayor primero) de serializers
+* registrados para clases específicas. El método {@link SerializerRegistry.serialize}
+* recorre objetos de forma recursiva aplicando el serializer que matchee por
+* `instanceof`, con dos guardas de seguridad:
+*
+* - **Depth guard**: corta la recursión al llegar a `maxDepth` y emite el
+*   placeholder `'[Max Depth]'`.
+* - **Circular ref**: lleva un `WeakSet` de objetos visitados en el path actual;
+*   al re-encontrar uno aplica la estrategia de `circular` (`placeholder` por
+*   default).
+*
+* Implementa {@link ISerializerRegistry}. Suele usarse vía el singleton de
+* {@link getDefaultSerializerRegistry}, expuesto al Logger a través del
+* {@link SerializerBridge}.
+*
+* @example
+* ```ts
+* const registry = new SerializerRegistry({ maxDepth: 3 });
+*
+* registry.add(URL, (url: URL) => ({
+*   href: url.href,
+*   origin: url.origin
+* }), 60);
+*
+* const safe = registry.serialize(someMaybeCyclicObject);
+* ```
+*
+* @see {@link ISerializerRegistry} para el contrato interface.
+* @see {@link SerializerConfig} para las opciones del constructor.
+*/
+var SerializerRegistry = class {
+	serializers = /* @__PURE__ */ new Map();
+	config;
+	/**
+	* Crea un registry nuevo con los serializers builtin ya registrados
+	* (Error, Date, RegExp, Map, Set, Buffer cuando está disponible).
+	*
+	* @param {SerializerConfig} config - Overrides sobre {@link DEFAULT_CONFIG}.
+	*   - `maxDepth` (default `5`): profundidad máxima de anidamiento antes del
+	*     placeholder `'[Max Depth]'`.
+	*   - `circular` (default `'placeholder'`): qué hacer ante una referencia
+	*     circular. `'placeholder'` emite `'[Circular]'`, `'skip'` omite la key
+	*     (devuelve `undefined`), `'error'` lanza.
+	*   - `preserveUndefined` (default `false`): si `true` deja `undefined`
+	*     textual; si `false` lo reemplaza por `'[undefined]'` (más seguro para
+	*     JSON / transporte).
+	*
+	* @example
+	* ```ts
+	* // Defaults (depth 5, circular → placeholder)
+	* const a = new SerializerRegistry();
+	*
+	* // Estricto: lanza ante ciclo, conservar undefined
+	* const b = new SerializerRegistry({
+	*   maxDepth: 10,
+	*   circular: 'error',
+	*   preserveUndefined: true
+	* });
+	* ```
+	*/
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+		this.registerDefaults();
+	}
+	/**
+	* Registra los serializers builtin con sus prioridades. Invocado por el
+	* constructor; no es API pública.
+	*
+	* Defaults (mayor priority = gana primero en `instanceof`):
+	*
+	* | Tipo     | Priority | Salida                                         |
+	* |----------|----------|------------------------------------------------|
+	* | `Error`  | 100      | `{ name, message, stack[], cause? }`           |
+	* | `Date`   | 90       | `{ iso, timestamp }`                           |
+	* | `RegExp` | 90       | `{ pattern, flags }`                           |
+	* | `Map`    | 80       | `{ __type:'Map', entries }`                    |
+	* | `Set`    | 80       | `{ __type:'Set', values[] }`                   |
+	* | `Buffer` | 70       | `{ __type:'Buffer', length, preview }` (Node)  |
+	*
+	* @internal
+	*/
+	registerDefaults() {
+		this.add(Error, (err) => ({
+			name: err.name,
+			message: err.message,
+			stack: err.stack?.split("\n").slice(0, 10),
+			...err.cause ? { cause: this.serialize(err.cause) } : {}
+		}), 100);
+		this.add(Date, (date) => ({
+			iso: date.toISOString(),
+			timestamp: date.getTime()
+		}), 90);
+		this.add(RegExp, (regex) => ({
+			pattern: regex.source,
+			flags: regex.flags
+		}), 90);
+		this.add(Map, (map, ctx) => {
+			const obj = {};
+			map.forEach((value, key) => {
+				const keyStr = typeof key === "object" ? JSON.stringify(key) : String(key);
+				obj[keyStr] = this.serializeInternal(value, {
+					...ctx,
+					depth: ctx.depth + 1,
+					path: [...ctx.path, keyStr]
+				});
+			});
+			return {
+				__type: "Map",
+				entries: obj
+			};
+		}, 80);
+		this.add(Set, (set, ctx) => ({
+			__type: "Set",
+			values: Array.from(set).map((v, i) => this.serializeInternal(v, {
+				...ctx,
+				depth: ctx.depth + 1,
+				path: [...ctx.path, `[${i}]`]
+			}))
+		}), 80);
+		if (typeof Buffer !== "undefined") this.add(Buffer, (buf) => ({
+			__type: "Buffer",
+			length: buf.length,
+			preview: buf.slice(0, 50).toString("hex")
+		}), 70);
+	}
+	/**
+	* Registra (o reemplaza) el serializer para una clase constructora.
+	*
+	* Si ya existía un serializer para `type`, se sobrescribe. La `priority`
+	* sólo ordena de cara al lookup por `instanceof` hecho en
+	* {@link SerializerRegistry.getAll} — útil cuando una subclass debería
+	* matchear antes que su superclass (p.ej. `TypeError` antes que `Error`).
+	*
+	* @param {new (...args: any[]) => T} type - Constructor de la clase a matchear.
+	* @param {SerializerFn<T>} serializer - Función que recibe la instancia y el
+	*   {@link SerializerContext} (depth, path, seen); devuelve una representación
+	*   serializable.
+	* @param {number} [priority=50] - Orden de lookup (mayor = primero). Los
+	*   defaults builtin usan 70–100.
+	*
+	* @example
+	* ```ts
+	* registry.add(
+	*   URL,
+	*   (url: URL, ctx) => ({ href: url.href, origin: url.origin }),
+	*   60
+	* );
+	* ```
+	*/
+	add(type, serializer, priority = 50) {
+		this.serializers.set(type, {
+			type,
+			serializer,
+			priority
+		});
+	}
+	/**
+	* Elimina el serializer registrado para `type`.
+	*
+	* @param {new (...args: any[]) => T} type - Constructor a remover.
+	* @returns `true` si existía y fue removido, `false` si no había registro.
+	*
+	* @example
+	* ```ts
+	* registry.remove(Date); // → true (estaba registrado por defecto)
+	* registry.remove(Date); // → false (ya no está)
+	* ```
+	*/
+	remove(type) {
+		return this.serializers.delete(type);
+	}
+	/**
+	* Indica si hay un serializer registrado para `type`.
+	*
+	* @param {new (...args: any[]) => T} type - Constructor a consultar.
+	* @returns `true` si `type` está registrado.
+	*
+	* @example
+	* ```ts
+	* if (!registry.has(CustomError)) {
+	*   registry.add(CustomError, serializeCustomError, 95);
+	* }
+	* ```
+	*/
+	has(type) {
+		return this.serializers.has(type);
+	}
+	/**
+	* Devuelve todas las entradas registradas, ordenadas por `priority`
+	* descendente (mayor priority primero). Este es el orden en el que
+	* {@link SerializerRegistry.serialize} los prueba vía `instanceof`.
+	*
+	* @returns {SerializerEntry[]} Array de entradas ordenadas por prioridad.
+	*
+	* @example
+	* ```ts
+	* const entries = registry.getAll();
+	* console.log(entries.map(e => [e.type.name, e.priority]));
+	* // [['Error', 100], ['Date', 90], ['RegExp', 90], ['Map', 80], ...]
+	* ```
+	*
+	* @see {@link SerializerEntry}
+	*/
+	getAll() {
+		return Array.from(this.serializers.values()).sort((a, b) => (b.priority ?? 50) - (a.priority ?? 50));
+	}
+	/**
+	* Busca el primer serializer cuyo `type` matchee `value instanceof type`,
+	* recorriendo las entradas en orden de prioridad descendente.
+	*
+	* @internal Helper del pipeline interno; no es API pública.
+	* @param value - Valor a testear.
+	* @returns Entrada matcheante, o `null` si ninguna aplica.
+	*/
+	findSerializer(value) {
+		const sorted = this.getAll();
+		for (const entry of sorted) if (value instanceof entry.type) return entry;
+		return null;
+	}
+	/**
+	* Pipeline interno de serialización recursiva. Es el core de
+	* {@link SerializerRegistry.serialize}; no es API pública pero se documenta
+	* aquí para mantener la semántica del pipeline en un solo lugar.
+	*
+	* Orden de guardas (cada una corta la recursión):
+	*
+	* 1. `null` / `undefined` — directo (respeta `preserveUndefined`).
+	* 2. `function` — placeholder `'[Function: name]'`.
+	* 3. Primitiva no-objeto — se devuelve tal cual.
+	* 4. **Depth guard**: si `depth >= maxDepth` → `'[Max Depth]'`.
+	* 5. **Circular**: si `value` ya está en el `WeakSet` `seen` del contexto,
+	*    aplica `circular` (`placeholder` / `skip` / `error`).
+	* 6. Se marca en `seen`, se busca serializer por `instanceof`; si matchea,
+	*    se delega (el serializer puede recursar via `ctx`).
+	* 7. Si es array, mapea cada item incrementando depth y extendiendo path.
+	* 8. Si es plain object, itera keys recursivamente.
+	*
+	* @internal
+	* @param value - Valor a serializar.
+	* @param context - Estado de recursión (depth, path, seen, maxDepth).
+	* @returns Valor serializable (puede ser primitiva, objeto, array o placeholder).
+	* @throws {Error} Sólo si `circular: 'error'` y se detecta ciclo.
+	*/
+	serializeInternal(value, context) {
+		if (value === null) return null;
+		if (value === void 0) return this.config.preserveUndefined ? void 0 : "[undefined]";
+		if (typeof value === "function") return `[Function: ${value.name || "anonymous"}]`;
+		if (typeof value !== "object") return value;
+		if (context.depth >= this.config.maxDepth) return "[Max Depth]";
+		if (context.seen.has(value)) switch (this.config.circular) {
+			case "error": throw new Error(`Circular reference at ${context.path.join(".")}`);
+			case "skip": return;
+			default: return "[Circular]";
+		}
+		context.seen.add(value);
+		const serializer = this.findSerializer(value);
+		if (serializer) return serializer.serializer(value, context);
+		if (Array.isArray(value)) return value.map((item, i) => this.serializeInternal(item, {
+			...context,
+			depth: context.depth + 1,
+			path: [...context.path, `[${i}]`]
+		}));
+		const result = {};
+		for (const [key, val] of Object.entries(value)) result[key] = this.serializeInternal(val, {
+			...context,
+			depth: context.depth + 1,
+			path: [...context.path, key]
+		});
+		return result;
+	}
+	/**
+	* Serializa un valor arbitrario a una representación segura para transporte
+	* (JSON, remote log, OTLP, etc.).
+	*
+	* Entry point público del pipeline. Construye un {@link SerializerContext}
+	* fresco (depth 0, path vacío, `WeakSet` nuevo para detección de ciclos),
+	* merguea overrides de `config` sobre los del constructor y delega a
+	* {@link SerializerRegistry.serializeInternal}.
+	*
+	* @param {any} value - Valor a serializar. Cualquier tipo.
+	* @param {SerializerConfig} [config] - Overrides puntuales para esta llamada
+	*   (no mutan la config del registry). Útil para, p.ej., subir `maxDepth`
+	*   sólo en un log concreto.
+	* @returns {any} Valor serializable. Para objetos sin serializer registrado
+	*   se devuelve un plain object; para tipos builtin, la shape definida en
+	*   {@link SerializerRegistry.registerDefaults}; para los cortes de
+	*   profundidad o circular, los placeholders `'[Max Depth]'` / `'[Circular]'`.
+	* @throws {Error} Sólo si `circular: 'error'` y se detecta una referencia circular.
+	*
+	* @example
+	* ```ts
+	* // Objetos simples
+	* registry.serialize({ a: 1, b: [2, 3] });
+	* // → { a: 1, b: [2, 3] }
+	*
+	* // Errores (serializer builtin)
+	* registry.serialize(new Error('boom'));
+	* // → { name: 'Error', message: 'boom', stack: [...] }
+	*
+	* // Referencia circular → placeholder
+	* const o: any = {};
+	* o.self = o;
+	* registry.serialize(o); // → { self: '[Circular]' }
+	*
+	* // Override puntual de maxDepth
+	* registry.serialize(deepObj, { maxDepth: 2 });
+	* ```
+	*
+	* @see {@link SerializerRegistry.serializeInternal} para el detalle del pipeline.
+	*/
+	serialize(value, config) {
+		const mergedConfig = {
+			...this.config,
+			...config
+		};
+		return this.serializeInternal(value, {
+			depth: 0,
+			maxDepth: mergedConfig.maxDepth,
+			path: [],
+			seen: /* @__PURE__ */ new WeakSet()
+		});
+	}
+};
+/**
+* Cache del singleton de {@link SerializerRegistry}. Module-private.
+*
+* @internal
+*/
+let _defaultRegistry = null;
+/**
+* Devuelve el singleton de {@link SerializerRegistry} (lo crea con config
+* default en la primera llamada). Es la vía canónica de obtener el registry
+* compartido que usa el Logger internamente.
+*
+* @returns {SerializerRegistry} Instancia singleton.
+*
+* @example
+* ```ts
+* import { getDefaultSerializerRegistry } from '@mks2508/better-logger/serializers';
+*
+* const registry = getDefaultSerializerRegistry();
+* if (!registry.has(CustomError)) {
+*   registry.add(CustomError, (e) => ({ code: e.code, message: e.message }), 95);
+* }
+* ```
+*/
+function getDefaultSerializerRegistry() {
+	if (!_defaultRegistry) _defaultRegistry = new SerializerRegistry();
+	return _defaultRegistry;
+}
+//#endregion
+//#region src/serializers/SerializerBridge.ts
+/**
+* Crea una instancia de {@link SerializerBridge}.
+*
+* @internal
+*/
+function createSerializerBridge() {
+	const serializerRegistry = new SerializerRegistry();
+	return {
+		addSerializer(type, serializer, priority) {
+			serializerRegistry.add(type, serializer, priority);
+		},
+		removeSerializer(type) {
+			return serializerRegistry.remove(type);
+		},
+		getSerializerRegistry() {
+			return serializerRegistry;
+		}
+	};
+}
+//#endregion
+export { SerializerRegistry as n, getDefaultSerializerRegistry as r, createSerializerBridge as t };
+
+//# sourceMappingURL=SerializerBridge-Ba43Mk7j.js.map

package/dist/chunks/SerializerBridge-Ba43Mk7j.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SerializerBridge-Ba43Mk7j.js","names":[],"sources":["../../src/serializers/SerializerRegistry.ts","../../src/serializers/SerializerBridge.ts"],"sourcesContent":["/**\n * @fileoverview Registry de serializers con control de profundidad, detección\n * de referencias circulares y soporte para tipos builtin (Error, Date, RegExp,\n * Map, Set, Buffer). Implementa {@link ISerializerRegistry}.\n */\nimport type {\n    SerializerFn,\n    SerializerContext,\n    SerializerEntry,\n    SerializerConfig,\n    ISerializerRegistry\n} from '../types/index.js';\n\n/**\n * Configuración por defecto del registry. Se merguea con la config que reciba\n * el constructor (gana la del caller).\n *\n * @internal Constante de módulo; no es API pública.\n */\nconst DEFAULT_CONFIG: Required<SerializerConfig> = {\n    maxDepth: 5,\n    circular: 'placeholder',\n    preserveUndefined: false\n};\n\n/**\n * Registry de serializers tipados por constructor.\n *\n * Mantiene un mapa ordenado por `priority` (mayor primero) de serializers\n * registrados para clases específicas. El método {@link SerializerRegistry.serialize}\n * recorre objetos de forma recursiva aplicando el serializer que matchee por\n * `instanceof`, con dos guardas de seguridad:\n *\n * - **Depth guard**: corta la recursión al llegar a `maxDepth` y emite el\n *   placeholder `'[Max Depth]'`.\n * - **Circular ref**: lleva un `WeakSet` de objetos visitados en el path actual;\n *   al re-encontrar uno aplica la estrategia de `circular` (`placeholder` por\n *   default).\n *\n * Implementa {@link ISerializerRegistry}. Suele usarse vía el singleton de\n * {@link getDefaultSerializerRegistry}, expuesto al Logger a través del\n * {@link SerializerBridge}.\n *\n * @example\n * ```ts\n * const registry = new SerializerRegistry({ maxDepth: 3 });\n *\n * registry.add(URL, (url: URL) => ({\n *   href: url.href,\n *   origin: url.origin\n * }), 60);\n *\n * const safe = registry.serialize(someMaybeCyclicObject);\n * ```\n *\n * @see {@link ISerializerRegistry} para el contrato interface.\n * @see {@link SerializerConfig} para las opciones del constructor.\n */\nexport class SerializerRegistry implements ISerializerRegistry {\n    private serializers: Map<Function, SerializerEntry> = new Map();\n    private config: Required<SerializerConfig>;\n\n    /**\n     * Crea un registry nuevo con los serializers builtin ya registrados\n     * (Error, Date, RegExp, Map, Set, Buffer cuando está disponible).\n     *\n     * @param {SerializerConfig} config - Overrides sobre {@link DEFAULT_CONFIG}.\n     *   - `maxDepth` (default `5`): profundidad máxima de anidamiento antes del\n     *     placeholder `'[Max Depth]'`.\n     *   - `circular` (default `'placeholder'`): qué hacer ante una referencia\n     *     circular. `'placeholder'` emite `'[Circular]'`, `'skip'` omite la key\n     *     (devuelve `undefined`), `'error'` lanza.\n     *   - `preserveUndefined` (default `false`): si `true` deja `undefined`\n     *     textual; si `false` lo reemplaza por `'[undefined]'` (más seguro para\n     *     JSON / transporte).\n     *\n     * @example\n     * ```ts\n     * // Defaults (depth 5, circular → placeholder)\n     * const a = new SerializerRegistry();\n     *\n     * // Estricto: lanza ante ciclo, conservar undefined\n     * const b = new SerializerRegistry({\n     *   maxDepth: 10,\n     *   circular: 'error',\n     *   preserveUndefined: true\n     * });\n     * ```\n     */\n    constructor(config: SerializerConfig = {}) {\n        this.config = { ...DEFAULT_CONFIG, ...config };\n        this.registerDefaults();\n    }\n\n    /**\n     * Registra los serializers builtin con sus prioridades. Invocado por el\n     * constructor; no es API pública.\n     *\n     * Defaults (mayor priority = gana primero en `instanceof`):\n     *\n     * | Tipo     | Priority | Salida                                         |\n     * |----------|----------|------------------------------------------------|\n     * | `Error`  | 100      | `{ name, message, stack[], cause? }`           |\n     * | `Date`   | 90       | `{ iso, timestamp }`                           |\n     * | `RegExp` | 90       | `{ pattern, flags }`                           |\n     * | `Map`    | 80       | `{ __type:'Map', entries }`                    |\n     * | `Set`    | 80       | `{ __type:'Set', values[] }`                   |\n     * | `Buffer` | 70       | `{ __type:'Buffer', length, preview }` (Node)  |\n     *\n     * @internal\n     */\n    private registerDefaults(): void {\n        this.add(Error, (err: Error) => ({\n            name: err.name,\n            message: err.message,\n            stack: err.stack?.split('\\n').slice(0, 10),\n            ...(err.cause ? { cause: this.serialize(err.cause) } : {})\n        }), 100);\n\n        this.add(Date, (date: Date) => ({\n            iso: date.toISOString(),\n            timestamp: date.getTime()\n        }), 90);\n\n        this.add(RegExp, (regex: RegExp) => ({\n            pattern: regex.source,\n            flags: regex.flags\n        }), 90);\n\n        this.add(Map, (map: Map<any, any>, ctx) => {\n            const obj: Record<string, any> = {};\n            map.forEach((value, key) => {\n                const keyStr = typeof key === 'object' ? JSON.stringify(key) : String(key);\n                obj[keyStr] = this.serializeInternal(value, {\n                    ...ctx,\n                    depth: ctx.depth + 1,\n                    path: [...ctx.path, keyStr]\n                });\n            });\n            return { __type: 'Map', entries: obj };\n        }, 80);\n\n        this.add(Set, (set: Set<any>, ctx) => ({\n            __type: 'Set',\n            values: Array.from(set).map((v, i) =>\n                this.serializeInternal(v, {\n                    ...ctx,\n                    depth: ctx.depth + 1,\n                    path: [...ctx.path, `[${i}]`]\n                })\n            )\n        }), 80);\n\n        if (typeof Buffer !== 'undefined') {\n            this.add(Buffer as any, (buf: Buffer) => ({\n                __type: 'Buffer',\n                length: buf.length,\n                preview: buf.slice(0, 50).toString('hex')\n            }), 70);\n        }\n    }\n\n    /**\n     * Registra (o reemplaza) el serializer para una clase constructora.\n     *\n     * Si ya existía un serializer para `type`, se sobrescribe. La `priority`\n     * sólo ordena de cara al lookup por `instanceof` hecho en\n     * {@link SerializerRegistry.getAll} — útil cuando una subclass debería\n     * matchear antes que su superclass (p.ej. `TypeError` antes que `Error`).\n     *\n     * @param {new (...args: any[]) => T} type - Constructor de la clase a matchear.\n     * @param {SerializerFn<T>} serializer - Función que recibe la instancia y el\n     *   {@link SerializerContext} (depth, path, seen); devuelve una representación\n     *   serializable.\n     * @param {number} [priority=50] - Orden de lookup (mayor = primero). Los\n     *   defaults builtin usan 70–100.\n     *\n     * @example\n     * ```ts\n     * registry.add(\n     *   URL,\n     *   (url: URL, ctx) => ({ href: url.href, origin: url.origin }),\n     *   60\n     * );\n     * ```\n     */\n    add<T>(\n        type: new (...args: any[]) => T,\n        serializer: SerializerFn<T>,\n        priority: number = 50\n    ): void {\n        this.serializers.set(type, { type, serializer, priority });\n    }\n\n    /**\n     * Elimina el serializer registrado para `type`.\n     *\n     * @param {new (...args: any[]) => T} type - Constructor a remover.\n     * @returns `true` si existía y fue removido, `false` si no había registro.\n     *\n     * @example\n     * ```ts\n     * registry.remove(Date); // → true (estaba registrado por defecto)\n     * registry.remove(Date); // → false (ya no está)\n     * ```\n     */\n    remove<T>(type: new (...args: any[]) => T): boolean {\n        return this.serializers.delete(type);\n    }\n\n    /**\n     * Indica si hay un serializer registrado para `type`.\n     *\n     * @param {new (...args: any[]) => T} type - Constructor a consultar.\n     * @returns `true` si `type` está registrado.\n     *\n     * @example\n     * ```ts\n     * if (!registry.has(CustomError)) {\n     *   registry.add(CustomError, serializeCustomError, 95);\n     * }\n     * ```\n     */\n    has<T>(type: new (...args: any[]) => T): boolean {\n        return this.serializers.has(type);\n    }\n\n    /**\n     * Devuelve todas las entradas registradas, ordenadas por `priority`\n     * descendente (mayor priority primero). Este es el orden en el que\n     * {@link SerializerRegistry.serialize} los prueba vía `instanceof`.\n     *\n     * @returns {SerializerEntry[]} Array de entradas ordenadas por prioridad.\n     *\n     * @example\n     * ```ts\n     * const entries = registry.getAll();\n     * console.log(entries.map(e => [e.type.name, e.priority]));\n     * // [['Error', 100], ['Date', 90], ['RegExp', 90], ['Map', 80], ...]\n     * ```\n     *\n     * @see {@link SerializerEntry}\n     */\n    getAll(): SerializerEntry[] {\n        return Array.from(this.serializers.values())\n            .sort((a, b) => (b.priority ?? 50) - (a.priority ?? 50));\n    }\n\n    /**\n     * Busca el primer serializer cuyo `type` matchee `value instanceof type`,\n     * recorriendo las entradas en orden de prioridad descendente.\n     *\n     * @internal Helper del pipeline interno; no es API pública.\n     * @param value - Valor a testear.\n     * @returns Entrada matcheante, o `null` si ninguna aplica.\n     */\n    private findSerializer(value: any): SerializerEntry | null {\n        const sorted = this.getAll();\n        for (const entry of sorted) {\n            if (value instanceof entry.type) {\n                return entry;\n            }\n        }\n        return null;\n    }\n\n    /**\n     * Pipeline interno de serialización recursiva. Es el core de\n     * {@link SerializerRegistry.serialize}; no es API pública pero se documenta\n     * aquí para mantener la semántica del pipeline en un solo lugar.\n     *\n     * Orden de guardas (cada una corta la recursión):\n     *\n     * 1. `null` / `undefined` — directo (respeta `preserveUndefined`).\n     * 2. `function` — placeholder `'[Function: name]'`.\n     * 3. Primitiva no-objeto — se devuelve tal cual.\n     * 4. **Depth guard**: si `depth >= maxDepth` → `'[Max Depth]'`.\n     * 5. **Circular**: si `value` ya está en el `WeakSet` `seen` del contexto,\n     *    aplica `circular` (`placeholder` / `skip` / `error`).\n     * 6. Se marca en `seen`, se busca serializer por `instanceof`; si matchea,\n     *    se delega (el serializer puede recursar via `ctx`).\n     * 7. Si es array, mapea cada item incrementando depth y extendiendo path.\n     * 8. Si es plain object, itera keys recursivamente.\n     *\n     * @internal\n     * @param value - Valor a serializar.\n     * @param context - Estado de recursión (depth, path, seen, maxDepth).\n     * @returns Valor serializable (puede ser primitiva, objeto, array o placeholder).\n     * @throws {Error} Sólo si `circular: 'error'` y se detecta ciclo.\n     */\n    private serializeInternal(value: any, context: SerializerContext): any {\n        if (value === null) return null;\n        if (value === undefined) return this.config.preserveUndefined ? undefined : '[undefined]';\n        if (typeof value === 'function') return `[Function: ${value.name || 'anonymous'}]`;\n        if (typeof value !== 'object') return value;\n\n        if (context.depth >= this.config.maxDepth) {\n            return '[Max Depth]';\n        }\n\n        if (context.seen.has(value)) {\n            switch (this.config.circular) {\n                case 'error':\n                    throw new Error(`Circular reference at ${context.path.join('.')}`);\n                case 'skip':\n                    return undefined;\n                case 'placeholder':\n                default:\n                    return '[Circular]';\n            }\n        }\n        context.seen.add(value);\n\n        const serializer = this.findSerializer(value);\n        if (serializer) {\n            return serializer.serializer(value, context);\n        }\n\n        if (Array.isArray(value)) {\n            return value.map((item, i) =>\n                this.serializeInternal(item, {\n                    ...context,\n                    depth: context.depth + 1,\n                    path: [...context.path, `[${i}]`]\n                })\n            );\n        }\n\n        const result: Record<string, any> = {};\n        for (const [key, val] of Object.entries(value)) {\n            result[key] = this.serializeInternal(val, {\n                ...context,\n                depth: context.depth + 1,\n                path: [...context.path, key]\n            });\n        }\n        return result;\n    }\n\n    /**\n     * Serializa un valor arbitrario a una representación segura para transporte\n     * (JSON, remote log, OTLP, etc.).\n     *\n     * Entry point público del pipeline. Construye un {@link SerializerContext}\n     * fresco (depth 0, path vacío, `WeakSet` nuevo para detección de ciclos),\n     * merguea overrides de `config` sobre los del constructor y delega a\n     * {@link SerializerRegistry.serializeInternal}.\n     *\n     * @param {any} value - Valor a serializar. Cualquier tipo.\n     * @param {SerializerConfig} [config] - Overrides puntuales para esta llamada\n     *   (no mutan la config del registry). Útil para, p.ej., subir `maxDepth`\n     *   sólo en un log concreto.\n     * @returns {any} Valor serializable. Para objetos sin serializer registrado\n     *   se devuelve un plain object; para tipos builtin, la shape definida en\n     *   {@link SerializerRegistry.registerDefaults}; para los cortes de\n     *   profundidad o circular, los placeholders `'[Max Depth]'` / `'[Circular]'`.\n     * @throws {Error} Sólo si `circular: 'error'` y se detecta una referencia circular.\n     *\n     * @example\n     * ```ts\n     * // Objetos simples\n     * registry.serialize({ a: 1, b: [2, 3] });\n     * // → { a: 1, b: [2, 3] }\n     *\n     * // Errores (serializer builtin)\n     * registry.serialize(new Error('boom'));\n     * // → { name: 'Error', message: 'boom', stack: [...] }\n     *\n     * // Referencia circular → placeholder\n     * const o: any = {};\n     * o.self = o;\n     * registry.serialize(o); // → { self: '[Circular]' }\n     *\n     * // Override puntual de maxDepth\n     * registry.serialize(deepObj, { maxDepth: 2 });\n     * ```\n     *\n     * @see {@link SerializerRegistry.serializeInternal} para el detalle del pipeline.\n     */\n    serialize(value: any, config?: SerializerConfig): any {\n        const mergedConfig = { ...this.config, ...config };\n        return this.serializeInternal(value, {\n            depth: 0,\n            maxDepth: mergedConfig.maxDepth,\n            path: [],\n            seen: new WeakSet()\n        });\n    }\n}\n\n/**\n * Cache del singleton de {@link SerializerRegistry}. Module-private.\n *\n * @internal\n */\nlet _defaultRegistry: SerializerRegistry | null = null;\n\n/**\n * Devuelve el singleton de {@link SerializerRegistry} (lo crea con config\n * default en la primera llamada). Es la vía canónica de obtener el registry\n * compartido que usa el Logger internamente.\n *\n * @returns {SerializerRegistry} Instancia singleton.\n *\n * @example\n * ```ts\n * import { getDefaultSerializerRegistry } from '@mks2508/better-logger/serializers';\n *\n * const registry = getDefaultSerializerRegistry();\n * if (!registry.has(CustomError)) {\n *   registry.add(CustomError, (e) => ({ code: e.code, message: e.message }), 95);\n * }\n * ```\n     */\nexport function getDefaultSerializerRegistry(): SerializerRegistry {\n    if (!_defaultRegistry) {\n        _defaultRegistry = new SerializerRegistry();\n    }\n    return _defaultRegistry;\n}\n","/**\n * @fileoverview SerializerBridge — facade de SerializerRegistry.\n * Encapsula registro, eliminación y acceso al registry de serializers.\n *\n * @internal\n */\n\nimport type { SerializerFn } from '../types/index.js';\nimport { SerializerRegistry } from './index.js';\n\n/**\n * Bridge para la gestión de serializers.\n *\n * @internal\n */\nexport interface SerializerBridge {\n    /** Añade un serializer para un tipo. */\n    addSerializer<T>(type: new (...args: unknown[]) => T, serializer: SerializerFn<T>, priority?: number): void;\n    /** Elimina el serializer asociado a un tipo. Devuelve `true` si se eliminó. */\n    removeSerializer<T>(type: new (...args: unknown[]) => T): boolean;\n    /** Devuelve el registry subyacente. */\n    getSerializerRegistry(): SerializerRegistry;\n}\n\n/**\n * Crea una instancia de {@link SerializerBridge}.\n *\n * @internal\n */\nexport function createSerializerBridge(): SerializerBridge {\n    const serializerRegistry = new SerializerRegistry();\n\n    return {\n        addSerializer<T>(type: new (...args: unknown[]) => T, serializer: SerializerFn<T>, priority?: number): void {\n            serializerRegistry.add(type, serializer, priority);\n        },\n\n        removeSerializer<T>(type: new (...args: unknown[]) => T): boolean {\n            return serializerRegistry.remove(type);\n        },\n\n        getSerializerRegistry(): SerializerRegistry {\n            return serializerRegistry;\n        }\n    };\n}\n"],"mappings":"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"}