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

package/dist/playground/step.d.ts

@@ -3,12 +3,31 @@
  */
 import { type ColorCapability } from '../terminal/color-converter.js';
 /**
- * Renders a step progress indicator like `  [2/5] Analyzing repository...`
- * @param current - Current step number
- * @param total - Total number of steps
- * @param msg - Step description message
- * @param colorCap - Terminal color capability
- * @returns Formatted step string
+ * Renderiza un indicador de progreso de step con el formato `  [n/total] msg`,
+ * donde el `[n/total]` se emite en cian bold (respetando `colorCap`) para
+ * destacarlo del mensaje descriptivo. Pensado para output secuencial de CLI
+ * tipo "steps de un build", "fases de un deploy" o "tareas de un script".
+ *
+ * No hace ningún chequeo de rango sobre `current`/`total` — el caller es
+ * responsable de pasar valores coherentes (se renderizan tal cual).
+ *
+ * @param current - Número de step actual (típicamente 1-based).
+ * @param total - Total de steps del proceso.
+ * @param msg - Descripción corta del step en curso.
+ * @param colorCap - Capacidad de color del terminal destino. Si es `'none'`,
+ *   el label `[n/total]` se emite sin color.
+ * @returns String de una sola línea con formato `  [n/total] msg`.
+ *
+ * @example
+ * ```ts
+ * const steps = ['Resolving deps', 'Bundling', 'Writing dist'];
+ * steps.forEach((step, i) => {
+ *   process.stdout.write(renderStep(i + 1, steps.length, step, 'full') + '\n');
+ * });
+ * //   [1/3] Resolving deps
+ * //   [2/3] Bundling
+ * //   [3/3] Writing dist
+ * ```
  */
 export declare function renderStep(current: number, total: number, msg: string, colorCap: ColorCapability): string;
 //# sourceMappingURL=step.d.ts.map

