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

package/dist/chunks/SerializerBridge-C4a9Z37F.cjs

@@ -0,0 +1,410 @@
+//#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
+Object.defineProperty(exports, "SerializerRegistry", {
+	enumerable: true,
+	get: function() {
+		return SerializerRegistry;
+	}
+});
+Object.defineProperty(exports, "createSerializerBridge", {
+	enumerable: true,
+	get: function() {
+		return createSerializerBridge;
+	}
+});
+Object.defineProperty(exports, "getDefaultSerializerRegistry", {
+	enumerable: true,
+	get: function() {
+		return getDefaultSerializerRegistry;
+	}
+});
+
+//# sourceMappingURL=SerializerBridge-C4a9Z37F.cjs.map

package/dist/chunks/SerializerBridge-C4a9Z37F.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SerializerBridge-C4a9Z37F.cjs","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":";;;;;;;AAmBA,MAAM,iBAA6C;CAC/C,UAAU;CACV,UAAU;CACV,mBAAmB;AACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,IAAa,qBAAb,MAA+D;CAC3D,8BAAsD,IAAI,IAAI;CAC9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BA,YAAY,SAA2B,CAAC,GAAG;EACvC,KAAK,SAAS;GAAE,GAAG;GAAgB,GAAG;EAAO;EAC7C,KAAK,iBAAiB;CAC1B;;;;;;;;;;;;;;;;;;CAmBA,mBAAiC;EAC7B,KAAK,IAAI,QAAQ,SAAgB;GAC7B,MAAM,IAAI;GACV,SAAS,IAAI;GACb,OAAO,IAAI,OAAO,MAAM,IAAI,CAAC,CAAC,MAAM,GAAG,EAAE;GACzC,GAAI,IAAI,QAAQ,EAAE,OAAO,KAAK,UAAU,IAAI,KAAK,EAAE,IAAI,CAAC;EAC5D,IAAI,GAAG;EAEP,KAAK,IAAI,OAAO,UAAgB;GAC5B,KAAK,KAAK,YAAY;GACtB,WAAW,KAAK,QAAQ;EAC5B,IAAI,EAAE;EAEN,KAAK,IAAI,SAAS,WAAmB;GACjC,SAAS,MAAM;GACf,OAAO,MAAM;EACjB,IAAI,EAAE;EAEN,KAAK,IAAI,MAAM,KAAoB,QAAQ;GACvC,MAAM,MAA2B,CAAC;GAClC,IAAI,SAAS,OAAO,QAAQ;IACxB,MAAM,SAAS,OAAO,QAAQ,WAAW,KAAK,UAAU,GAAG,IAAI,OAAO,GAAG;IACzE,IAAI,UAAU,KAAK,kBAAkB,OAAO;KACxC,GAAG;KACH,OAAO,IAAI,QAAQ;KACnB,MAAM,CAAC,GAAG,IAAI,MAAM,MAAM;IAC9B,CAAC;GACL,CAAC;GACD,OAAO;IAAE,QAAQ;IAAO,SAAS;GAAI;EACzC,GAAG,EAAE;EAEL,KAAK,IAAI,MAAM,KAAe,SAAS;GACnC,QAAQ;GACR,QAAQ,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,GAAG,MAC5B,KAAK,kBAAkB,GAAG;IACtB,GAAG;IACH,OAAO,IAAI,QAAQ;IACnB,MAAM,CAAC,GAAG,IAAI,MAAM,IAAI,EAAE,EAAE;GAChC,CAAC,CACL;EACJ,IAAI,EAAE;EAEN,IAAI,OAAO,WAAW,aAClB,KAAK,IAAI,SAAgB,SAAiB;GACtC,QAAQ;GACR,QAAQ,IAAI;GACZ,SAAS,IAAI,MAAM,GAAG,EAAE,CAAC,CAAC,SAAS,KAAK;EAC5C,IAAI,EAAE;CAEd;;;;;;;;;;;;;;;;;;;;;;;;;CA0BA,IACI,MACA,YACA,WAAmB,IACf;EACJ,KAAK,YAAY,IAAI,MAAM;GAAE;GAAM;GAAY;EAAS,CAAC;CAC7D;;;;;;;;;;;;;CAcA,OAAU,MAA0C;EAChD,OAAO,KAAK,YAAY,OAAO,IAAI;CACvC;;;;;;;;;;;;;;CAeA,IAAO,MAA0C;EAC7C,OAAO,KAAK,YAAY,IAAI,IAAI;CACpC;;;;;;;;;;;;;;;;;CAkBA,SAA4B;EACxB,OAAO,MAAM,KAAK,KAAK,YAAY,OAAO,CAAC,CAAC,CACvC,MAAM,GAAG,OAAO,EAAE,YAAY,OAAO,EAAE,YAAY,GAAG;CAC/D;;;;;;;;;CAUA,eAAuB,OAAoC;EACvD,MAAM,SAAS,KAAK,OAAO;EAC3B,KAAK,MAAM,SAAS,QAChB,IAAI,iBAAiB,MAAM,MACvB,OAAO;EAGf,OAAO;CACX;;;;;;;;;;;;;;;;;;;;;;;;;CA0BA,kBAA0B,OAAY,SAAiC;EACnE,IAAI,UAAU,MAAM,OAAO;EAC3B,IAAI,UAAU,KAAA,GAAW,OAAO,KAAK,OAAO,oBAAoB,KAAA,IAAY;EAC5E,IAAI,OAAO,UAAU,YAAY,OAAO,cAAc,MAAM,QAAQ,YAAY;EAChF,IAAI,OAAO,UAAU,UAAU,OAAO;EAEtC,IAAI,QAAQ,SAAS,KAAK,OAAO,UAC7B,OAAO;EAGX,IAAI,QAAQ,KAAK,IAAI,KAAK,GACtB,QAAQ,KAAK,OAAO,UAApB;GACI,KAAK,SACD,MAAM,IAAI,MAAM,yBAAyB,QAAQ,KAAK,KAAK,GAAG,GAAG;GACrE,KAAK,QACD;GAEJ,SACI,OAAO;EACf;EAEJ,QAAQ,KAAK,IAAI,KAAK;EAEtB,MAAM,aAAa,KAAK,eAAe,KAAK;EAC5C,IAAI,YACA,OAAO,WAAW,WAAW,OAAO,OAAO;EAG/C,IAAI,MAAM,QAAQ,KAAK,GACnB,OAAO,MAAM,KAAK,MAAM,MACpB,KAAK,kBAAkB,MAAM;GACzB,GAAG;GACH,OAAO,QAAQ,QAAQ;GACvB,MAAM,CAAC,GAAG,QAAQ,MAAM,IAAI,EAAE,EAAE;EACpC,CAAC,CACL;EAGJ,MAAM,SAA8B,CAAC;EACrC,KAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,KAAK,GACzC,OAAO,OAAO,KAAK,kBAAkB,KAAK;GACtC,GAAG;GACH,OAAO,QAAQ,QAAQ;GACvB,MAAM,CAAC,GAAG,QAAQ,MAAM,GAAG;EAC/B,CAAC;EAEL,OAAO;CACX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CA,UAAU,OAAY,QAAgC;EAClD,MAAM,eAAe;GAAE,GAAG,KAAK;GAAQ,GAAG;EAAO;EACjD,OAAO,KAAK,kBAAkB,OAAO;GACjC,OAAO;GACP,UAAU,aAAa;GACvB,MAAM,CAAC;GACP,sBAAM,IAAI,QAAQ;EACtB,CAAC;CACL;AACJ;;;;;;AAOA,IAAI,mBAA8C;;;;;;;;;;;;;;;;;;AAmBlD,SAAgB,+BAAmD;CAC/D,IAAI,CAAC,kBACD,mBAAmB,IAAI,mBAAmB;CAE9C,OAAO;AACX;;;;;;;;ACtYA,SAAgB,yBAA2C;CACvD,MAAM,qBAAqB,IAAI,mBAAmB;CAElD,OAAO;EACH,cAAiB,MAAqC,YAA6B,UAAyB;GACxG,mBAAmB,IAAI,MAAM,YAAY,QAAQ;EACrD;EAEA,iBAAoB,MAA8C;GAC9D,OAAO,mBAAmB,OAAO,IAAI;EACzC;EAEA,wBAA4C;GACxC,OAAO;EACX;CACJ;AACJ"}

