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

package/dist/serializers/SerializerBridge.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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 para la gestión de serializers.
+ *
+ * @internal
+ */
+export interface SerializerBridge {
+    /** 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;
+    /** Devuelve el registry subyacente. */
+    getSerializerRegistry(): SerializerRegistry;
+}
+/**
+ * Crea una instancia de {@link SerializerBridge}.
+ *
+ * @internal
+ */
+export declare function createSerializerBridge(): SerializerBridge;
+//# sourceMappingURL=SerializerBridge.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +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

@@ -0,0 +1 @@
+{"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/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Serializers subpath barrel.
+ * Exports: SerializerRegistry, createSerializerBridge, SerializerBridge
+ */
+export { SerializerRegistry, getDefaultSerializerRegistry } from './SerializerRegistry.js';
+export { createSerializerBridge, type SerializerBridge } from './SerializerBridge.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serializers/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,kBAAkB,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AAC3F,OAAO,EAAE,sBAAsB,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/serializers-module.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Entry point for ./serializers subpath.
+ * Serializer registry and bridge.
+ */
+export { SerializerRegistry, getDefaultSerializerRegistry } from './serializers/index.js';
+export { createSerializerBridge, type SerializerBridge } from './serializers/index.js';
+//# sourceMappingURL=serializers-module.d.ts.map

package/dist/serializers-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializers-module.d.ts","sourceRoot":"","sources":["../src/serializers-module.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,kBAAkB,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAC1F,OAAO,EAAE,sBAAsB,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/serializers.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,190 @@
+/**
+ * @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.
+ */
+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';
+/**
+ * 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;
+}
+/**
+ * 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 {
+    /** Config de estilos resuelta (referencia a {@link LEVEL_STYLES}). */
+    styles: typeof THEME_PRESETS.default;
+    /** Config del smart-preset activo (si lo hay). */
+    activePreset: unknown;
+    /** Nombre del smart-preset activo (si lo hay). */
+    activePresetName: string | undefined;
+    /** Últimos overrides aplicados via `customize()`. */
+    customization: unknown;
+    /** Toggles de visibilidad del output. */
+    displaySettings: DisplaySettings;
+}
+/**
+ * Opciones de construcción para {@link createStyleManager}.
+ */
+export interface IStyleManagerOptions {
+    /** Display settings iniciales (parciales: se merguean sobre los defaults). */
+    initialDisplaySettings?: Partial<DisplaySettings>;
+}
+/**
+ * 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 {
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Lista los identificadores de todos los smart-presets registrados.
+     * Útil para alimentar un selector de UI o validar input de usuario.
+     */
+    getAvailablePresets(): string[];
+    /**
+     * 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;
+    /** Devuelve la config cruda del smart-preset activo (o `undefined`). */
+    getActivePreset(): unknown;
+    /** Nombre del smart-preset activo — útil para logging diagnóstico. */
+    getActivePresetName(): string | undefined;
+    /** Último override aplicado via `Logger.customize()` (si lo hubo). */
+    getCustomization(): unknown;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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

@@ -0,0 +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;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/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Styles subpath barrel.
+ * Exports: StyleBuilder, StylePresets, THEME_PRESETS, createStyleManager, StyleManager
+ */
+export { StyleBuilder, StylePresets, THEME_PRESETS } from '../styling/index.js';
+export { createStyleManager, type StyleManager, type DisplaySettings, type PresetState } from './StyleManager.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/styles/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/styles-module.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Entry point for ./styles subpath.
+ * StyleBuilder + themes + presets + StyleManager.
+ */
+export { StyleBuilder, StylePresets, THEME_PRESETS } from './styling/index.js';
+export { createStyleManager, type StyleManager, type DisplaySettings, type PresetState } from './styles/index.js';
+//# sourceMappingURL=styles-module.d.ts.map

package/dist/styles-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles-module.d.ts","sourceRoot":"","sources":["../src/styles-module.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,EAAE,kBAAkB,EAAE,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/styles.cjs

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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;
+exports.createStyleManager = require_StyleManager.createStyleManager;

package/dist/styles.js

@@ -0,0 +1,3 @@
+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 };