package/dist/playground/step.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../src/playground/step.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAE/F;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,MAAM,CAMzG"}
+{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../src/playground/step.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAE/F;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,MAAM,CAMzG"}

package/dist/playground.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_spinner = require("./chunks/spinner-DNvxbM9a.cjs");
+const require_spinner = require("./chunks/spinner-BHyYEXsM.cjs");
 exports.NoopSpinner = require_spinner.NoopSpinner;
 exports.SpinnerManager = require_spinner.SpinnerManager;
 exports.renderBox = require_spinner.renderBox;

package/dist/playground.js

@@ -1,2 +1,2 @@
-import { a as renderDivider, i as renderBox, n as SpinnerManager, o as renderHeader, r as renderTable, s as renderStep, t as NoopSpinner } from "./chunks/spinner-D3FsF78o.js";
+import { a as renderDivider, i as renderBox, n as SpinnerManager, o as renderHeader, r as renderTable, s as renderStep, t as NoopSpinner } from "./chunks/spinner-BtkwpzYv.js";
 export { NoopSpinner, SpinnerManager, renderBox, renderDivider, renderHeader, renderStep, renderTable };

package/dist/serializers/SerializerBridge.d.ts

@@ -1,21 +1,28 @@
 /**
- * @fileoverview SerializerBridge — SerializerRegistry facade.
- * Encapsulates serializer registration, removal, and registry access.
+ * @fileoverview SerializerBridge — facade de SerializerRegistry.
+ * Encapsula registro, eliminación y acceso al registry de serializers.
+ *
+ * @internal
  */
 import type { SerializerFn } from '../types/index.js';
 import { SerializerRegistry } from './index.js';
 /**
- * Bridge for serializer management.
+ * Bridge para la gestión de serializers.
+ *
+ * @internal
  */
 export interface SerializerBridge {
-    /** Adds a serializer for a type. */
+    /** Añade un serializer para un tipo. */
     addSerializer<T>(type: new (...args: unknown[]) => T, serializer: SerializerFn<T>, priority?: number): void;
+    /** Elimina el serializer asociado a un tipo. Devuelve `true` si se eliminó. */
     removeSerializer<T>(type: new (...args: unknown[]) => T): boolean;
-    /** Returns the underlying registry. */
+    /** Devuelve el registry subyacente. */
     getSerializerRegistry(): SerializerRegistry;
 }
 /**
- * Creates a SerializerBridge instance.
+ * Crea una instancia de {@link SerializerBridge}.
+ *
+ * @internal
  */
 export declare function createSerializerBridge(): SerializerBridge;
 //# sourceMappingURL=SerializerBridge.d.ts.map

package/dist/serializers/SerializerBridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SerializerBridge.d.ts","sourceRoot":"","sources":["../../src/serializers/SerializerBridge.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,oCAAoC;IACpC,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5G,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC;IAClE,uCAAuC;IACvC,qBAAqB,IAAI,kBAAkB,CAAC;CAC/C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAgBzD"}
+{"version":3,"file":"SerializerBridge.d.ts","sourceRoot":"","sources":["../../src/serializers/SerializerBridge.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC7B,wCAAwC;IACxC,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5G,+EAA+E;IAC/E,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC;IAClE,uCAAuC;IACvC,qBAAqB,IAAI,kBAAkB,CAAC;CAC/C;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAgBzD"}

package/dist/serializers/SerializerRegistry.d.ts

@@ -1,16 +1,252 @@
+/**
+ * @fileoverview Registry de serializers con control de profundidad, detección
+ * de referencias circulares y soporte para tipos builtin (Error, Date, RegExp,
+ * Map, Set, Buffer). Implementa {@link ISerializerRegistry}.
+ */
 import type { SerializerFn, SerializerEntry, SerializerConfig, ISerializerRegistry } from '../types/index.js';
+/**
+ * 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.
+ */
 export declare class SerializerRegistry implements ISerializerRegistry {
     private serializers;
     private 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?: SerializerConfig);
+    /**
+     * 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
+     */
     private registerDefaults;
+    /**
+     * 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<T>(type: new (...args: any[]) => T, serializer: SerializerFn<T>, priority?: number): void;
+    /**
+     * 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<T>(type: new (...args: any[]) => T): boolean;
+    /**
+     * 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<T>(type: new (...args: any[]) => T): boolean;
+    /**
+     * 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(): SerializerEntry[];
+    /**
+     * 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.
+     */
     private findSerializer;
+    /**
+     * 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.
+     */
     private serializeInternal;
+    /**
+     * 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: any, config?: SerializerConfig): any;
 }
+/**
+ * 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);
+ * }
+ * ```
+     */
 export declare function getDefaultSerializerRegistry(): SerializerRegistry;
 //# sourceMappingURL=SerializerRegistry.d.ts.map

package/dist/serializers/SerializerRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SerializerRegistry.d.ts","sourceRoot":"","sources":["../../src/serializers/SerializerRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,YAAY,EAEZ,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACtB,MAAM,mBAAmB,CAAC;AAQ3B,qBAAa,kBAAmB,YAAW,mBAAmB;IAC1D,OAAO,CAAC,WAAW,CAA6C;IAChE,OAAO,CAAC,MAAM,CAA6B;gBAE/B,MAAM,GAAE,gBAAqB;IAKzC,OAAO,CAAC,gBAAgB;IAmDxB,GAAG,CAAC,CAAC,EACD,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAC/B,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC,EAC3B,QAAQ,GAAE,MAAW,GACtB,IAAI;IAIP,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,OAAO;IAInD,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,OAAO;IAIhD,MAAM,IAAI,eAAe,EAAE;IAK3B,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,iBAAiB;IAiDzB,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,GAAG;CASxD;AAID,wBAAgB,4BAA4B,IAAI,kBAAkB,CAKjE"}
+{"version":3,"file":"SerializerRegistry.d.ts","sourceRoot":"","sources":["../../src/serializers/SerializerRegistry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EACR,YAAY,EAEZ,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACtB,MAAM,mBAAmB,CAAC;AAc3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,kBAAmB,YAAW,mBAAmB;IAC1D,OAAO,CAAC,WAAW,CAA6C;IAChE,OAAO,CAAC,MAAM,CAA6B;IAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;gBACS,MAAM,GAAE,gBAAqB;IAKzC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,gBAAgB;IAmDxB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,GAAG,CAAC,CAAC,EACD,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAC/B,UAAU,EAAE,YAAY,CAAC,CAAC,CAAC,EAC3B,QAAQ,GAAE,MAAW,GACtB,IAAI;IAIP;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,OAAO;IAInD;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,OAAO;IAIhD;;;;;;;;;;;;;;;OAeG;IACH,MAAM,IAAI,eAAe,EAAE;IAK3B;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAUtB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,iBAAiB;IAiDzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,GAAG;CASxD;AASD;;;;;;;;;;;;;;;;OAgBO;AACP,wBAAgB,4BAA4B,IAAI,kBAAkB,CAKjE"}

package/dist/serializers.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_SerializerBridge = require("./chunks/SerializerBridge-BaOQOb8q.cjs");
+const require_SerializerBridge = require("./chunks/SerializerBridge-C4a9Z37F.cjs");
 exports.SerializerRegistry = require_SerializerBridge.SerializerRegistry;
 exports.createSerializerBridge = require_SerializerBridge.createSerializerBridge;
 exports.getDefaultSerializerRegistry = require_SerializerBridge.getDefaultSerializerRegistry;

package/dist/serializers.js

@@ -1,2 +1,2 @@
-import { n as SerializerRegistry, r as getDefaultSerializerRegistry, t as createSerializerBridge } from "./chunks/SerializerBridge-BkpQu5c9.js";
+import { n as SerializerRegistry, r as getDefaultSerializerRegistry, t as createSerializerBridge } from "./chunks/SerializerBridge-Ba43Mk7j.js";
 export { SerializerRegistry, createSerializerBridge, getDefaultSerializerRegistry };

package/dist/styles/StyleManager.d.ts

@@ -1,83 +1,190 @@
 /**
- * @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.
  */
 import { THEME_PRESETS } from '../styling/index.js';
 import type { ThemeVariant } from '../types/index.js';
+/**
+ * Re-export de `StyleBuilder` para consumo interno del Logger dentro de este
+ * paquete. La API pública de styling vive en `../styling/index.ts`; este
+ * re-export existe únicamente para evitar un segundo import cruzado desde
+ * Logger.ts. No considerar parte del surface público de este módulo.
+ *
+ * @internal
+ */
 export { StyleBuilder } from '../styling/index.js';
 /**
- * Display visibility settings.
+ * Toggles de visibilidad que controlan qué metadatos acompañan a cada línea
+ * de log en la salida formateada. Cada preset inteligente
+ * (via {@link StyleManager.applyPreset}) puede imponer sus propios defaults
+ * sobreescribiendo estos valores.
  */
 export interface DisplaySettings {
+    /** Muestra (o no) el timestamp ISO al inicio de cada línea. */
     showTimestamp: boolean;
+    /** Muestra (o no) la ubicación del caller (file:line) parseada del stack. */
     showLocation: boolean;
+    /** Muestra (o no) los badges de scope/nivel junto al mensaje. */
     showBadges: boolean;
 }
 /**
- * Active preset state tracked by StyleManager.
+ * Snapshot del estado interno que el StyleManager trackea en closure:
+ * preset activo, overrides de `customize()` y display settings vigentes.
+ * Útil para serializar/inspeccionar el estado de styling sin exponer la
+ * implementación del bridge.
  */
 export interface PresetState {
-    /** The resolved style config (LEVEL_STYLES). */
+    /** Config de estilos resuelta (referencia a {@link LEVEL_STYLES}). */
     styles: typeof THEME_PRESETS.default;
-    /** The active smart-preset config (if any). */
+    /** Config del smart-preset activo (si lo hay). */
     activePreset: unknown;
-    /** Name of the active smart-preset (if any). */
+    /** Nombre del smart-preset activo (si lo hay). */
     activePresetName: string | undefined;
-    /** Last-applied customize() overrides. */
+    /** Últimos overrides aplicados via `customize()`. */
     customization: unknown;
-    /** Display visibility settings. */
+    /** Toggles de visibilidad del output. */
     displaySettings: DisplaySettings;
 }
 /**
- * Options for creating StyleManager.
+ * Opciones de construcción para {@link createStyleManager}.
  */
 export interface IStyleManagerOptions {
-    /** Initial display settings. */
+    /** Display settings iniciales (parciales: se merguean sobre los defaults). */
     initialDisplaySettings?: Partial<DisplaySettings>;
 }
 /**
- * StyleManager - manages style presets and display settings.
+ * Bridge que gestiona presets de estilo, display settings y el ciclo de
+ * theme switching para un Logger.
+ *
+ * Encapsula el estado de styling en una closure para que el Logger no
+ * tenga que mantener boilerplate propio. La implementación por defecto
+ * (ver {@link createStyleManager}) opera sobre la variable de módulo
+ * compartida {@link LEVEL_STYLES}: esto significa que `setTheme()` y
+ * `resetStyles()` mutan estado global visible para TODAS las instancias
+ * de Logger que comparten el módulo. Cada Logger construye su propio
+ * StyleManager, pero la backing store de estilos activos es module-scoped
+ * — está pensado así para que cambiar de theme una vez afecte a toda la
+ * app, pero conviene saberlo al instanciar múltiples loggers con intents
+ * distintos.
  */
 export interface StyleManager {
-    /** Returns current display settings. */
+    /**
+     * Devuelve un shallow clone de los display settings vigentes, de modo
+     * que el caller pueda leerlos sin riesgo de mutar el estado interno.
+     */
     getDisplaySettings(): DisplaySettings;
-    /** Applies a smart preset by name. Returns true if applied. */
+    /**
+     * Aplica un smart-preset por nombre. Si el preset existe, actualiza los
+     * toggles de display (`showTimestamp`/`showLocation`) según la config
+     * del preset y memoriza su nombre/config para que el renderer pueda
+     * regenerar el output si cambia el theme.
+     *
+     * @param name - Identificador del preset (ver {@link getAvailablePresets}).
+     * @returns `true` si el preset existe y se aplicó, `false` si no se encontró.
+     */
     applyPreset(name: string): boolean;
-    /** Lists all available presets. */
+    /**
+     * Lista los identificadores de todos los smart-presets registrados.
+     * Útil para alimentar un selector de UI o validar input de usuario.
+     */
     getAvailablePresets(): string[];
-    /** Gets the current LEVEL_STYLES. */
+    /**
+     * Devuelve la referencia actual a {@link LEVEL_STYLES}. Como es
+     * module-scoped, refleja el último `setTheme()`/`resetStyles()` aunque
+     * provenga de otra instancia.
+     */
     getStyles(): typeof THEME_PRESETS.default;
-    /** Gets the active smart-preset config. */
+    /** Devuelve la config cruda del smart-preset activo (o `undefined`). */
     getActivePreset(): unknown;
-    /** Gets the active smart-preset name. */
+    /** Nombre del smart-preset activo — útil para logging diagnóstico. */
     getActivePresetName(): string | undefined;
-    /** Gets the active customization overrides. */
+    /** Último override aplicado via `Logger.customize()` (si lo hubo). */
     getCustomization(): unknown;
-    /** Stores customization overrides. */
+    /**
+     * Persiste overrides de customización para que el renderer los consuma
+     * en el próximo render. No muta {@link LEVEL_STYLES}.
+     */
     setCustomization(overrides: unknown): void;
-    /** Resolves the effective styles for a theme variant. */
+    /**
+     * Resuelve (sin mutar nada) el set de estilos que correspondería a un
+     * theme dado. Si el theme no existe en {@link THEME_PRESETS}, cae al
+     * preset `default`. Útil para previsualizar un theme sin aplicarlo.
+     *
+     * @param theme - Variante de theme soportada por {@link THEME_PRESETS}.
+     */
     resolveThemeStyle(theme: ThemeVariant): typeof THEME_PRESETS.default;
-    /** Sets the active theme by name, updating the module-level LEVEL_STYLES. */
+    /**
+     * Aplica el theme mutando la variable de módulo {@link LEVEL_STYLES}.
+     *
+     * **Side-effect global**: como `LEVEL_STYLES` se comparte entre todas
+     * las instancias de Logger del módulo, este cambio es visible para
+     * cualquier Logger que haya en el proceso. No hay undo a nivel
+     * instancia — llamar a {@link resetStyles} para volver al default.
+     *
+     * @param theme - Variante de theme soportada por {@link THEME_PRESETS}.
+     * @returns `true` si el theme existe y se aplicó, `false` si no se encontró.
+     */
     setTheme(theme: ThemeVariant): boolean;
-    /** Resets LEVEL_STYLES to the default preset. */
+    /**
+     * Restablece {@link LEVEL_STYLES} al preset `default` de
+     * {@link THEME_PRESETS}. Al igual que {@link setTheme}, afecta a todas
+     * las instancias de Logger del módulo.
+     */
     resetStyles(): void;
 }
 /**
- * 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.
  */
 export declare function createStyleManager(options?: IStyleManagerOptions): StyleManager;
 /**
- * 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.
  */
 export declare let LEVEL_STYLES: typeof THEME_PRESETS.default;
 /**
- * Resets LEVEL_STYLES to default.
+ * Restablece {@link LEVEL_STYLES} al preset `default` de {@link THEME_PRESETS}.
+ *
+ * Equivalente a invocar {@link StyleManager.resetStyles} sobre cualquier
+ * instancia, expuesto como función libre para que código externo al Logger
+ * (CLIs, tooling, tests) pueda resetear el módulo sin tener que sostener una
+ * referencia al StyleManager. Mismo side-effect global que `setTheme`.
+ *
+ * @example
+ * ```ts
+ * import { resetStyles } from '@mks2508/better-logger/styles';
+ * resetStyles(); // vuelve al theme default para todos los loggers del módulo
+ * ```
  */
 export declare function resetStyles(): void;
 //# sourceMappingURL=StyleManager.d.ts.map

package/dist/styles/StyleManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StyleManager.d.ts","sourceRoot":"","sources":["../../src/styles/StyleManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACH,aAAa,EAGhB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,YAAY,EAAa,MAAM,mBAAmB,CAAC;AAGjE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,gDAAgD;IAChD,MAAM,EAAE,OAAO,aAAa,CAAC,OAAO,CAAC;IACrC,+CAA+C;IAC/C,YAAY,EAAE,OAAO,CAAC;IACtB,gDAAgD;IAChD,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,0CAA0C;IAC1C,aAAa,EAAE,OAAO,CAAC;IACvB,mCAAmC;IACnC,eAAe,EAAE,eAAe,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,gCAAgC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,wCAAwC;IACxC,kBAAkB,IAAI,eAAe,CAAC;IACtC,+DAA+D;IAC/D,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC,mCAAmC;IACnC,mBAAmB,IAAI,MAAM,EAAE,CAAC;IAChC,qCAAqC;IACrC,SAAS,IAAI,OAAO,aAAa,CAAC,OAAO,CAAC;IAC1C,2CAA2C;IAC3C,eAAe,IAAI,OAAO,CAAC;IAC3B,yCAAyC;IACzC,mBAAmB,IAAI,MAAM,GAAG,SAAS,CAAC;IAC1C,+CAA+C;IAC/C,gBAAgB,IAAI,OAAO,CAAC;IAC5B,sCAAsC;IACtC,gBAAgB,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3C,yDAAyD;IACzD,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,aAAa,CAAC,OAAO,CAAC;IACrE,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC;IACvC,iDAAiD;IACjD,WAAW,IAAI,IAAI,CAAC;CACvB;AAUD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,oBAAyB,GAAG,YAAY,CA0EnF;AAED;;;GAGG;AACH,eAAO,IAAI,YAAY,EAAE,OAAO,aAAa,CAAC,OAA+B,CAAC;AAE9E;;GAEG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAElC"}
+{"version":3,"file":"StyleManager.d.ts","sourceRoot":"","sources":["../../src/styles/StyleManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACH,aAAa,EAGhB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,YAAY,EAAa,MAAM,mBAAmB,CAAC;AAEjE;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC5B,+DAA+D;IAC/D,aAAa,EAAE,OAAO,CAAC;IACvB,6EAA6E;IAC7E,YAAY,EAAE,OAAO,CAAC;IACtB,iEAAiE;IACjE,UAAU,EAAE,OAAO,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IACxB,sEAAsE;IACtE,MAAM,EAAE,OAAO,aAAa,CAAC,OAAO,CAAC;IACrC,kDAAkD;IAClD,YAAY,EAAE,OAAO,CAAC;IACtB,kDAAkD;IAClD,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,qDAAqD;IACrD,aAAa,EAAE,OAAO,CAAC;IACvB,yCAAyC;IACzC,eAAe,EAAE,eAAe,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,8EAA8E;IAC9E,sBAAsB,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;CACrD;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,YAAY;IACzB;;;OAGG;IACH,kBAAkB,IAAI,eAAe,CAAC;IACtC;;;;;;;;OAQG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC;;;OAGG;IACH,mBAAmB,IAAI,MAAM,EAAE,CAAC;IAChC;;;;OAIG;IACH,SAAS,IAAI,OAAO,aAAa,CAAC,OAAO,CAAC;IAC1C,wEAAwE;IACxE,eAAe,IAAI,OAAO,CAAC;IAC3B,sEAAsE;IACtE,mBAAmB,IAAI,MAAM,GAAG,SAAS,CAAC;IAC1C,sEAAsE;IACtE,gBAAgB,IAAI,OAAO,CAAC;IAC5B;;;OAGG;IACH,gBAAgB,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3C;;;;;;OAMG;IACH,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,aAAa,CAAC,OAAO,CAAC;IACrE;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC;IACvC;;;;OAIG;IACH,WAAW,IAAI,IAAI,CAAC;CACvB;AAUD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,oBAAyB,GAAG,YAAY,CA0EnF;AAED;;;;;;;;;GASG;AACH,eAAO,IAAI,YAAY,EAAE,OAAO,aAAa,CAAC,OAA+B,CAAC;AAE9E;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAElC"}

package/dist/styles.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_styling = require("./chunks/styling-Cg5saQ46.cjs");
-const require_StyleManager = require("./chunks/StyleManager-CIpd6wbO.cjs");
+const require_styling = require("./chunks/styling-Cel2wPRy.cjs");
+const require_StyleManager = require("./chunks/StyleManager-DQ6UNRB-.cjs");
 exports.StyleBuilder = require_styling.StyleBuilder;
 exports.StylePresets = require_styling.StylePresets;
 exports.THEME_PRESETS = require_styling.THEME_PRESETS;

package/dist/styles.js

@@ -1,3 +1,3 @@
-import { c as StyleBuilder, l as StylePresets, s as THEME_PRESETS } from "./chunks/styling-84N8T97t.js";
-import { t as createStyleManager } from "./chunks/StyleManager-LCvVlVdx.js";
+import { c as StyleBuilder, l as StylePresets, s as THEME_PRESETS } from "./chunks/styling-CRw3KQW4.js";
+import { t as createStyleManager } from "./chunks/StyleManager-DjwAYbxE.js";
 export { StyleBuilder, StylePresets, THEME_PRESETS, createStyleManager };