package/dist/chunks/{StyleManager-CIpd6wbO.cjs → StyleManager-DQ6UNRB-.cjs}

@@ -1,13 +1,13 @@
-const require_styling = require("./styling-Cg5saQ46.cjs");
+const require_styling = require("./styling-Cel2wPRy.cjs");
 //#region src/styles/StyleManager.ts
 /**
-* @fileoverview StyleManager — style preset and display settings management.
-* Encapsulates active preset tracking, display toggles, and the
-* module-level LEVEL_STYLES variable.
+* @fileoverview StyleManager — gestión de presets de estilo y display settings.
 *
-* Wired into Logger.ts in F4. Logger delegates style queries and theme
-* changes through this bridge so that the module-level LEVEL_STYLES stay
-* in sync across the module.
+* Encapsula el tracking del preset activo, los toggles de visibilidad del
+* output (timestamp, location, badges) y la variable de módulo
+* {@link LEVEL_STYLES}. El Logger delega en este bridge la resolución de
+* estilos y los cambios de theme para mantener sincronizado el estado
+* compartido a nivel módulo.
 */
 function createDefaultDisplaySettings() {
 	return {
@@ -17,7 +17,27 @@ function createDefaultDisplaySettings() {
 	};
 }
 /**
-* Creates a StyleManager instance.
+* Crea una instancia de {@link StyleManager} con display settings por defecto
+* (o los overrides que se pasen en `options`).
+*
+* Cada instancia mantiene su propio estado de preset/customization/display,
+* pero la backing store de estilos activos ({@link LEVEL_STYLES}) es
+* module-scoped: dos StyleManagers comparten la misma vista de LEVEL_STYLES.
+*
+* @param options - Overrides opcionales para los display settings iniciales.
+*
+* @example
+* ```ts
+* const sm = createStyleManager({
+*   initialDisplaySettings: { showTimestamp: false, showBadges: true }
+* });
+*
+* sm.applyPreset('cyberpunk'); // aplica preset + ajusta toggles
+* sm.setTheme('dark');         // muta LEVEL_STYLES (global al módulo)
+* console.log(sm.getStyles()); // lee el LEVEL_STYLES vigente
+* ```
+*
+* @see {@link StyleManager} para el contrato completo del bridge.
 */
 function createStyleManager(options = {}) {
 	const displaySettings = createDefaultDisplaySettings();
@@ -77,8 +97,14 @@ function createStyleManager(options = {}) {
 	};
 }
 /**
-* Module-level active styles — shared across all Logger instances.
-* Exported so Logger can reference it directly.
+* Variable de módulo con el set de estilos activo, compartida por todas las
+* instancias de Logger/StyleManager que importan este módulo. Se exporta
+* `let` para que el Logger la pueda leer directamente sin pasar por el bridge.
+*
+* **Mutadores**: {@link StyleManager.setTheme} y {@link StyleManager.resetStyles}
+* (o el {@link resetStyles} exportado de este módulo) reasignan esta variable.
+* Cualquier referencia capturada con anterioridad queda stale — siempre leer
+* vía `LEVEL_STYLES` en punto de uso, no cacheandola.
 */
 let LEVEL_STYLES = require_styling.THEME_PRESETS.default;
 //#endregion
@@ -89,4 +115,4 @@ Object.defineProperty(exports, "createStyleManager", {
 	}
 });
 
