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

package/dist/chunks/LogContext-DjlITOzZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogContext-DjlITOzZ.js","names":[],"sources":["../../src/context/LogContext.ts"],"sourcesContent":["/**\n * @fileoverview Bridge de LogContext — gestión de MDC (Mapped Diagnostic Context).\n *\n * Encapsula el contexto estructurado por logger, la creación de child loggers y\n * el merge de resource OTel en cada record emitido.\n *\n * Modelo de API:\n * - `withContext(bindings, fn?)` — si se pasa `fn`, lo ejecuta dentro de un\n *   scope de AsyncLocalStorage mergeando `bindings`. Sin `fn`: no-op (shim de\n *   backwards compat para la vieja forma de setter).\n * - `withContextAsync(bindings, fn)` — variante async callback.\n * - `child(bindings)` — inmutable (patrón canónico de MDC).\n * - Feature-detect de AsyncLocalStorage; en browser sin ALS es no-op.\n */\n\nimport type { ILogResourceRef } from '../types/index.js';\nimport type { LoggerConfig } from '../types/index.js';\n\n/**\n * Snapshot del contexto bound. Lo retorna {@link LogContext.getContext}.\n *\n * Es `Readonly` para marcar contractually que el objeto devuelto es una shallow\n * copy: mutarlo no afecta a los records que emitan futuras llamadas de log.\n */\nexport type ContextSnapshot = Readonly<Record<string, unknown>>;\n\n/**\n * Tipo de la factory function para crear instancias child de Logger.\n *\n * Se inyecta en LogContext para que `child()` pueda instanciar nuevos loggers\n * sin introducir un import circular entre `Logger.ts` y `LogContext.ts`.\n * Retorna `unknown` — la clase Logger concreta la maneja el caller, y la\n * instancia devuelta tiene su campo `context` escrito por LogContext tras la\n * creación.\n */\nexport type ChildLoggerFactory = (config: Partial<LoggerConfig>) => unknown;\n\n/**\n * Shape mínima de una instancia de Logger que LogContext necesita ver.\n *\n * Evita dependencias circulares entre LogContext y Logger. El campo\n * `_parentContextRecord` lo setea el Logger padre después de que\n * `LogContext.child()` retorna, estableciendo la cadena de contextos.\n */\nexport interface ChildLoggerShape {\n    _parentContextRecord?: Record<string, unknown>;\n    /** Campo legacy — ya no es la fuente canónica del contexto. */\n    context?: Record<string, unknown>;\n}\n\n/**\n * Options que se pasan a {@link createLogContext}.\n */\nexport interface ILogContextOptions {\n    /** Pares key-value iniciales del contexto. */\n    initialContext?: Record<string, unknown>;\n    /** Factory para crear instancias child de logger. */\n    childLoggerFactory: ChildLoggerFactory;\n    /** Resource OTel inicial a mergear en cada record emitido. */\n    initialResource?: Partial<ILogResourceRef>;\n    /**\n     * Retorna el record de contexto mergeado del logger padre en el momento\n     * de creación del child. Lo usa `_getContextRecord()` para construir la\n     * cadena de contextos.\n     * @internal\n     */\n    getParentContextRecord?: () => Record<string, unknown>;\n    /**\n     * Instancia de AsyncLocalStorage a usar para el scoping de `withContext`.\n     * @internal\n     */\n    alsInstance?: ALS;\n}\n\n/**\n * Contrato que retorna {@link createLogContext}.\n *\n * Fachada de MDC (Mapped Diagnostic Context) por logger. Combina tres fuentes\n * de contexto:\n * - **base inmutable** vía `child()` (snapshot capturado al crear el child),\n * - **scope transitorio** vía `withContext()` / `withContextAsync()` sobre\n *   AsyncLocalStorage,\n * - **resource OTel** mergeado en cada record.\n *\n * En entornos browser sin `AsyncLocalStorage`, las variantes `withContext*`\n * degradan a no-op: ejecutan `fn` sin scoping (o lo skipan si no hay `fn`).\n * `child()` sigue operativo en browser porque no depende de ALS.\n */\nexport interface LogContext {\n    /**\n     * Snapshot actual del contexto bound.\n     *\n     * @returns Copia inmutable (shallow) del contexto; mutarla no afecta a los\n     * records que emitan futuras llamadas de log.\n     *\n     * @example\n     * const ctx = logContext.getContext();\n     * console.log(ctx.requestId); // 'abc-123'\n     */\n    getContext(): ContextSnapshot;\n\n    /**\n     * Ejecuta `fn` dentro de un scope de AsyncLocalStorage donde `bindings`\n     * se mergean al contexto para todas las llamadas de log dentro de `fn`.\n     *\n     * Si no se pasa `fn` (la vieja forma de setter), es no-op por backwards\n     * compatibility. Para binding persistente prefiere `child()`; para\n     * callbacks async usa `withContextAsync()`.\n     *\n     * **Browser fallback**: sin ALS, ejecuta `fn` directamente sin scoping\n     * (los bindings NO se mergean). Si tampoco hay `fn`, retorna `undefined`.\n     *\n     * @param bindings - Pares key-value a attachar durante la ejecución de `fn`\n     * @param fn - Función sincrónica opcional a ejecutar bajo el scope ALS\n     * @returns El valor de retorno de `fn`, o `undefined` si no se pasa `fn`\n     *\n     * @example\n     * logContext.withContext({ requestId: 'abc-123' }, () => {\n     *   logger.info('procesando'); // el record lleva requestId=abc-123\n     * });\n     * // fuera de fn: requestId ya no está presente en próximos logs\n     *\n     * @see {@link LogContext.withContextAsync} para callbacks async\n     * @see {@link LogContext.child} para binding persistente inmutable (sin ALS)\n     */\n    withContext<R>(bindings: Record<string, unknown>, fn?: () => R): R | undefined;\n\n    /**\n     * Variante async de {@link withContext}. Ejecuta `fn` dentro de un scope\n     * de AsyncLocalStorage para que los bindings queden disponibles a todas las\n     * llamadas de log async dentro de `fn` (incluso tras `await`).\n     *\n     * **Browser fallback**: sin ALS, ejecuta `fn` directamente sin scoping.\n     *\n     * @param bindings - Pares key-value a attachar durante la ejecución de `fn`\n     * @param fn - Función async a ejecutar bajo el scope ALS\n     * @returns El Promise retornado por `fn`\n     *\n     * @example\n     * await logContext.withContextAsync({ traceId }, async () => {\n     *   const user = await fetchUser();\n     *   logger.info('user cargado', { id: user.id });\n     *   // el record lleva el traceId aunque el log ocurra tras un await\n     * });\n     */\n    withContextAsync<R>(bindings: Record<string, unknown>, fn: () => Promise<R>): Promise<R>;\n\n    /**\n     * Droppea todas las keys del contexto bound. Tras esta llamada, los\n     * records emitidos ya no llevan `attributes` hasta que\n     * {@link withContext} o {@link child} restablezcan uno.\n     *\n     * @returns La misma instancia de LogContext, ahora sin contexto\n     *\n     * @example\n     * logContext.clearContext();\n     * logger.info('limpio'); // sin attributes\n     */\n    clearContext(): this;\n\n    /**\n     * Actualiza el resource OTel por defecto (service.name, version,\n     * deployment.environment, ...).\n     *\n     * Se persiste en el campo `resource` de cada record emitido, salvo que el\n     * propio record lo overridee.\n     *\n     * @param resource - Resource OTel parcial a mergear con el actual\n     * @returns La misma instancia de LogContext, para encadenar calls\n     *\n     * @example\n     * logContext.setResource({ serviceName: 'api-gateway', environment: 'prod' });\n     */\n    setResource(resource: Partial<ILogResourceRef>): this;\n\n    /**\n     * Devuelve una copia inmutable de este logger con el contexto extra bound.\n     *\n     * Las llamadas futuras sobre el child emiten con el contexto mergeado, sin\n     * mutar al padre — patrón canónico de MDC.\n     *\n     * A diferencia de {@link withContext}, **no involucra AsyncLocalStorage**:\n     * el binding es persistente y queda capturado en el snapshot del child al\n     * crearse. Por eso `child()` es operativo también en browser sin ALS.\n     *\n     * Los bindings transitorios de ALS activos en el momento de `child()` NO\n     * se bakean en el child — solo se captura el contexto base. ALS se aplica\n     * fresco en cada dispatch vía `_getContextRecord()`.\n     *\n     * @param extra - Pares key-value a attachar (requestId, userId, ...)\n     * @returns Un nuevo Logger con el contexto mergeado\n     *\n     * @example\n     * const requestLog = logContext.child({ requestId: 'abc-123' });\n     * requestLog.info('inicio');   // siempre lleva requestId=abc-123\n     * requestLog.info('fin');\n     * // el logger padre no se ve afectado por estos bindings\n     *\n     * @see {@link LogContext.withContext} para scoping transitorio (ALS)\n     */\n    child(extra: Record<string, unknown>): ChildLoggerShape;\n\n    /**\n     * Record de contexto interno. Expuesto para el ensamblado de TransportRecord\n     * (base + overlay ALS si hay store activo).\n     * @internal\n     */\n    _getContextRecord(): Record<string, unknown>;\n    /**\n     * Retorna el contexto base SIN el overlay de ALS.\n     *\n     * Lo usa `Logger.child()` para capturar el snapshot del contexto padre al\n     * crear un child logger, garantizando que el binding ALS transitorio no\n     * se bakeé en el child.\n     * @internal\n     */\n    _getBaseContextRecord(): Record<string, unknown>;\n    /**\n     * Record de resource interno. Expuesto para el ensamblado de TransportRecord.\n     * @internal\n     */\n    _getResource(): Partial<ILogResourceRef> | undefined;\n    /**\n     * Retorna el store actual de AsyncLocalStorage, si ALS está activo en el\n     * call stack corriente.\n     * @internal\n     */\n    _getAlsStore(): Record<string, unknown> | undefined;\n}\n\n// AsyncLocalStorage type (Node 14+, undefined in browser)\ntype ALS = {\n    run<R>(store: Record<string, unknown>, fn: () => R): R;\n    getStore(): Record<string, unknown> | undefined;\n};\ndeclare const AsyncLocalStorage: new () => ALS;\n\n// Feature-detect AsyncLocalStorage\nconst hasALS = typeof AsyncLocalStorage !== 'undefined';\nconst alsInstance: ALS | undefined = hasALS ? new AsyncLocalStorage() : undefined;\n\n/**\n * Factory que crea una instancia de {@link LogContext}.\n *\n * @param options - Configuración (ver {@link ILogContextOptions})\n * @returns Una instancia de LogContext lista para usar\n *\n * @example\n * const logContext = createLogContext({\n *   childLoggerFactory: (cfg) => new Logger(cfg),\n *   initialContext: { service: 'orders-api' },\n *   initialResource: { serviceName: 'orders-api', environment: 'prod' }\n * });\n *\n * // Child inmutable con contexto persistente\n * const requestLog = logContext.child({ requestId: 'abc-123' });\n *\n * // Scope transitorio vía ALS (Node; en browser sin ALS es no-op)\n * logContext.withContext({ traceId: 't-9' }, () => {\n *   requestLog.info('procesando orden');\n * });\n */\nexport function createLogContext(options: ILogContextOptions): LogContext {\n    let context: Record<string, unknown> = { ...options.initialContext };\n    let resource: Partial<ILogResourceRef> | undefined = options.initialResource\n        ? { ...options.initialResource }\n        : undefined;\n\n    // Use provided ALS instance or fall back to module-level (browser fallback)\n    const als = options.alsInstance ?? alsInstance;\n\n    return {\n        getContext(): ContextSnapshot {\n            return { ...context };\n        },\n\n        withContext<R>(bindings: Record<string, unknown>, fn?: () => R): R | undefined {\n            // No-op without AsyncLocalStorage (browser) — warn once\n            if (!als) {\n                if (fn) return fn();\n                return undefined;\n            }\n            // No fn: backwards-compat no-op setter shim\n            if (!fn) return undefined;\n            // Run fn within AsyncLocalStorage scope\n            const merged = { ...context, ...bindings };\n            return als.run(merged, fn);\n        },\n\n        async withContextAsync<R>(bindings: Record<string, unknown>, fn: () => Promise<R>): Promise<R> {\n            if (!als) return fn();\n            const merged = { ...context, ...bindings };\n            return als.run(merged, fn);\n        },\n\n        clearContext(): typeof this {\n            context = {};\n            return this;\n        },\n\n        setResource(res: Partial<ILogResourceRef>): typeof this {\n            resource = { ...resource, ...res };\n            return this;\n        },\n\n        child(_extra: Record<string, unknown>): ChildLoggerShape {\n            // Creates the child logger via factory. Captures the current\n            // _getBaseContextRecord() snapshot (parent context WITHOUT ALS) at\n            // child-creation time. ALS is transient and should not be baked into\n            // the child's _parentContextRecord — it is applied fresh at dispatch time.\n            // Note: _extra (bindings) are stored by Logger.child() as _bindings.\n            const snapshot = this._getBaseContextRecord();\n            const childLogger = options.childLoggerFactory({}) as ChildLoggerShape;\n            // Store on childLogger for Logger.child() to pick up\n            (childLogger as unknown as Record<string, unknown>)['__parentSnapshot'] = snapshot;\n            return childLogger;\n        },\n\n        _getContextRecord(): Record<string, unknown> {\n            // Returns the full merged context for dispatch purposes.\n            // Base (parent snapshot + own context) plus ALS overlay if active.\n            const base = this._getBaseContextRecord();\n            const alsContext = als?.getStore();\n            if (alsContext && Object.keys(alsContext).length > 0) {\n                return { ...base, ...alsContext };\n            }\n            return base;\n        },\n\n        _getBaseContextRecord(): Record<string, unknown> {\n            // Returns parent context chain + own context (NO ALS overlay).\n            // ALS is applied by _getContextRecord() as a live overlay.\n            let base: Record<string, unknown> = {};\n            const parentRecord = options.getParentContextRecord?.() ?? null;\n            if (parentRecord && Object.keys(parentRecord).length > 0) {\n                base = parentRecord;\n            } else if (Object.keys(context).length > 0) {\n                base = context;\n            }\n            if (Object.keys(context).length > 0) {\n                base = { ...base, ...context };\n            }\n            return base;\n        },\n\n        _getResource(): Partial<ILogResourceRef> | undefined {\n            return resource;\n        },\n\n        _getAlsStore(): Record<string, unknown> | undefined {\n            return als?.getStore();\n        }\n    };\n}\n"],"mappings":";AA+OA,MAAM,cADS,OAAO,sBAAsB,cACE,IAAI,kBAAkB,IAAI,KAAA;;;;;;;;;;;;;;;;;;;;;;AAuBxE,SAAgB,iBAAiB,SAAyC;CACtE,IAAI,UAAmC,EAAE,GAAG,QAAQ,eAAe;CACnE,IAAI,WAAiD,QAAQ,kBACvD,EAAE,GAAG,QAAQ,gBAAgB,IAC7B,KAAA;CAGN,MAAM,MAAM,QAAQ,eAAe;CAEnC,OAAO;EACH,aAA8B;GAC1B,OAAO,EAAE,GAAG,QAAQ;EACxB;EAEA,YAAe,UAAmC,IAA6B;GAE3E,IAAI,CAAC,KAAK;IACN,IAAI,IAAI,OAAO,GAAG;IAClB;GACJ;GAEA,IAAI,CAAC,IAAI,OAAO,KAAA;GAEhB,MAAM,SAAS;IAAE,GAAG;IAAS,GAAG;GAAS;GACzC,OAAO,IAAI,IAAI,QAAQ,EAAE;EAC7B;EAEA,MAAM,iBAAoB,UAAmC,IAAkC;GAC3F,IAAI,CAAC,KAAK,OAAO,GAAG;GACpB,MAAM,SAAS;IAAE,GAAG;IAAS,GAAG;GAAS;GACzC,OAAO,IAAI,IAAI,QAAQ,EAAE;EAC7B;EAEA,eAA4B;GACxB,UAAU,CAAC;GACX,OAAO;EACX;EAEA,YAAY,KAA4C;GACpD,WAAW;IAAE,GAAG;IAAU,GAAG;GAAI;GACjC,OAAO;EACX;EAEA,MAAM,QAAmD;GAMrD,MAAM,WAAW,KAAK,sBAAsB;GAC5C,MAAM,cAAc,QAAQ,mBAAmB,CAAC,CAAC;GAEjD,YAAoD,sBAAsB;GAC1E,OAAO;EACX;EAEA,oBAA6C;GAGzC,MAAM,OAAO,KAAK,sBAAsB;GACxC,MAAM,aAAa,KAAK,SAAS;GACjC,IAAI,cAAc,OAAO,KAAK,UAAU,CAAC,CAAC,SAAS,GAC/C,OAAO;IAAE,GAAG;IAAM,GAAG;GAAW;GAEpC,OAAO;EACX;EAEA,wBAAiD;GAG7C,IAAI,OAAgC,CAAC;GACrC,MAAM,eAAe,QAAQ,yBAAyB,KAAK;GAC3D,IAAI,gBAAgB,OAAO,KAAK,YAAY,CAAC,CAAC,SAAS,GACnD,OAAO;QACJ,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,SAAS,GACrC,OAAO;GAEX,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,SAAS,GAC9B,OAAO;IAAE,GAAG;IAAM,GAAG;GAAQ;GAEjC,OAAO;EACX;EAEA,eAAqD;GACjD,OAAO;EACX;EAEA,eAAoD;GAChD,OAAO,KAAK,SAAS;EACzB;CACJ;AACJ"}

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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"}