-//# sourceMappingURL=StyleManager-CIpd6wbO.cjs.map
+//# sourceMappingURL=StyleManager-DQ6UNRB-.cjs.map

package/dist/chunks/StyleManager-DQ6UNRB-.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"StyleManager-DQ6UNRB-.cjs","names":["hasPreset","getSmartPreset","getAvailablePresets","THEME_PRESETS","themeRecord"],"sources":["../../src/styles/StyleManager.ts"],"sourcesContent":["/**\n * @fileoverview StyleManager — gestión de presets de estilo y display settings.\n *\n * Encapsula el tracking del preset activo, los toggles de visibilidad del\n * output (timestamp, location, badges) y la variable de módulo\n * {@link LEVEL_STYLES}. El Logger delega en este bridge la resolución de\n * estilos y los cambios de theme para mantener sincronizado el estado\n * compartido a nivel módulo.\n */\n\nimport {\n    THEME_PRESETS,\n    type StylePresets,\n    type StyleBuilder\n} from '../styling/index.js';\nimport { getSmartPreset, getAvailablePresets, hasPreset } from '../styling/SmartPresets.js';\nimport type { ThemeVariant, LogStyles } from '../types/index.js';\n\n/**\n * Re-export de `StyleBuilder` para consumo interno del Logger dentro de este\n * paquete. La API pública de styling vive en `../styling/index.ts`; este\n * re-export existe únicamente para evitar un segundo import cruzado desde\n * Logger.ts. No considerar parte del surface público de este módulo.\n *\n * @internal\n */\nexport { StyleBuilder } from '../styling/index.js';\n\n/**\n * Toggles de visibilidad que controlan qué metadatos acompañan a cada línea\n * de log en la salida formateada. Cada preset inteligente\n * (via {@link StyleManager.applyPreset}) puede imponer sus propios defaults\n * sobreescribiendo estos valores.\n */\nexport interface DisplaySettings {\n    /** Muestra (o no) el timestamp ISO al inicio de cada línea. */\n    showTimestamp: boolean;\n    /** Muestra (o no) la ubicación del caller (file:line) parseada del stack. */\n    showLocation: boolean;\n    /** Muestra (o no) los badges de scope/nivel junto al mensaje. */\n    showBadges: boolean;\n}\n\n/**\n * Snapshot del estado interno que el StyleManager trackea en closure:\n * preset activo, overrides de `customize()` y display settings vigentes.\n * Útil para serializar/inspeccionar el estado de styling sin exponer la\n * implementación del bridge.\n */\nexport interface PresetState {\n    /** Config de estilos resuelta (referencia a {@link LEVEL_STYLES}). */\n    styles: typeof THEME_PRESETS.default;\n    /** Config del smart-preset activo (si lo hay). */\n    activePreset: unknown;\n    /** Nombre del smart-preset activo (si lo hay). */\n    activePresetName: string | undefined;\n    /** Últimos overrides aplicados via `customize()`. */\n    customization: unknown;\n    /** Toggles de visibilidad del output. */\n    displaySettings: DisplaySettings;\n}\n\n/**\n * Opciones de construcción para {@link createStyleManager}.\n */\nexport interface IStyleManagerOptions {\n    /** Display settings iniciales (parciales: se merguean sobre los defaults). */\n    initialDisplaySettings?: Partial<DisplaySettings>;\n}\n\n/**\n * Bridge que gestiona presets de estilo, display settings y el ciclo de\n * theme switching para un Logger.\n *\n * Encapsula el estado de styling en una closure para que el Logger no\n * tenga que mantener boilerplate propio. La implementación por defecto\n * (ver {@link createStyleManager}) opera sobre la variable de módulo\n * compartida {@link LEVEL_STYLES}: esto significa que `setTheme()` y\n * `resetStyles()` mutan estado global visible para TODAS las instancias\n * de Logger que comparten el módulo. Cada Logger construye su propio\n * StyleManager, pero la backing store de estilos activos es module-scoped\n * — está pensado así para que cambiar de theme una vez afecte a toda la\n * app, pero conviene saberlo al instanciar múltiples loggers con intents\n * distintos.\n */\nexport interface StyleManager {\n    /**\n     * Devuelve un shallow clone de los display settings vigentes, de modo\n     * que el caller pueda leerlos sin riesgo de mutar el estado interno.\n     */\n    getDisplaySettings(): DisplaySettings;\n    /**\n     * Aplica un smart-preset por nombre. Si el preset existe, actualiza los\n     * toggles de display (`showTimestamp`/`showLocation`) según la config\n     * del preset y memoriza su nombre/config para que el renderer pueda\n     * regenerar el output si cambia el theme.\n     *\n     * @param name - Identificador del preset (ver {@link getAvailablePresets}).\n     * @returns `true` si el preset existe y se aplicó, `false` si no se encontró.\n     */\n    applyPreset(name: string): boolean;\n    /**\n     * Lista los identificadores de todos los smart-presets registrados.\n     * Útil para alimentar un selector de UI o validar input de usuario.\n     */\n    getAvailablePresets(): string[];\n    /**\n     * Devuelve la referencia actual a {@link LEVEL_STYLES}. Como es\n     * module-scoped, refleja el último `setTheme()`/`resetStyles()` aunque\n     * provenga de otra instancia.\n     */\n    getStyles(): typeof THEME_PRESETS.default;\n    /** Devuelve la config cruda del smart-preset activo (o `undefined`). */\n    getActivePreset(): unknown;\n    /** Nombre del smart-preset activo — útil para logging diagnóstico. */\n    getActivePresetName(): string | undefined;\n    /** Último override aplicado via `Logger.customize()` (si lo hubo). */\n    getCustomization(): unknown;\n    /**\n     * Persiste overrides de customización para que el renderer los consuma\n     * en el próximo render. No muta {@link LEVEL_STYLES}.\n     */\n    setCustomization(overrides: unknown): void;\n    /**\n     * Resuelve (sin mutar nada) el set de estilos que correspondería a un\n     * theme dado. Si el theme no existe en {@link THEME_PRESETS}, cae al\n     * preset `default`. Útil para previsualizar un theme sin aplicarlo.\n     *\n     * @param theme - Variante de theme soportada por {@link THEME_PRESETS}.\n     */\n    resolveThemeStyle(theme: ThemeVariant): typeof THEME_PRESETS.default;\n    /**\n     * Aplica el theme mutando la variable de módulo {@link LEVEL_STYLES}.\n     *\n     * **Side-effect global**: como `LEVEL_STYLES` se comparte entre todas\n     * las instancias de Logger del módulo, este cambio es visible para\n     * cualquier Logger que haya en el proceso. No hay undo a nivel\n     * instancia — llamar a {@link resetStyles} para volver al default.\n     *\n     * @param theme - Variante de theme soportada por {@link THEME_PRESETS}.\n     * @returns `true` si el theme existe y se aplicó, `false` si no se encontró.\n     */\n    setTheme(theme: ThemeVariant): boolean;\n    /**\n     * Restablece {@link LEVEL_STYLES} al preset `default` de\n     * {@link THEME_PRESETS}. Al igual que {@link setTheme}, afecta a todas\n     * las instancias de Logger del módulo.\n     */\n    resetStyles(): void;\n}\n\nfunction createDefaultDisplaySettings(): DisplaySettings {\n    return {\n        showTimestamp: true,\n        showLocation: true,\n        showBadges: true\n    };\n}\n\n/**\n * Crea una instancia de {@link StyleManager} con display settings por defecto\n * (o los overrides que se pasen en `options`).\n *\n * Cada instancia mantiene su propio estado de preset/customization/display,\n * pero la backing store de estilos activos ({@link LEVEL_STYLES}) es\n * module-scoped: dos StyleManagers comparten la misma vista de LEVEL_STYLES.\n *\n * @param options - Overrides opcionales para los display settings iniciales.\n *\n * @example\n * ```ts\n * const sm = createStyleManager({\n *   initialDisplaySettings: { showTimestamp: false, showBadges: true }\n * });\n *\n * sm.applyPreset('cyberpunk'); // aplica preset + ajusta toggles\n * sm.setTheme('dark');         // muta LEVEL_STYLES (global al módulo)\n * console.log(sm.getStyles()); // lee el LEVEL_STYLES vigente\n * ```\n *\n * @see {@link StyleManager} para el contrato completo del bridge.\n */\nexport function createStyleManager(options: IStyleManagerOptions = {}): StyleManager {\n    const displaySettings = createDefaultDisplaySettings();\n    let activePreset: unknown;\n    let activePresetName: string | undefined;\n    let customization: unknown;\n\n    return {\n        getDisplaySettings(): DisplaySettings {\n            return { ...displaySettings };\n        },\n\n        applyPreset(name: string): boolean {\n            if (!hasPreset(name)) {\n                return false;\n            }\n\n            const presetConfig = getSmartPreset(name);\n            if (presetConfig) {\n                displaySettings.showTimestamp = presetConfig.timestamp?.show ?? true;\n                displaySettings.showLocation = presetConfig.location?.show ?? true;\n                activePreset = presetConfig;\n                activePresetName = name;\n            }\n            return true;\n        },\n\n        getAvailablePresets(): string[] {\n            return getAvailablePresets();\n        },\n\n        getStyles(): typeof THEME_PRESETS.default {\n            return LEVEL_STYLES;\n        },\n\n        getActivePreset(): unknown {\n            return activePreset;\n        },\n\n        getActivePresetName(): string | undefined {\n            return activePresetName;\n        },\n\n        getCustomization(): unknown {\n            return customization;\n        },\n\n        setCustomization(overrides: unknown): void {\n            customization = overrides;\n        },\n\n        resolveThemeStyle(theme: ThemeVariant): typeof THEME_PRESETS.default {\n            if (theme in THEME_PRESETS) {\n                const themeRecord = THEME_PRESETS as unknown as Record<string, typeof LEVEL_STYLES>;\n                return themeRecord[theme] ?? THEME_PRESETS.default;\n            }\n            return THEME_PRESETS.default;\n        },\n\n        setTheme(theme: ThemeVariant): boolean {\n            if (theme in THEME_PRESETS) {\n                const themeRecord = THEME_PRESETS as unknown as Record<string, typeof LEVEL_STYLES>;\n                const newStyles = themeRecord[theme];\n                if (newStyles) {\n                    LEVEL_STYLES = newStyles;\n                    return true;\n                }\n            }\n            return false;\n        },\n\n        resetStyles(): void {\n            LEVEL_STYLES = THEME_PRESETS.default;\n        }\n    };\n}\n\n/**\n * Variable de módulo con el set de estilos activo, compartida por todas las\n * instancias de Logger/StyleManager que importan este módulo. Se exporta\n * `let` para que el Logger la pueda leer directamente sin pasar por el bridge.\n *\n * **Mutadores**: {@link StyleManager.setTheme} y {@link StyleManager.resetStyles}\n * (o el {@link resetStyles} exportado de este módulo) reasignan esta variable.\n * Cualquier referencia capturada con anterioridad queda stale — siempre leer\n * vía `LEVEL_STYLES` en punto de uso, no cacheandola.\n */\nexport let LEVEL_STYLES: typeof THEME_PRESETS.default = THEME_PRESETS.default;\n\n/**\n * Restablece {@link LEVEL_STYLES} al preset `default` de {@link THEME_PRESETS}.\n *\n * Equivalente a invocar {@link StyleManager.resetStyles} sobre cualquier\n * instancia, expuesto como función libre para que código externo al Logger\n * (CLIs, tooling, tests) pueda resetear el módulo sin tener que sostener una\n * referencia al StyleManager. Mismo side-effect global que `setTheme`.\n *\n * @example\n * ```ts\n * import { resetStyles } from '@mks2508/better-logger/styles';\n * resetStyles(); // vuelve al theme default para todos los loggers del módulo\n * ```\n */\nexport function resetStyles(): void {\n    LEVEL_STYLES = THEME_PRESETS.default;\n}\n"],"mappings":";;;;;;;;;;;AAuJA,SAAS,+BAAgD;CACrD,OAAO;EACH,eAAe;EACf,cAAc;EACd,YAAY;CAChB;AACJ;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,mBAAmB,UAAgC,CAAC,GAAiB;CACjF,MAAM,kBAAkB,6BAA6B;CACrD,IAAI;CACJ,IAAI;CACJ,IAAI;CAEJ,OAAO;EACH,qBAAsC;GAClC,OAAO,EAAE,GAAG,gBAAgB;EAChC;EAEA,YAAY,MAAuB;GAC/B,IAAI,CAACA,gBAAAA,UAAU,IAAI,GACf,OAAO;GAGX,MAAM,eAAeC,gBAAAA,eAAe,IAAI;GACxC,IAAI,cAAc;IACd,gBAAgB,gBAAgB,aAAa,WAAW,QAAQ;IAChE,gBAAgB,eAAe,aAAa,UAAU,QAAQ;IAC9D,eAAe;IACf,mBAAmB;GACvB;GACA,OAAO;EACX;EAEA,sBAAgC;GAC5B,OAAOC,gBAAAA,oBAAoB;EAC/B;EAEA,YAA0C;GACtC,OAAO;EACX;EAEA,kBAA2B;GACvB,OAAO;EACX;EAEA,sBAA0C;GACtC,OAAO;EACX;EAEA,mBAA4B;GACxB,OAAO;EACX;EAEA,iBAAiB,WAA0B;GACvC,gBAAgB;EACpB;EAEA,kBAAkB,OAAmD;GACjE,IAAI,SAASC,gBAAAA,eAET,OAAOC,gBAAAA,cAAY,UAAUD,gBAAAA,cAAc;GAE/C,OAAOA,gBAAAA,cAAc;EACzB;EAEA,SAAS,OAA8B;GACnC,IAAI,SAASA,gBAAAA,eAAe;IAExB,MAAM,YAAYC,gBAAAA,cAAY;IAC9B,IAAI,WAAW;KACX,eAAe;KACf,OAAO;IACX;GACJ;GACA,OAAO;EACX;EAEA,cAAoB;GAChB,eAAeD,gBAAAA,cAAc;EACjC;CACJ;AACJ;;;;;;;;;;;AAYA,IAAW,eAA6CA,gBAAAA,cAAc"}

package/dist/chunks/StyleManager-DjwAYbxE.js

@@ -0,0 +1,113 @@
+import { n as getSmartPreset, r as hasPreset, s as THEME_PRESETS, t as getAvailablePresets } from "./styling-CRw3KQW4.js";
+//#region src/styles/StyleManager.ts
+/**
+* @fileoverview StyleManager — gestión de presets de estilo y display settings.
+*
+* Encapsula el tracking del preset activo, los toggles de visibilidad del
+* output (timestamp, location, badges) y la variable de módulo
+* {@link LEVEL_STYLES}. El Logger delega en este bridge la resolución de
+* estilos y los cambios de theme para mantener sincronizado el estado
+* compartido a nivel módulo.
+*/
+function createDefaultDisplaySettings() {
+	return {
+		showTimestamp: true,
+		showLocation: true,
+		showBadges: true
+	};
+}
+/**
+* Crea una instancia de {@link StyleManager} con display settings por defecto
+* (o los overrides que se pasen en `options`).
+*
+* Cada instancia mantiene su propio estado de preset/customization/display,
+* pero la backing store de estilos activos ({@link LEVEL_STYLES}) es
+* module-scoped: dos StyleManagers comparten la misma vista de LEVEL_STYLES.
+*
+* @param options - Overrides opcionales para los display settings iniciales.
+*
+* @example
+* ```ts
+* const sm = createStyleManager({
+*   initialDisplaySettings: { showTimestamp: false, showBadges: true }
+* });
+*
+* sm.applyPreset('cyberpunk'); // aplica preset + ajusta toggles
+* sm.setTheme('dark');         // muta LEVEL_STYLES (global al módulo)
+* console.log(sm.getStyles()); // lee el LEVEL_STYLES vigente
+* ```
+*
+* @see {@link StyleManager} para el contrato completo del bridge.
+*/
+function createStyleManager(options = {}) {
+	const displaySettings = createDefaultDisplaySettings();
+	let activePreset;
+	let activePresetName;
+	let customization;
+	return {
+		getDisplaySettings() {
+			return { ...displaySettings };
+		},
+		applyPreset(name) {
+			if (!hasPreset(name)) return false;
+			const presetConfig = getSmartPreset(name);
+			if (presetConfig) {
+				displaySettings.showTimestamp = presetConfig.timestamp?.show ?? true;
+				displaySettings.showLocation = presetConfig.location?.show ?? true;
+				activePreset = presetConfig;
+				activePresetName = name;
+			}
+			return true;
+		},
+		getAvailablePresets() {
+			return getAvailablePresets();
+		},
+		getStyles() {
+			return LEVEL_STYLES;
+		},
+		getActivePreset() {
+			return activePreset;
+		},
+		getActivePresetName() {
+			return activePresetName;
+		},
+		getCustomization() {
+			return customization;
+		},
+		setCustomization(overrides) {
+			customization = overrides;
+		},
+		resolveThemeStyle(theme) {
+			if (theme in THEME_PRESETS) return THEME_PRESETS[theme] ?? THEME_PRESETS.default;
+			return THEME_PRESETS.default;
+		},
+		setTheme(theme) {
+			if (theme in THEME_PRESETS) {
+				const newStyles = THEME_PRESETS[theme];
+				if (newStyles) {
+					LEVEL_STYLES = newStyles;
+					return true;
+				}
+			}
+			return false;
+		},
+		resetStyles() {
+			LEVEL_STYLES = THEME_PRESETS.default;
+		}
+	};
+}
+/**
+* Variable de módulo con el set de estilos activo, compartida por todas las
+* instancias de Logger/StyleManager que importan este módulo. Se exporta
+* `let` para que el Logger la pueda leer directamente sin pasar por el bridge.
+*
+* **Mutadores**: {@link StyleManager.setTheme} y {@link StyleManager.resetStyles}
+* (o el {@link resetStyles} exportado de este módulo) reasignan esta variable.
+* Cualquier referencia capturada con anterioridad queda stale — siempre leer
+* vía `LEVEL_STYLES` en punto de uso, no cacheandola.
+*/
+let LEVEL_STYLES = THEME_PRESETS.default;
+//#endregion
+export { createStyleManager as t };
+
+//# sourceMappingURL=StyleManager-DjwAYbxE.js.map