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

package/dist/index.js

@@ -1,160 +1,3329 @@
+import { t as LOG_LEVELS } from "./chunks/core-Blfi2klP.js";
+import { o as LOG_LEVEL_TO_SEVERITY_NUMBER, s as LOG_LEVEL_TO_SEVERITY_TEXT, t as TransportManager } from "./chunks/transports-BGfwwakw.js";
+import { _ as DEFAULT_CONFIG, a as safeSerialize, b as parseStackTrace, c as ansiBackground, d as ansiDim, f as ansiStyle, g as CLI_LEVEL_MAP, h as formatSuccessANSI, i as getConsoleMethod, l as ansiBold, m as formatLogLevelANSI, o as createStyledOutput, p as ansiUnderline, r as formatTablePlain, s as setupThemeChangeListener, t as createLogEntry, u as ansiColor, y as formatTimestamp } from "./chunks/utils-tKfBAWUM.js";
+import { a as THEME_BANNERS, c as StyleBuilder, i as BANNER_VARIANTS, l as StylePresets, n as getSmartPreset, o as displayInitBanner, r as hasPreset, s as THEME_PRESETS, t as getAvailablePresets } from "./chunks/styling-CRw3KQW4.js";
+import { a as getTerminalWidth, c as isRunningInTerminal, i as getTerminalHeight, l as supportsANSI, n as getEnvironment, r as getEnvironmentInfo, t as getColorCapability } from "./chunks/environment-detector-7NvnYUfr.js";
+import { a as renderDivider, c as formatBadge, i as renderBox, n as SpinnerManager, o as renderHeader, r as renderTable, s as renderStep, t as NoopSpinner } from "./chunks/spinner-BtkwpzYv.js";
+import { t as createLogContext } from "./chunks/LogContext-DjlITOzZ.js";
+import { t as createHookBridge } from "./chunks/HookBridge-CI2PH79S.js";
+import { t as createSerializerBridge } from "./chunks/SerializerBridge-Ba43Mk7j.js";
+import { t as ServerFallback } from "./chunks/server-fallback-jj0T6XaK.js";
+import { t as createStyleManager } from "./chunks/StyleManager-DjwAYbxE.js";
+//#region src/ScopedLogger.ts
 /**
- * @fileoverview Better Logger - Librería completa con todas las características
- * @version 0.3.0
- * @since 2024
- *
- * Punto de entrada principal que proporciona la experiencia completa de Better Logger
- * con características avanzadas incluyendo estilos CSS, soporte SVG, animaciones,
- * capacidades de exportación y logging remoto.
- *
- * @module @mks2508/better-logger
- */
-// Main Logger class with all features
-import { Logger } from './Logger.js';
-// Create singleton instance with all features enabled
-const logger = new Logger();
-/**
- * Clase principal Logger con conjunto completo de características
- *
- * @example
- * // Importación y uso básico
- * import { Logger } from '@mks2508/better-logger';
- *
- * const logger = new Logger();
- * logger.preset('cyberpunk');  // Aplicar preset completo
- * logger.info('¡Hola mundo!');
- *
- * @example
- * // Logger con scope para componentes
- * const auth = logger.component('Auth');
- * auth.info('Usuario autenticando...');
- * auth.success('Login exitoso');
- *
- * @example
- * // Logger para APIs con badges
- * const api = logger.api('GraphQL');
- * api.badges(['v2', 'cached']).info('Query ejecutada');
- *
- * @since 0.3.0
- */
-export { Logger };
-/**
- * Instancia singleton del logger lista para usar
- * @default
- *
- * @example
- * // Uso directo sin crear instancia
- * import logger from '@mks2508/better-logger';
- *
- * logger.info('Aplicación iniciada');
- * logger.success('Conexión establecida');
- * logger.warn('Memoria al 80%');
- * logger.error('Fallo en conexión');
- */
-export default logger;
-/**
- * Métodos de logging individuales (enlazados al singleton)
- *
- * @example
- * // Importar solo los métodos necesarios
- * import { info, error, success } from '@mks2508/better-logger';
- *
- * info('Proceso iniciado');
- * success('✓ Completado exitosamente');
- * error('Error:', errorDetails);
- *
- * @since 0.3.0
- */
-export const debug = (...args) => logger.debug(...args);
-export const info = (...args) => logger.info(...args);
-export const warn = (...args) => logger.warn(...args);
-export const error = (...args) => logger.error(...args);
-export const success = (...args) => logger.success(...args);
-export const critical = (...args) => logger.critical(...args);
-export const trace = (...args) => logger.trace(...args);
-export const table = (data, columns) => logger.table(data, columns);
-export const group = (label, collapsed) => logger.group(label, collapsed);
-export const groupEnd = () => logger.groupEnd();
-export const time = (label) => logger.time(label);
-export const timeEnd = (label) => logger.timeEnd(label);
-export const setGlobalPrefix = (prefix) => logger.setGlobalPrefix(prefix);
-export const scope = (prefix) => logger.scope(prefix);
-export const setVerbosity = (level) => logger.setVerbosity(level);
-export const addHandler = (handler) => logger.addHandler(handler);
-export const setTheme = (theme) => logger.setTheme(theme);
-export const setBannerType = (bannerType) => logger.setBannerType(bannerType);
-export const showBanner = (bannerType) => logger.showBanner(bannerType);
-export const logWithSVG = (message, svgContent, options) => logger.logWithSVG(message, svgContent, options);
-export const logAnimated = (message, duration) => logger.logAnimated(message, duration);
-export const cli = (command) => logger.cli(command);
-// Styling utilities
-export { StyleBuilder, StylePresets, THEME_PRESETS, THEME_BANNERS, BANNER_VARIANTS } from './styling/index.js';
-// Handler exports
-export { FileLogHandler, RemoteLogHandler, AnalyticsLogHandler } from './handlers/index.js';
-// Constants
-export { DEFAULT_CONFIG } from './constants.js';
-// Utility exports
-export { parseStackTrace, formatTimestamp } from './utils/index.js';
-/**
- * Utilidades de estilo para crear estilos personalizados de consola
- *
- * @example
- * // Crear estilo personalizado
- * import { createStyle, stylePresets } from '@mks2508/better-logger';
- *
- * const miEstilo = createStyle()
- *   .bg('linear-gradient(45deg, #ff6b6b, #feca57)')
- *   .color('white')
- *   .padding('10px')
- *   .rounded('8px')
- *   .bold()
- *   .build();
- *
- * console.log('%cMensaje estilizado', miEstilo);
- *
- * @example
- * // Usar presets predefinidos
- * console.log('%cÉxito!', stylePresets.success);
- * console.log('%cError!', stylePresets.error);
- *
- * @since 0.3.0
- */
-import { StyleBuilder, StylePresets } from './styling/index.js';
-/**
- * Crea una nueva instancia de StyleBuilder para estilos personalizados de consola
- *
- * @returns {StyleBuilder} Constructor de estilos encadenable
- *
- * @example
- * const estilo = createStyle()
- *   .gradient('#667eea', '#764ba2')
- *   .color('white')
- *   .padding('8px 16px')
- *   .rounded('4px')
- *   .shadow('0 2px 4px rgba(0,0,0,0.2)')
- *   .build();
- *
- * @since 0.3.0
- */
-export const createStyle = () => new StyleBuilder();
-/**
- * Presets de estilo predefinidos para casos de uso comunes
- *
- * @constant {Object} stylePresets
- *
- * @example
- * console.log('%cOperación exitosa', stylePresets.success);
- * console.log('%cAdvertencia', stylePresets.warning);
- * console.log('%cError crítico', stylePresets.error);
- * console.log('%cInformación', stylePresets.info);
- * console.log('%cDestacado', stylePresets.accent);
- *
- * @since 0.3.0
- */
-export const stylePresets = {
-    success: StylePresets.success().build(),
-    error: StylePresets.error().build(),
-    warning: StylePresets.warning().build(),
-    info: StylePresets.info().build(),
-    accent: StylePresets.accent().build(),
+* Logger prefijado por un scope nominal. Mantiene su propio stack de badges
+* y contextos y delega el envío de mensajes al {@link Logger} padre a través
+* de bindings (`{ scope, badges }`).
+*
+* Es la base de la jerarquía temática: {@link APILogger} y
+* {@link ComponentLogger} extienden de ella, y {@link ContextLogger} la
+* consume para apilar/subdesapilar sub-prefijos en el scope.
+*
+* No se construye directamente: se obtiene con `logger.scope('name')`.
+*
+* @example
+* // El factory method del Logger raíz devuelve un ScopedLogger
+* import logger from '@mks2508/better-logger';
+*
+* const http = logger.scope('HTTP');
+* http.badge('OUTBOUND').info('Request enviada');
+* // salida: [HTTP] [OUTBOUND] Request enviada
+*
+* @example
+* // Anidar contextos dentro de un scope (el prefijo se compone con ':')
+* const retry = http.context('retry');
+* retry.run(() => http.warn('Reintentando petición'));
+* // salida: [HTTP:retry] Reintentando petición
+*
+* @see {@link Logger.scope}
+* @see {@link APILogger}
+* @see {@link ComponentLogger}
+* @see {@link ContextLogger}
+*/
+var ScopedLogger = class {
+	parent;
+	scopeName;
+	badgeList = [];
+	contextStack = [];
+	_timers;
+	/**
+	* Construye un ScopedLogger vinculado a un {@link Logger} padre.
+	*
+	* Los clientes no deben llamar a este constructor directamente: usen
+	* `logger.scope(name)`, que configura correctamente la instancia.
+	*
+	* @param {Logger} parent - Logger raíz al que se delegan los mensajes.
+	* @param {string} scopeName - Etiqueta del scope; se renderiza como
+	*   prefijo `[scopeName]` en cada línea.
+	*/
+	constructor(parent, scopeName) {
+		this.parent = parent;
+		this.scopeName = scopeName;
+	}
+	get timers() {
+		if (!this._timers) this._timers = /* @__PURE__ */ new Map();
+		return this._timers;
+	}
+	getBindings() {
+		return {
+			scope: this.getScopePrefix(),
+			badges: this.badgeList.length > 0 ? [...this.badgeList] : void 0
+		};
+	}
+	getScopePrefix() {
+		if (this.contextStack.length === 0) return this.scopeName;
+		return [this.scopeName, ...this.contextStack].join(":");
+	}
+	/**
+	* Reemplaza la lista actual de badges por la pasada y la aplica a todos
+	* los mensajes posteriores de este scope.
+	*
+	* @param {string[]} badges - Etiquetas a mostrar como badges adyacentes
+	*   al prefijo (p. ej. `['OUTBOUND', 'CACHED']`).
+	* @returns {this} La misma instancia, para encadenar llamadas.
+	*
+	* @example
+	* logger.scope('HTTP').badges(['OUTBOUND', 'CACHED']).info('Cache hit');
+	* // salida: [HTTP] [OUTBOUND] [CACHED] Cache hit
+	*
+	* @see {@link badge} para añadir sin reemplazar los existentes.
+	* @see {@link clearBadges} para vaciar la lista.
+	*/
+	badges(badges) {
+		this.badgeList = [...badges];
+		return this;
+	}
+	/**
+	* Añade un badge al scope de forma idempotente (no lo duplica si ya existe).
+	*
+	* @param {string} badge - Etiqueta a añadir a la lista de badges.
+	* @returns {this} La misma instancia, para encadenar llamadas.
+	*
+	* @example
+	* logger.scope('API')
+	*   .badge('OUTBOUND')
+	*   .badge('RETRY')
+	*   .warn('Reintentando');
+	* // salida: [API] [OUTBOUND] [RETRY] Reintentando
+	*/
+	badge(badge) {
+		if (!this.badgeList.includes(badge)) this.badgeList.push(badge);
+		return this;
+	}
+	/**
+	* Vacía la lista de badges del scope.
+	*
+	* @returns {this} La misma instancia, para encadenar llamadas.
+	*
+	* @example
+	* const http = logger.scope('HTTP');
+	* http.badge('OUTBOUND').info('uno');
+	* http.clearBadges().info('dos');
+	* // [HTTP] [OUTBOUND] uno   /   [HTTP] dos
+	*/
+	clearBadges() {
+		this.badgeList = [];
+		return this;
+	}
+	/**
+	* Aplica un theme preset al logger padre. El preset afecta a toda la
+	* instancia raíz (no solo a este scope) porque el style es compartido.
+	*
+	* @param {string} presetName - Nombre del preset registrado en el StyleManager.
+	* @returns {this} La misma instancia, para encadenar llamadas.
+	*
+	* @example
+	* logger.scope('UI').style('cyberpunk').info('neon');
+	* @see {@link Logger.setTheme}
+	*/
+	style(presetName) {
+		this.parent.setTheme(presetName);
+		return this;
+	}
+	/**
+	* Crea un {@link ContextLogger} vinculado a este scope. Los contextos se
+	* apilan en el prefijo separados por `:`, permitiendo agrupar bloques de
+	* logs relacionados (reintentos, sub-etapas, etc.) sin `console.group`.
+	*
+	* @param {string} contextName - Nombre del contexto a apilar.
+	* @returns {ContextLogger} Handler con `run`, `runAsync`, `start`/`end`.
+	*
+	* @example
+	* const retry = logger.scope('HTTP').context('retry');
+	* retry.run(() => logger.warn('Reintentando'));
+	* // salida: [HTTP:retry] Reintentando
+	* @see {@link ContextLogger}
+	*/
+	context(contextName) {
+		return new ContextLogger(this, contextName);
+	}
+	/**
+	* Inicia un timer etiquetado bajo el namespace `<scopeName>:<label>`.
+	* El label es local a este scope, así que dos scopes pueden reutilizar el
+	* mismo nombre sin colisión.
+	*
+	* @param {string} label - Identificador del timer.
+	*
+	* @example
+	* const http = logger.scope('HTTP');
+	* http.time('request');
+	* // ... trabajo ...
+	* http.timeEnd('request'); // imprime "Timer: request - 12.34ms"
+	* @see {@link timeEnd}
+	*/
+	time(label) {
+		this.timers.set(label, {
+			label: `${this.scopeName}:${label}`,
+			startTime: performance.now()
+		});
+	}
+	/**
+	* Detiene un timer previamente iniciado con {@link time} y registra la
+	* duración con nivel `success`. Si el label no existe, emite un `warn`
+	* y devuelve `undefined`.
+	*
+	* @param {string} label - Mismo label pasado a {@link time}.
+	* @returns {number | undefined} Milisegundos transcurridos, o `undefined`
+	*   si el timer no estaba registrado.
+	*
+	* @example
+	* const http = logger.scope('HTTP');
+	* http.time('fetch');
+	* await fetch(url);
+	* const ms = http.timeEnd('fetch');
+	* if (ms && ms > 1000) http.warn('Latencia alta');
+	*/
+	timeEnd(label) {
+		const timer = this.timers.get(label);
+		if (!timer) {
+			this.warn(`Timer '${label}' not found`);
+			return;
+		}
+		const elapsed = performance.now() - timer.startTime;
+		this.timers.delete(label);
+		this.success(`Timer: ${label} - ${elapsed.toFixed(2)}ms`);
+		return elapsed;
+	}
+	/**
+	* Emite un mensaje a nivel `debug` con los bindings actuales del scope.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales (objetos,
+	*   errores, etc.) serializados igual que en el logger raíz.
+	*
+	* @example
+	* logger.scope('DB').debug('query', { sql, params });
+	*/
+	debug(...args) {
+		this.parent.logWithBindings(this.getBindings(), "debug", ...args);
+	}
+	/**
+	* Emite un mensaje a nivel `info` con los bindings actuales del scope.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales.
+	*
+	* @example
+	* logger.scope('AUTH').info('Login exitoso', { userId });
+	*/
+	info(...args) {
+		this.parent.logWithBindings(this.getBindings(), "info", ...args);
+	}
+	/**
+	* Emite un mensaje a nivel `warn` con los bindings actuales del scope.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales.
+	*
+	* @example
+	* logger.scope('CACHE').warn('Cache miss', { key });
+	*/
+	warn(...args) {
+		this.parent.logWithBindings(this.getBindings(), "warn", ...args);
+	}
+	/**
+	* Emite un mensaje a nivel `error` con los bindings actuales del scope.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales (típicamente
+	*   un `Error` o contexto del fallo).
+	*
+	* @example
+	* logger.scope('DB').error('Conexión rechazada', err);
+	*/
+	error(...args) {
+		this.parent.logWithBindings(this.getBindings(), "error", ...args);
+	}
+	/**
+	* Emite un mensaje con badge visual `SUCCESS` a nivel `info`. Úselo para
+	* hitos positivos dentro del scope (conexión establecida, sync completo,
+	* commit aplicado).
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales.
+	*
+	* @example
+	* logger.scope('SYNC').success('Sincronización completa', { count: 42 });
+	*/
+	success(...args) {
+		const bindings = this.getBindings();
+		this.parent.logWithBindingsAndTag(bindings, "info", "success", ...args);
+	}
+	/**
+	* Emite un mensaje a nivel `critical` con los bindings actuales del scope.
+	* Reservado para fallos que detienen el flujo de la aplicación.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales.
+	*
+	* @example
+	* logger.scope('PAY').critical('Pasarela inaccesible', err);
+	*/
+	critical(...args) {
+		this.parent.logWithBindings(this.getBindings(), "critical", ...args);
+	}
+	/**
+	* Emite un mensaje a nivel `trace` (verbosidad máxima) con los bindings
+	* actuales del scope. Solo aparece si la verbosity global lo permite.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales.
+	*
+	* @example
+	* logger.scope('NET').trace('packet', { bytes });
+	*/
+	trace(...args) {
+		this.parent.logWithBindings(this.getBindings(), "trace", ...args);
+	}
+	/**
+	* Delegación a {@link Logger.step}: dibuja una barra de progreso discreta
+	* `current/total` para este scope.
+	*
+	* @param {number} current - Paso actual (1-indexed).
+	* @param {number} total - Total de pasos.
+	* @param {string} message - Texto mostrado junto al contador.
+	* @see {@link Logger.step}
+	*/
+	step(current, total, message) {
+		this.parent.step(current, total, message);
+	}
+	/**
+	* Delegación a {@link Logger.header}: imprime un título con separadores visuales.
+	*
+	* @param {string} title - Texto del título.
+	* @param {string} [subtitle] - Subtítulo opcional bajo el título.
+	* @see {@link Logger.header}
+	*/
+	header(title, subtitle) {
+		this.parent.header(title, subtitle);
+	}
+	/**
+	* Delegación a {@link Logger.divider}: imprime una línea separadora horizontal.
+	* @see {@link Logger.divider}
+	*/
+	divider() {
+		this.parent.divider();
+	}
+	/**
+	* Delegación a {@link Logger.blank}: inserta una línea en blanco.
+	* @see {@link Logger.blank}
+	*/
+	blank() {
+		this.parent.blank();
+	}
+	/**
+	* Delegación a {@link Logger.box}: dibuja un recuadro ANSI alrededor de `content`.
+	*
+	* @param {string} content - Texto a enmarcar.
+	* @param {IBoxOptions} [options] - Opciones de estilo del box.
+	* @see {@link Logger.box}
+	*/
+	box(content, options) {
+		this.parent.box(content, options);
+	}
+	/**
+	* Delegación a {@link Logger.cliTable}: renderiza `rows` como tabla ASCII.
+	*
+	* @param {Record<string, unknown>[]} rows - Filas a mostrar.
+	* @param {ITableOptions} [options] - Opciones de columnas y estilo.
+	* @see {@link Logger.cliTable}
+	*/
+	cliTable(rows, options) {
+		this.parent.cliTable(rows, options);
+	}
+	/**
+	* Delegación a {@link Logger.spinner}: arranca un spinner con `message`.
+	*
+	* @param {string} message - Texto a mostrar al lado del spinner.
+	* @returns {ISpinnerHandle} Handle para detener/actualizar el spinner.
+	* @see {@link Logger.spinner}
+	*/
+	spinner(message) {
+		return this.parent.spinner(message);
+	}
+	/**
+	* Delegación a {@link Logger.setCLILevel}: ajusta el nivel mínimo de las
+	* primitivas CLI visibles.
+	*
+	* @param {CLILogLevel} level - Nivel CLI (`silent` … `verbose`).
+	* @see {@link Logger.setCLILevel}
+	*/
+	setCLILevel(level) {
+		this.parent.setCLILevel(level);
+	}
+	/**
+	* Apila un contexto en el prefijo del scope. Invocado por
+	* {@link ContextLogger}; los clientes no deben llamarlo directamente.
+	*
+	* @param {string} context - Nombre del contexto a apilar.
+	* @internal
+	*/
+	_pushContext(context) {
+		this.contextStack.push(context);
+	}
+	/**
+	* Desapila el último contexto del prefijo del scope. Invocado por
+	* {@link ContextLogger}; los clientes no deben llamarlo directamente.
+	*
+	* @internal
+	*/
+	_popContext() {
+		this.contextStack.pop();
+	}
 };
+/**
+* Logger especializado para llamadas a APIs y servicios externos.
+*
+* Extiende {@link ScopedLogger} pre-seteando el badge `API` y exponiendo
+* atajos para eventos típicos de integración: llamadas lentas ({@link slow}),
+* rate limiting ({@link rateLimit}), fallos de autenticación ({@link auth}) y
+* APIs deprecadas ({@link deprecated}).
+*
+* Se obtiene con `logger.api(name)` y no se construye directamente.
+*
+* @example
+* import logger from '@mks2508/better-logger';
+*
+* const stripe = logger.api('Stripe');
+* stripe.info('Consultando customer', { id });
+* // salida: [API:Stripe] [API] Consultando customer
+*
+* stripe.slow('customer.retrieve', 1250);
+* // salida: [API:Stripe] [API] [SLOW] customer.retrieve (1250ms)
+*
+* @see {@link Logger.api}
+* @see {@link ScopedLogger}
+*/
+var APILogger = class extends ScopedLogger {
+	/**
+	* Construye un APILogger con scope `API:<apiName>` y badge `API` ya aplicado.
+	*
+	* Los clientes deben usar `logger.api(name)`.
+	*
+	* @param {Logger} parent - Logger raíz al que se delegan los mensajes.
+	* @param {string} apiName - Nombre del servicio/API (se prefija con `API:`).
+	*/
+	constructor(parent, apiName) {
+		super(parent, `API:${apiName}`);
+		this.badge("API");
+	}
+	/**
+	* Registra una llamada lenta con badge `SLOW` a nivel `warn`.
+	*
+	* @param {string} message - Descripción de la operación lenta.
+	* @param {number} [duration] - Duración medida en ms; si se pasa, se
+	*   anexa al mensaje como `(Nms)`.
+	*
+	* @example
+	* const t0 = performance.now();
+	* await stripe.customers.retrieve(id);
+	* logger.api('Stripe').slow('retrieve', performance.now() - t0);
+	*/
+	slow(message, duration) {
+		this.badge("SLOW");
+		const msg = duration ? `${message} (${duration}ms)` : message;
+		this.warn(msg);
+	}
+	/**
+	* Registra un evento de rate limiting (HTTP 429) con badge `RATE_LIMIT`.
+	*
+	* @param {string} message - Detalle del límite golpeado.
+	*
+	* @example
+	* logger.api('GitHub').rateLimit('Secondary rate limit on /search');
+	*/
+	rateLimit(message) {
+		this.badge("RATE_LIMIT");
+		this.warn(message);
+	}
+	/**
+	* Registra un fallo de autenticación (401/403) con badge `AUTH` a nivel
+	* `error`.
+	*
+	* @param {string} message - Detalle del fallo de credenciales/token.
+	*
+	* @example
+	* logger.api('OAuth').auth('Token expirado');
+	*/
+	auth(message) {
+		this.badge("AUTH");
+		this.error(message);
+	}
+	/**
+	* Marca una API como deprecada con badge `DEPRECATED` a nivel `warn`.
+	*
+	* @param {string} message - Mensaje guiando a la migración (endpoint
+	*   alternativo, versión retirada, etc.).
+	*
+	* @example
+	* logger.api('Legacy').deprecated('Usar v3; v2 se retira en Q4');
+	*/
+	deprecated(message) {
+		this.badge("DEPRECATED");
+		this.warn(message);
+	}
+};
+/**
+* Logger para componentes UI, módulos o cualquier unidad con ciclo de vida.
+*
+* Extiende {@link ScopedLogger} pre-seteando el badge `COMPONENT` y exponiendo
+* atajos para eventos típicos: {@link lifecycle}, {@link stateChange} y
+* {@link propsChange}.
+*
+* Se obtiene con `logger.component(name)` y no se construye directamente.
+*
+* @example
+* import logger from '@mks2508/better-logger';
+*
+* const cart = logger.component('Cart');
+* cart.lifecycle('mount');
+* // salida: [Cart] [COMPONENT] [LIFECYCLE] mount
+*
+* cart.stateChange('empty', 'has-items', { count: 3 });
+* // salida: [Cart] [COMPONENT] [STATE] empty → has-items { count: 3 }
+*
+* @see {@link Logger.component}
+* @see {@link ScopedLogger}
+*/
+var ComponentLogger = class extends ScopedLogger {
+	/**
+	* Construye un ComponentLogger con badge `COMPONENT` ya aplicado.
+	*
+	* Los clientes deben usar `logger.component(name)`.
+	*
+	* @param {Logger} parent - Logger raíz al que se delegan los mensajes.
+	* @param {string} componentName - Nombre del componente (scope label).
+	*/
+	constructor(parent, componentName) {
+		super(parent, componentName);
+		this.badge("COMPONENT");
+	}
+	/**
+	* Registra un evento de ciclo de vida con badge `LIFECYCLE` a nivel `info`.
+	*
+	* @param {string} event - Nombre del evento (`mount`, `unmount`,
+	*   `update`, ...).
+	* @param {string} [message] - Detalle opcional; si se omite, solo se
+	*   registra el nombre del evento.
+	*
+	* @example
+	* logger.component('Cart').lifecycle('mount', 'Modal abierto');
+	*/
+	lifecycle(event, message) {
+		this.badge("LIFECYCLE");
+		const msg = message ? `${event}: ${message}` : event;
+		this.info(msg);
+	}
+	/**
+	* Registra una transición de estado con badge `STATE` a nivel `info`.
+	*
+	* @param {string} from - Estado previo.
+	* @param {string} to - Estado nuevo.
+	* @param {unknown} [data] - Payload opcional asociado a la transición.
+	*
+	* @example
+	* const fsm = logger.component('FSM');
+	* fsm.stateChange('idle', 'loading');
+	* fsm.stateChange('loading', 'success', { items: 3 });
+	*/
+	stateChange(from, to, data) {
+		this.badge("STATE");
+		const msg = `${from} → ${to}`;
+		if (data) this.info(msg, data);
+		else this.info(msg);
+	}
+	/**
+	* Registra cambios de props/debug del componente con badge `PROPS` a nivel
+	* `debug`.
+	*
+	* @param {Record<string, unknown>} changes - Mapa prop → valor (típicamente
+	*   el diff de props entre renders).
+	*
+	* @example
+	* logger.component('Cart').propsChange({ itemCount: 5, currency: 'EUR' });
+	*/
+	propsChange(changes) {
+		this.badge("PROPS");
+		this.debug("Props changed:", changes);
+	}
+};
+/**
+* Handler de contexto apilable sobre un {@link ScopedLogger}.
+*
+* Permite agrupar bloques de logs bajo un sub-prefijo separado por `:`,
+* manteniendo la correlación visual sin necesidad de `console.group`. El
+* prefijo compuesto se forma como `<scopeName>:<contextName>`.
+*
+* Se crea con `scopedLogger.context(name)`. El patrón idiomático es
+* {@link run}/{@link runAsync} (auto push/pop con try/finally); {@link start}
+* y {@link end} permiten control manual cuando el bloque no cierra
+* léxicamente (event handlers distribuidos, promesas de larga duración).
+*
+* @example
+* import logger from '@mks2508/better-logger';
+*
+* const http = logger.scope('HTTP');
+*
+* // Bloque síncrono auto-cerrado
+* http.context('retry').run(() => {
+*   http.warn('Reintentando petición');
+* });
+* // salida: [HTTP:retry] Reintentando petición
+*
+* // Bloque async auto-cerrado
+* await http.context('refresh').runAsync(async () => {
+*   await refreshToken();
+*   http.info('Token refrescado');
+* });
+*
+* @see {@link ScopedLogger.context}
+*/
+var ContextLogger = class {
+	parentLogger;
+	contextName;
+	/**
+	* @param {ScopedLogger} parentLogger - Scope sobre el que se apila el contexto.
+	* @param {string} contextName - Sub-prefijo a apilar en el scope padre.
+	*/
+	constructor(parentLogger, contextName) {
+		this.parentLogger = parentLogger;
+		this.contextName = contextName;
+	}
+	/**
+	* Ejecuta `fn` síncrona dentro del contexto, garantizando el pop del
+	* prefijo incluso si `fn` lanza. El contexto solo está activo durante la
+	* ejecución de `fn`.
+	*
+	* @typeParam T - Tipo de retorno de `fn`.
+	* @param {() => T} fn - Función a ejecutar bajo el contexto.
+	* @returns {T} Lo que devuelva `fn`.
+	* @throws {unknown} Relanza cualquier excepción de `fn` tras desapilar.
+	*
+	* @example
+	* logger.scope('HTTP').context('warmup').run(() => {
+	*   logger.info('Pre-cargando caché');
+	* });
+	*/
+	run(fn) {
+		this.parentLogger._pushContext(this.contextName);
+		try {
+			return fn();
+		} finally {
+			this.parentLogger._popContext();
+		}
+	}
+	/**
+	* Variante async de {@link run}: mantiene el contexto activo mientras se
+	* awaiting la promesa de `fn`, incluyendo awaits internos.
+	*
+	* @typeParam T - Tipo resuelto por la promesa de `fn`.
+	* @param {() => Promise<T>} fn - Función async a ejecutar bajo el contexto.
+	* @returns {Promise<T>} Promesa que resuelve al valor de `fn`.
+	* @throws {unknown} Relanza cualquier rechazo de `fn` tras desapilar.
+	*
+	* @example
+	* await logger.scope('HTTP').context('fetch').runAsync(async () => {
+	*   const r = await fetch(url);
+	*   logger.info('Recibido', { status: r.status });
+	* });
+	*/
+	async runAsync(fn) {
+		this.parentLogger._pushContext(this.contextName);
+		try {
+			return await fn();
+		} finally {
+			this.parentLogger._popContext();
+		}
+	}
+	/**
+	* Apila el contexto manualmente. Útil cuando el bloque que lo consume no
+	* cierra léxicamente (event handlers, timeouts, streams). Debe emparejarse
+	* con un {@link end} posterior; olvidarlo deja el prefijo contaminado para
+	* los logs siguientes del scope.
+	*
+	* @example
+	* const ctx = logger.scope('WS').context('subscribe');
+	* socket.onopen  = () => { ctx.start(); ctx.info('connected'); };
+	* socket.onclose = () => { ctx.info('disconnected'); ctx.end(); };
+	* @see {@link end}
+	*/
+	start() {
+		this.parentLogger._pushContext(this.contextName);
+	}
+	/**
+	* Desapila el último contexto abierto con {@link start}.
+	*
+	* @see {@link start}
+	*/
+	end() {
+		this.parentLogger._popContext();
+	}
+	/**
+	* Atajo a `scopedLogger.debug(...)`. El contexto se aplica al prefijo del
+	* scope padre solo si se invoca dentro de un bloque {@link run}/{@link start}.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales.
+	*/
+	debug(...args) {
+		this.parentLogger.debug(...args);
+	}
+	/**
+	* Atajo a `scopedLogger.info(...)`. El contexto se aplica al prefijo del
+	* scope padre solo si se invoca dentro de un bloque {@link run}/{@link start}.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales.
+	*/
+	info(...args) {
+		this.parentLogger.info(...args);
+	}
+	/**
+	* Atajo a `scopedLogger.warn(...)`. El contexto se aplica al prefijo del
+	* scope padre solo si se invoca dentro de un bloque {@link run}/{@link start}.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales.
+	*/
+	warn(...args) {
+		this.parentLogger.warn(...args);
+	}
+	/**
+	* Atajo a `scopedLogger.error(...)`. El contexto se aplica al prefijo del
+	* scope padre solo si se invoca dentro de un bloque {@link run}/{@link start}.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales.
+	*/
+	error(...args) {
+		this.parentLogger.error(...args);
+	}
+	/**
+	* Atajo a `scopedLogger.success(...)`. El contexto se aplica al prefijo del
+	* scope padre solo si se invoca dentro de un bloque {@link run}/{@link start}.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales.
+	*/
+	success(...args) {
+		this.parentLogger.success(...args);
+	}
+	/**
+	* Atajo a `scopedLogger.critical(...)`. El contexto se aplica al prefijo
+	* del scope padre solo si se invoca dentro de un bloque {@link run}/{@link start}.
+	*
+	* @param {...unknown[]} args - Mensaje y argumentos adicionales.
+	*/
+	critical(...args) {
+		this.parentLogger.critical(...args);
+	}
+};
+//#endregion
+//#region src/cli/CommandProcessor.ts
+/**
+* Procesador central del CLI del logger. Resuelve nombres de comando (con
+* aliases), despacha ejecución, mantiene historial acotado (max 100 entradas)
+* y soporta un sistema de plugins para extensión de terceros.
+*
+* No es un binario standalone: se invoca desde la consola del navegador vía
+* `window.cli("<command>")` (modo interactivo habilitado por
+* {@link enterInteractiveMode}) o desde código vía `logger.cli()`. El
+* constructor no registra ningún comando por defecto — usar
+* {@link createDefaultCLI} para obtener una instancia con los 8 comandos
+* estándar ya cargados.
+*
+* @example
+* ```ts
+* const cli = createDefaultCLI();
+* await cli.processCommand('/themes', logger);
+* await cli.processCommand('/config theme=neon', logger);
+* ```
+*
+* @example
+* ```ts
+* // Modo interactivo: expone `window.cli` en el navegador
+* cli.enterInteractiveMode(logger);
+* // Desde la devtools: cli('help')  →  procesa '/help'
+* ```
+*
+* @see {@link createDefaultCLI}
+* @see {@link ICommand}
+* @see {@link ICLIPlugin}
+*/
+var CommandProcessor = class {
+	commands = /* @__PURE__ */ new Map();
+	aliases = /* @__PURE__ */ new Map();
+	plugins = /* @__PURE__ */ new Map();
+	history = [];
+	maxHistorySize = 100;
+	isInteractiveMode = false;
+	/**
+	* Registra un comando. Si el comando declara `aliases`, también se indexan
+	* para resolución. Un comando con el mismo `name` sobreescribe al previo.
+	*
+	* @param {ICommand} command - Comando a registrar.
+	* @see {@link ICommand}
+	*/
+	registerCommand(command) {
+		this.commands.set(command.name, command);
+		if (command.aliases) for (const alias of command.aliases) this.aliases.set(alias, command.name);
+	}
+	/**
+	* Registra un plugin: indexa todos sus commands y, si el plugin define
+	* `initialize`, lo invoca con el processor y el logger. Los comandos del
+	* plugin se registran vía {@link registerCommand} y sus aliases quedan
+	* resolvibles igual que los directos.
+	*
+	* @param {ICLIPlugin} plugin - Plugin a registrar.
+	* @param {Logger} [logger] - Logger activo; requerido solo si el plugin define `initialize`.
+	* @throws {Error} Si ya existe un plugin registrado con el mismo `name`.
+	* @see {@link unregisterPlugin}
+	*/
+	registerPlugin(plugin, logger) {
+		if (this.plugins.has(plugin.name)) throw new Error(`Plugin ${plugin.name} is already registered`);
+		this.plugins.set(plugin.name, plugin);
+		for (const command of plugin.commands) this.registerCommand(command);
+		if (plugin.initialize && logger) plugin.initialize(this, logger);
+	}
+	/**
+	* Desregistra un plugin por nombre: elimina todos sus commands (y los
+	* aliases que aportasen), invoca su hook `cleanup` si existe y lo quita
+	* del registry. No-op si el nombre no existe.
+	*
+	* @param {string} pluginName - Nombre del plugin a desregistrar.
+	* @see {@link registerPlugin}
+	*/
+	unregisterPlugin(pluginName) {
+		const plugin = this.plugins.get(pluginName);
+		if (!plugin) return;
+		for (const command of plugin.commands) {
+			this.commands.delete(command.name);
+			if (command.aliases) for (const alias of command.aliases) this.aliases.delete(alias);
+		}
+		if (plugin.cleanup) plugin.cleanup();
+		this.plugins.delete(pluginName);
+	}
+	/**
+	* Lista todos los commands registrados (directamente o vía plugins).
+	* No incluye aliases.
+	*
+	* @returns {ICommand[]} Snapshot array de los commands registrados.
+	*/
+	getCommands() {
+		return Array.from(this.commands.values());
+	}
+	/**
+	* Resuelve un comando por nombre canónico o alias. Devuelve `undefined`
+	* si no existe ninguno que matchee.
+	*
+	* @param {string} name - Nombre canónico o alias del comando.
+	* @returns {ICommand | undefined} El comando resuelto, o `undefined`.
+	*/
+	getCommand(name) {
+		let command = this.commands.get(name);
+		if (command) return command;
+		const aliasTarget = this.aliases.get(name);
+		if (aliasTarget) return this.commands.get(aliasTarget);
+	}
+	/**
+	* Devuelve una copia del historial de comandos ejecutados (más recientes
+	* primero). Acotado a 100 entradas por {@link maxHistorySize}; las más
+	* viejas se descartan al insertar nuevas.
+	*
+	* @returns {HistoryEntry[]} Snapshot del historial; mutar el array devuelto
+	*   no afecta al estado interno del processor.
+	*/
+	getHistory() {
+		return [...this.history];
+	}
+	/**
+	* Vacía el historial de comandos en memoria.
+	*/
+	clearHistory() {
+		this.history = [];
+	}
+	/**
+	* Lista los plugins actualmente registrados.
+	*
+	* @returns {ICLIPlugin[]} Snapshot array de plugins activos.
+	*/
+	getPlugins() {
+		return Array.from(this.plugins.values());
+	}
+	/**
+	* Activa el modo interactivo. Marca el flag interno y, si se ejecuta en
+	* navegador, expone `window.cli(command)` para invocar comandos desde la
+	* devtools sin prefijo `/` (se añade automáticamente al input).
+	*
+	* @param {Logger} logger - Logger activo (emite el mensaje de bienvenida
+	*   con hint sobre `cli(...)` en browser).
+	* @see {@link exitInteractiveMode}
+	*/
+	enterInteractiveMode(logger) {
+		this.isInteractiveMode = true;
+		logger.info("🔧 Interactive CLI mode activated. Type /exit to quit, /help for commands.");
+		if (typeof window !== "undefined") this.setupBrowserInteractiveMode(logger);
+	}
+	/**
+	* Desactiva el flag de modo interactivo. Nota: no elimina el `window.cli`
+	* que {@link enterInteractiveMode} haya expuesto en el navegador — el
+	* handler global sigue vivo hasta reload.
+	*
+	* @see {@link enterInteractiveMode}
+	*/
+	exitInteractiveMode() {
+		this.isInteractiveMode = false;
+	}
+	/**
+	* Instala `window.cli(command)` como wrapper delgado alrededor de
+	* {@link processCommand}, prefijando `/` automáticamente. Solo se invoca
+	* desde {@link enterInteractiveMode} cuando `window` está disponible.
+	*
+	* @internal
+	* @param logger - Logger activo, reenviado a cada invocación.
+	*/
+	setupBrowserInteractiveMode(logger) {
+		window.cli = (commandString) => {
+			return this.processCommand(`/${commandString}`, logger);
+		};
+		logger.info("💡 Use cli(\"command\") to execute CLI commands in browser console.");
+	}
+	/**
+	* Parsea y ejecuta un comando. El formato esperado es `/name args...`:
+	* split por espacios, primer token = nombre del comando, resto = args
+	* (re-joined con espacios). Si el comando no existe, loguea el error y
+	* sugiere similares vía {@link getSuggestions} ("Did you mean: ...?").
+	*
+	* Toda invocación (válida o no) se registra en el historial con flag de
+	* éxito/fallo según si `execute` resolvió o throweó.
+	*
+	* @param {string} commandString - Comando completo, debe empezar con `/`.
+	* @param {Logger} logger - Logger activo para output y errores.
+	* @returns {Promise<void>} Resuelve cuando el comando termina (sync o async).
+	*   Nunca rechaza: los errores de `execute` se capturan y se loguean.
+	* @see {@link ICommand.execute}
+	* @see {@link getSuggestions}
+	*/
+	async processCommand(commandString, logger) {
+		if (!commandString.startsWith("/")) {
+			logger.error("Invalid command. Commands must start with /");
+			this.addToHistory(commandString, false);
+			return;
+		}
+		const parts = commandString.slice(1).split(" ");
+		const commandName = parts[0] || "";
+		const args = parts.slice(1).join(" ");
+		const command = this.getCommand(commandName);
+		if (!command) {
+			logger.error(`Unknown command: ${commandName}. Type /help for available commands.`);
+			const suggestions = this.getSuggestions(commandName);
+			if (suggestions.length > 0) logger.info(`📋 Did you mean: ${suggestions.slice(0, 3).join(", ")}?`);
+			this.addToHistory(commandString, false);
+			return;
+		}
+		try {
+			await command.execute(args || "", logger);
+			this.addToHistory(commandString, true);
+		} catch (error) {
+			logger.error(`Command '${commandName}' failed:`, error);
+			this.addToHistory(commandString, false);
+		}
+	}
+	/**
+	* Inserta una entrada al frente del historial y trunca a
+	* {@link maxHistorySize} (100) si hace falta.
+	*
+	* @internal
+	* @param command - String crudo del comando ejecutado.
+	* @param success - Si la ejecución tuvo éxito.
+	*/
+	addToHistory(command, success) {
+		this.history.unshift({
+			command,
+			timestamp: /* @__PURE__ */ new Date(),
+			success
+		});
+		if (this.history.length > this.maxHistorySize) this.history = this.history.slice(0, this.maxHistorySize);
+	}
+	/**
+	* Devuelve nombres de comando que empiezan con el prefijo dado. Alimente
+	* el hint "Did you mean" de {@link processCommand} cuando un comando no
+	* se encuentra. Match por `startsWith` (no fuzzy).
+	*
+	* @param {string} partial - Prefijo parcial tipeado por el usuario.
+	* @returns {string[]} Nombres canónicos que matchean; aliases excluidos.
+	*/
+	getSuggestions(partial) {
+		return Array.from(this.commands.keys()).filter((name) => name.startsWith(partial));
+	}
+};
+//#endregion
+//#region src/cli/commands/ConfigCommand.ts
+/**
+* Comando `/config` del CLI runtime del {@link Logger}. Inspecciona o muta
+* la configuración del logger en vivo desde la DevTools console.
+*
+* Acepta tres modos de invocación:
+* - Sin argumentos: vuelca el estado actual como tabla agrupada.
+* - JSON completo (empieza con `{`): aplica un objeto de configuración parcial.
+* - Pares `key=value` separados por coma: atajo para mutaciones puntuales.
+*
+* Solo se aplican las keys de la whitelist interna (`theme`, `verbosity`,
+* `enableColors`, `enableTimestamps`, `enableStackTrace`, `globalPrefix`,
+* `bannerType`); cualquier otra key se rechaza con un `warn` y se ignora.
+*
+* @example
+* // Sin argumentos: ver estado actual
+* // > /config
+*
+* @example
+* // Objeto JSON completo
+* // > /config {"theme":"neon","verbosity":"debug"}
+*
+* @example
+* // Atajo key=value (múltiples pares separados por coma)
+* // > /config theme=neon,verbosity=debug,globalPrefix=MiApp
+*
+* @see {@link ICommand} para el contrato que implementa este comando.
+* @see {@link Logger.setTheme}, {@link Logger.setVerbosity},
+*      {@link Logger.setBannerType}, {@link Logger.setGlobalPrefix}
+*      para los setters subyacentes.
+*/
+var ConfigCommand = class {
+	name = "config";
+	description = "Show or update logger configuration";
+	usage = "/config [json|key=value,...]";
+	/**
+	* Ejecuta el comando `/config` contra el logger dado.
+	*
+	* @param args - Argumentos crudos del usuario. Vacío = status; con `{`
+	*               inicial = parse JSON; resto = pares `key=value` separados
+	*               por coma.
+	* @param logger - Instancia destino cuyos setters se invocan.
+	*/
+	execute(args, logger) {
+		if (!args) {
+			this.showStatus(logger);
+			return;
+		}
+		try {
+			if (args.startsWith("{")) {
+				const config = JSON.parse(args);
+				this.applyConfig(config, logger);
+			} else {
+				const pairs = args.split(",").map((pair) => pair.trim().split("="));
+				const config = {};
+				pairs.forEach(([key, value]) => {
+					if (key && value) config[key.trim()] = value.trim().replace(/["']/g, "");
+				});
+				this.applyConfig(config, logger);
+			}
+		} catch (error) {
+			logger.error("Invalid config format. Use JSON or key=value pairs:", error);
+			logger.info("Examples: /config {\"theme\":\"dark\"} or /config theme=neon,verbosity=debug");
+		}
+	}
+	showStatus(logger) {
+		const statusData = {
+			theme: logger.getConfig().theme || "default",
+			verbosity: logger.getConfig().verbosity,
+			colors: logger.getConfig().enableColors,
+			timestamps: logger.getConfig().enableTimestamps,
+			stackTrace: logger.getConfig().enableStackTrace,
+			globalPrefix: logger.getConfig().globalPrefix || "none",
+			bannerType: logger.getConfig().bannerType || "simple",
+			handlers: logger.getHandlers().length
+		};
+		logger.group("⚙️ Logger Configuration");
+		logger.table(statusData);
+		logger.groupEnd();
+	}
+	applyConfig(config, logger) {
+		const validKeys = [
+			"theme",
+			"verbosity",
+			"enableColors",
+			"enableTimestamps",
+			"enableStackTrace",
+			"globalPrefix",
+			"bannerType"
+		];
+		const applied = [];
+		Object.entries(config).forEach(([key, value]) => {
+			if (validKeys.includes(key)) if (key === "theme" && typeof value === "string") {
+				logger.setTheme(value);
+				applied.push(`${key}=${value}`);
+			} else if (key === "bannerType" && typeof value === "string") {
+				logger.setBannerType(value);
+				applied.push(`${key}=${value}`);
+			} else if (key === "verbosity") {
+				logger.setVerbosity(value);
+				applied.push(`${key}=${value}`);
+			} else if (key === "globalPrefix") {
+				logger.setGlobalPrefix(value);
+				applied.push(`${key}=${value}`);
+			} else {
+				logger.updateConfig({ [key]: value });
+				applied.push(`${key}=${value}`);
+			}
+			else logger.warn(`Invalid config key: ${key}`);
+		});
+		if (applied.length > 0) logger.success(`Configuration updated: ${applied.join(", ")}`);
+	}
+};
+//#endregion
+//#region src/cli/commands/ThemeCommand.ts
+/**
+* Comando `/themes` del CLI runtime del {@link Logger}. Lista los presets
+* temáticos disponibles en {@link THEME_PRESETS}, renderizando una preview
+* con los colores reales de cada tema (background, foreground, border).
+*
+* Es de solo lectura: no muta el logger. Útil para descubrir qué tema
+* aplicar antes de correr `/config theme=<name>`.
+*
+* @example
+* // Listar todos los temas con preview coloreada
+* // > /themes
+*
+* @see {@link THEME_PRESETS} para el catálogo completo de temas.
+* @see {@link ConfigCommand} para aplicar un tema vía `/config theme=...`.
+*/
+var ThemesCommand = class {
+	name = "themes";
+	description = "Show available theme presets";
+	usage = "/themes";
+	/**
+	* Ejecuta el comando `/themes` contra el logger dado.
+	*
+	* @param _args - Ignorado (comando sin parámetros).
+	* @param logger - Instancia usada para abrir/cerrar el `group` de salida.
+	*/
+	execute(_args, logger) {
+		logger.group("🎨 Available Themes");
+		Object.keys(THEME_PRESETS).forEach((themeName) => {
+			const preview = THEME_PRESETS[themeName];
+			const previewStyle = new StyleBuilder().bg(preview.info.background).color(preview.info.color).padding("4px 8px").rounded("4px").border(preview.info.border).build();
+			console.log(`%c${themeName}`, previewStyle, `- ${themeName} theme preview`);
+		});
+		logger.groupEnd();
+	}
+};
+/**
+* Comando `/banners` del CLI runtime del {@link Logger}. Enumera los tipos
+* de banner disponibles en {@link BANNER_VARIANTS} (`simple`, `ascii`,
+* `unicode`, ...) con una mini-preview de cada uno para inspección visual.
+*
+* Es de solo lectura: no muta el logger. Para cambiar el banner activo
+* usar {@link BannerCommand}.
+*
+* @example
+* // Listar todas las variantes de banner con preview
+* // > /banners
+*
+* @see {@link BANNER_VARIANTS} para el catálogo completo de variantes.
+* @see {@link BannerCommand} para aplicar un tipo concreto.
+*/
+var BannersCommand = class {
+	name = "banners";
+	description = "Show available banner types";
+	usage = "/banners";
+	/**
+	* Ejecuta el comando `/banners` contra el logger dado.
+	*
+	* @param _args - Ignorado (comando sin parámetros).
+	* @param logger - Instancia usada para abrir/cerrar el `group` de salida.
+	*/
+	execute(_args, logger) {
+		logger.group("🖼️ Available Banner Types");
+		Object.keys(BANNER_VARIANTS).forEach((bannerName) => {
+			const banner = BANNER_VARIANTS[bannerName];
+			console.log(`%c${bannerName}`, "font-weight: bold; color: #667eea;");
+			console.log(`%cPreview:`, "color: #666; font-size: 12px;");
+			if (bannerName === "simple") console.log(`%c${banner.text}`, banner.style);
+			else if (bannerName === "ascii") console.log(`%c${banner.text.split("\n").slice(1, 4).join("\n")}...`, "font-family: monospace; color: #667eea; font-size: 10px;");
+			else if (bannerName === "unicode") console.log(`%c${banner.text}`, banner.style);
+			else console.log(`%c${bannerName} banner`, "color: #666; font-style: italic;");
+		});
+		logger.groupEnd();
+	}
+};
+/**
+* Comando `/banner [type]` del CLI runtime del {@link Logger}.
+*
+* - Sin argumentos: re-renderiza el banner actualmente activo.
+* - Con un tipo válido: lo aplica vía {@link Logger.setBannerType} y lo
+*   muestra inmediatamente.
+* - Con un tipo inválido: loguea un `error` listando las opciones válidas.
+*
+* @example
+* // Mostrar el banner actual
+* // > /banner
+*
+* @example
+* // Cambiar a un tipo concreto
+* // > /banner ascii
+*
+* @see {@link BANNER_VARIANTS} para los tipos aceptados.
+* @see {@link Logger.setBannerType} y {@link Logger.showBanner} para los
+*      métodos subyacentes.
+*/
+var BannerCommand = class {
+	name = "banner";
+	description = "Change or show current banner type";
+	usage = "/banner [type]";
+	/**
+	* Ejecuta el comando `/banner` contra el logger dado.
+	*
+	* @param args - Tipo de banner solicitado. Vacío = mostrar banner actual.
+	* @param logger - Instancia destino cuyo banner se actualiza/muestra.
+	*/
+	execute(args, logger) {
+		if (!args) {
+			logger.showBanner();
+			return;
+		}
+		if (args in BANNER_VARIANTS) {
+			logger.setBannerType(args);
+			logger.showBanner();
+		} else logger.error(`Invalid banner type: ${args}. Available: ${Object.keys(BANNER_VARIANTS).join(", ")}`);
+	}
+};
+//#endregion
+//#region src/cli/commands/ExportCommand.ts
+/**
+* Comando `/status` del CLI runtime del {@link Logger}. Vuelca la
+* configuración vigente y algunas estadísticas (theme, verbosity, flags
+* de features, handler count, bufferSize) en una tabla agrupada dentro
+* de la consola. Es de solo lectura: no muta el logger.
+*
+* @example
+* // Inspeccionar el estado actual del logger
+* // > /status
+*
+* @see {@link Logger.getConfig} fuente de los datos mostrados.
+*/
+var StatusCommand = class {
+	name = "status";
+	description = "Show current logger status and configuration";
+	usage = "/status";
+	/**
+	* Ejecuta el comando `/status` contra el logger dado.
+	*
+	* @param _args - Ignorado (comando sin parámetros).
+	* @param logger - Instancia de la que se lee la configuración.
+	*/
+	execute(_args, logger) {
+		const config = logger.getConfig();
+		const statusData = {
+			theme: config.theme ? config.theme : "default",
+			verbosity: config.verbosity,
+			colors: config.enableColors,
+			timestamps: config.enableTimestamps,
+			stackTrace: config.enableStackTrace,
+			globalPrefix: config.globalPrefix ? config.globalPrefix : "none",
+			bannerType: config.bannerType ? config.bannerType : "simple",
+			handlers: logger.getHandlers().length,
+			bufferSize: config.bufferSize ? config.bufferSize : 1e3
+		};
+		logger.group("⚙️ Logger Configuration");
+		logger.table(statusData);
+		logger.groupEnd();
+	}
+};
+/**
+* Comando `/reset` del CLI runtime del {@link Logger}. Restaura la
+* configuración a sus defaults de fábrica vía {@link Logger.resetConfig}.
+* No resetea handlers ni transports registrados — solo config.
+*
+* @example
+* // Volver a la configuración por defecto
+* // > /reset
+*
+* @see {@link Logger.resetConfig} para el método subyacente.
+*/
+var ResetCommand = class {
+	name = "reset";
+	description = "Reset logger configuration to defaults";
+	usage = "/reset";
+	/**
+	* Ejecuta el comando `/reset` contra el logger dado.
+	*
+	* @param _args - Ignorado (comando sin parámetros).
+	* @param logger - Instancia cuya configuración se resetea.
+	*/
+	execute(_args, logger) {
+		logger.resetConfig();
+	}
+};
+/**
+* Comando `/demo` del CLI runtime del {@link Logger}. Ejecuta una
+* demostración integral de las capacidades del logger: todos los niveles
+* de log (debug → critical), tablas, timers (`time`/`timeEnd`), SVG inline
+* y mensajes animados. Útil para validar que el styling funciona en un
+* entorno nuevo o tras un cambio de tema.
+*
+* @example
+* // Lanzar la demo completa
+* // > /demo
+*
+* @see {@link Logger} para cada feature individual (`table`, `time`,
+*      `logWithSVG`, `logAnimated`, ...).
+*/
+var DemoCommand = class {
+	name = "demo";
+	description = "Show comprehensive feature demonstration";
+	usage = "/demo";
+	/**
+	* Ejecuta el comando `/demo` contra el logger dado.
+	*
+	* @param _args - Ignorado (comando sin parámetros).
+	* @param logger - Instancia sobre la que se ejecutan los ejemplos.
+	*/
+	execute(_args, logger) {
+		logger.group("🎪 Advanced Logger Demo");
+		logger.debug("Debug message with detailed information");
+		logger.info("Informational message about system state");
+		logger.warn("Warning about deprecated feature");
+		logger.error("Error processing user request");
+		logger.success("Operation completed successfully");
+		logger.critical("Critical system failure detected");
+		logger.group("📊 Advanced Features Demo");
+		logger.table([
+			{
+				feature: "Styled Console",
+				status: "✅ Active",
+				performance: "Excellent"
+			},
+			{
+				feature: "Theme System",
+				status: "✅ Active",
+				performance: "Great"
+			},
+			{
+				feature: "CLI Interface",
+				status: "✅ Active",
+				performance: "Good"
+			},
+			{
+				feature: "Export System",
+				status: "✅ Active",
+				performance: "Excellent"
+			}
+		]);
+		logger.time("demo-operation");
+		setTimeout(() => {
+			logger.timeEnd("demo-operation");
+		}, 100);
+		logger.logWithSVG("SVG Demo");
+		logger.logAnimated("🌟 Animated Logger Demo 🌟", 2);
+		logger.groupEnd();
+		logger.groupEnd();
+		logger.info("Demo completed! Check the console for styled output.");
+	}
+};
+//#endregion
+//#region src/cli/help.ts
+/**
+* Comando `/help`: renderiza en consola el panel de ayuda del CLI con todos
+* los comandos disponibles, opciones de configuración, filtros de export y
+* ejemplos. El panel usa un gradient claro con {@link StyleBuilder} y los
+* quick tips se agrupan vía `logger.group`.
+*
+* Registrado por defecto por {@link createDefaultCLI}.
+*
+* @example
+* ```ts
+* const cli = createDefaultCLI();
+* await cli.processCommand('/help', logger);
+* // Imprime el panel ASCII con gradient + grupo "Quick Tips".
+* ```
+*
+* @see {@link ICommand}
+* @see {@link createDefaultCLI}
+*/
+var HelpCommand = class {
+	name = "help";
+	description = "Show CLI help and available commands";
+	usage = "/help [command]";
+	/**
+	* Renderiza el panel de ayuda completo. Actualmente ignora `_args`: el
+	* `usage` declara `/help [command]` (sub-comando opcional) pero la
+	* implementación siempre muestra el panel global.
+	*
+	* @param {string} _args - Argumentos opcionales (reservado para ayuda por
+	*   sub-comando; sin uso actual).
+	* @param {Logger} logger - Logger activo; se usa solo para `group`/`info`
+	*   de los quick tips.
+	* @returns {void}
+	*/
+	execute(_args, logger) {
+		const helpStyle = new StyleBuilder().bg("linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%)").color("#495057").padding("15px 20px").rounded("8px").border("1px solid #dee2e6").font("Monaco, Consolas, monospace").size("13px").build();
+		console.log(`%c
+╭─────────────── ADVANCED LOGGER CLI COMMANDS ─────────────────╮
+│                                                             │
+│  CONFIGURATION                                              │
+│  /config            Show current configuration              │
+│  /config {json}     Apply JSON configuration                │
+│  /config key=val    Apply key-value configuration           │
+│  /themes            Show available themes                   │
+│  /banners           Show available banner types             │
+│  /banner [type]     Change/show banner type                 │
+│  /status            Show logger status & buffer stats       │
+│  /demo              Show feature demonstration              │
+│  /reset             Reset to default configuration          │
+│                                                             │
+│  EXPORT & CLIPBOARD                                         │
+│  /export <format>   Export logs (json|csv|md|plain|html)    │
+│  /copy <format>     Copy logs to clipboard                  │
+│  /buffer-size N     Set log buffer size                     │
+│  /buffer-info       Show buffer statistics                  │
+│  /clear-buffer      Clear stored logs                       │
+│                                                             │
+│  EXPORT FILTERS (for export/copy commands)                 │
+│  --level error,warn     Filter by log levels                │
+│  --since 2h             Logs from last 2 hours              │
+│  --until 1h             Logs until 1 hour ago               │
+│  --prefix API,DB        Filter by prefixes                  │
+│  --exclude-prefix INT   Exclude prefixes                    │
+│  --last 50             Last 50 logs only                    │
+│  --first 25            First 25 logs only                   │
+│  --search "error"      Search in log messages               │
+│  --with-stack          Only logs with stack traces          │
+│  --errors-only         Only error + critical logs           │
+│  --group-by level      Group by level/prefix/hour           │
+│                                                             │
+│  EXPORT OPTIONS                                             │
+│  --minimal             Minimal output format                │
+│  --compact             Remove extra whitespace              │
+│  --styled              Include styling (HTML format)        │
+│                                                             │
+├──────────────────── CONFIGURATION OPTIONS ─────────────────┤
+│                                                             │
+│  theme: default | dark | light | neon | minimal | cyberpunk│
+│  bannerType: simple | ascii | unicode | svg | animated     │
+│  verbosity: debug | info | warn | error | critical | silent│
+│  enableColors: true | false                                 │
+│  enableTimestamps: true | false                             │
+│  enableStackTrace: true | false                             │
+│  globalPrefix: "string"                                     │
+│  bufferSize: number (50-10000)                             │
+│                                                             │
+├──────────────────────── EXAMPLES ──────────────────────────┤
+│                                                             │
+│  Basic Configuration:                                       │
+│  /config {"theme":"dark","verbosity":"debug"}               │
+│  /config theme=neon,bufferSize=2000                        │
+│  /banner animated       Change to animated banner          │
+│                                                             │
+│  Export Examples:                                           │
+│  /export json --level=error,warn --last=25                 │
+│  /export csv --since=2h --prefix=API                       │
+│  /export markdown --group-by=level --errors-only           │
+│  /export html --styled --since=1h                          │
+│                                                             │
+│  Clipboard Examples:                                        │
+│  /copy plain --minimal --last=10                           │
+│  /copy json --search="authentication" --compact            │
+│  /copy csv --since=30m --exclude-prefix=DEBUG              │
+│                                                             │
+│  Buffer Management:                                         │
+│  /buffer-size 5000      Increase buffer to 5000 logs       │
+│  /buffer-info           Show detailed buffer statistics     │
+│  /clear-buffer          Clear all stored logs               │
+│                                                             │
+│  Time Formats:                                              │
+│  --since=2h            2 hours ago                          │
+│  --since=30m           30 minutes ago                       │
+│  --since=1d            1 day ago                            │
+│  --since="2024-01-01T10:00:00Z"  Specific ISO date         │
+│                                                             │
+╰─────────────────────────────────────────────────────────────╯`, helpStyle);
+		logger.group("💡 Quick Tips");
+		[
+			"Use /demo to see all logger features in action",
+			"Logs are automatically stored in a circular buffer for export",
+			"Export formats: JSON (structured), CSV (Excel), Markdown (readable), Plain (simple), HTML (styled)",
+			"Time filters support relative (2h, 30m) and absolute (ISO) formats",
+			"Combine multiple filters: /export json --level=error --since=1h --search=\"auth\"",
+			"Use /copy for quick clipboard access instead of /export"
+		].forEach((tip) => {
+			logger.info(`• ${tip}`);
+		});
+		logger.groupEnd();
+	}
+};
+//#endregion
+//#region src/cli/index.ts
+/**
+* Crea un {@link CommandProcessor} con los 8 comandos estándar ya registrados:
+* `help`, `config`, `themes`, `banners`, `banner`, `status`, `reset` y
+* `demo`. Es el factory canónico — los consumidores normalmente no construyen
+* un `CommandProcessor` vacío a mano, ya que este no trae comandos cargados.
+*
+* @returns {CommandProcessor} Processor listo para usar, sin modo interactivo activo.
+*
+* @example
+* ```ts
+* const cli = createDefaultCLI();
+* await cli.processCommand('/help', logger);
+* await cli.processCommand('/config theme=neon', logger);
+* ```
+*
+* @example
+* ```ts
+* // Modo interactivo en el navegador: expone `window.cli`
+* const cli = createDefaultCLI();
+* cli.enterInteractiveMode(logger);
+* // desde devtools: cli('themes')  →  procesa '/themes'
+* ```
+*
+* @see {@link CommandProcessor}
+* @see {@link HelpCommand}
+*/
+function createDefaultCLI() {
+	const processor = new CommandProcessor();
+	processor.registerCommand(new HelpCommand());
+	processor.registerCommand(new ConfigCommand());
+	processor.registerCommand(new ThemesCommand());
+	processor.registerCommand(new BannersCommand());
+	processor.registerCommand(new BannerCommand());
+	processor.registerCommand(new StatusCommand());
+	processor.registerCommand(new ResetCommand());
+	processor.registerCommand(new DemoCommand());
+	return processor;
+}
+//#endregion
+//#region src/transports/TransportBridge.ts
+/**
+* Crea una instancia de {@link TransportBridge}.
+*
+* @internal
+*/
+function createTransportBridge() {
+	let transportManager;
+	return {
+		addTransport(target) {
+			if (!transportManager) transportManager = new TransportManager();
+			return transportManager.add(target);
+		},
+		removeTransport(id) {
+			return transportManager?.remove(id) ?? false;
+		},
+		async flushTransports() {
+			await transportManager?.flush();
+		},
+		async closeTransports() {
+			await transportManager?.close();
+		},
+		getTransportManager() {
+			return transportManager;
+		},
+		writeRecord(record) {
+			if (!transportManager) return;
+			transportManager.write(record).catch(() => {});
+		}
+	};
+}
+//#endregion
+//#region src/playground/TerminalBridge.ts
+/**
+* Crea un {@link TerminalBridge} usando un getter para evitar referencias
+* circulares en la construcción.
+*
+* @internal
+*/
+function createTerminalBridge(options) {
+	let _showPrimitives = true;
+	let _serverFallback;
+	return {
+		step(current, total, message) {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().step(current, total, message);
+				return;
+			}
+			const output = renderStep(current, total, message, getColorCapability());
+			process.stderr.write(output + "\n");
+		},
+		header(title, subtitle) {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().header(title, subtitle);
+				return;
+			}
+			const output = renderHeader(title, subtitle);
+			process.stderr.write(output + "\n");
+		},
+		divider() {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().divider();
+				return;
+			}
+			const output = renderDivider();
+			process.stderr.write(output + "\n");
+		},
+		blank() {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().blank();
+				return;
+			}
+			process.stderr.write("\n");
+		},
+		box(content, opts) {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().box(content, opts);
+				return;
+			}
+			const output = renderBox(content, opts, getColorCapability());
+			process.stderr.write(output + "\n");
+		},
+		cliTable(rows, opts) {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().cliTable(rows, opts);
+				return;
+			}
+			const output = renderTable(rows, opts, getColorCapability());
+			process.stderr.write(output + "\n");
+		},
+		spinner(message) {
+			const logger = options.getLogger();
+			if (!isRunningInTerminal() || options.config.outputMode === "silent") return new NoopSpinner(message, logger);
+			return new SpinnerManager(message, options.config, logger);
+		},
+		getShowPrimitives() {
+			return _showPrimitives;
+		},
+		setShowPrimitives(show) {
+			_showPrimitives = show;
+		},
+		getServerFallback() {
+			if (!_serverFallback) _serverFallback = new ServerFallback(options.getLogger());
+			return _serverFallback;
+		},
+		isInTerminal() {
+			return isRunningInTerminal();
+		}
+	};
+}
+//#endregion
+//#region src/Logger.ts
+THEME_PRESETS.default;
+/**
+* Clase principal Logger con capacidades avanzadas de logging
+* 
+* @class Logger
+* @description Sistema completo de logging con temas, badges, contextos y exportación.
+*              Detecta automáticamente el tema claro/oscuro del navegador.
+* 
+* @example
+* // Uso básico sin configuración
+* import logger from '@mks2508/better-logger';
+* logger.info('Aplicación iniciada');
+* logger.success('Conexión establecida');
+* 
+* @example
+* // Aplicar un preset temático
+* logger.preset('cyberpunk');
+* logger.warn('Advertencia con estilo neón');
+* 
+* @example
+* // Logger con scope para componentes
+* const auth = logger.component('Autenticación');
+* auth.info('Usuario intentando login');
+* auth.success('Login exitoso');
+* 
+*/
+var Logger = class Logger {
+	config;
+	scopedPrefix;
+	handlers = [];
+	timers = /* @__PURE__ */ new Map();
+	groupDepth = 0;
+	cliProcessor;
+	themeChangeListener;
+	badgeList = [];
+	displaySettings = {
+		showTimestamp: true,
+		showLocation: true,
+		showBadges: true
+	};
+	serializerBridge;
+	hookBridge;
+	logContext;
+	transportBridge;
+	/** Fijado por `success()` para que `log()` salte su propio dispatch. */
+	_successTagDispatched = false;
+	styleManager;
+	/** Controla si las CLI primitives (step, box, header, ...) deben renderizarse. */
+	_showPrimitives = true;
+	terminalBridge;
+	/**
+	* Referencia activa al smart-preset (fijada por `preset()`). Tipada como
+	* `unknown` para mantener limpia la surface pública; la consume
+	* `createStyledOutput`.
+	*/
+	_activePreset;
+	/**
+	* Nombre del smart-preset activo. Se guarda aparte para que la detección
+	* de cambio de tema pueda re-renderizar sin re-ejecutar el body del preset.
+	*/
+	_activePresetName;
+	/**
+	* Overrides aplicados por el último `customize()`. Se conservan para que
+	* `createStyledOutput` los lea después.
+	*/
+	_customization;
+	/**
+	* Bindings propios de este logger (provenientes de llamadas a `child()`).
+	* Source of truth única de la contribución de este logger a la cadena de contexto.
+	* @private
+	*/
+	_bindings = {};
+	/**
+	* Referencia al record de contexto mergueado del parent en el momento en
+	* que se creó este logger. Junto con `_bindings`, forma la cadena de
+	* contexto. `undefined` para el logger raíz.
+	* @private
+	*/
+	_parentContextRecord;
+	/**
+	* Crea una nueva instancia del Logger
+	* 
+	* @param {Partial<LoggerConfig>} config - Configuración opcional del logger
+	* 
+	* @example
+	* // Logger con configuración personalizada
+	* const logger = new Logger({
+	*   theme: 'neon',
+	*   globalPrefix: 'MiApp',
+	*   verbosity: 'debug',
+	*   bufferSize: 1000
+	* });
+	*/
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+		this.serializerBridge = createSerializerBridge();
+		this.hookBridge = createHookBridge();
+		this.logContext = createLogContext({
+			initialResource: this.config.resource,
+			childLoggerFactory: (childConfig) => {
+				return new Logger({
+					...this.config,
+					...childConfig
+				});
+			},
+			getParentContextRecord: () => this._captureMergedContext()
+		});
+		this.transportBridge = createTransportBridge();
+		this.styleManager = createStyleManager();
+		this.terminalBridge = createTerminalBridge({
+			config: this.config,
+			getLogger: () => this
+		});
+		this.cliProcessor = createDefaultCLI();
+		if (this.config.autoDetectTheme) this.setupAutoThemeDetection();
+	}
+	/**
+	* Configura la detección automática de tema con listener de cambios
+	* @private
+	* @description Detecta automáticamente si el navegador está en modo claro u oscuro
+	*/
+	setupAutoThemeDetection() {
+		if (this.themeChangeListener) {
+			this.themeChangeListener();
+			this.themeChangeListener = null;
+		}
+		this.themeChangeListener = setupThemeChangeListener((theme) => {
+			this.debug(`DevTools theme changed to: ${theme}`);
+		});
+	}
+	/**
+	* Obtiene la configuración actual del logger
+	* 
+	* @returns {LoggerConfig} Configuración completa actual
+	* 
+	* @example
+	* const config = logger.getConfig();
+	* console.log('Verbosidad actual:', config.verbosity);
+	* console.log('Tema actual:', config.theme);
+	* 
+	*/
+	getConfig() {
+		return { ...this.config };
+	}
+	/**
+	* Actualiza la configuración del logger
+	* 
+	* @param {Partial<LoggerConfig>} updates - Propiedades a actualizar
+	* 
+	* @example
+	* logger.updateConfig({
+	*   verbosity: 'debug',
+	*   enableTimestamps: false,
+	*   theme: 'cyberpunk'
+	* });
+	* 
+	*/
+	updateConfig(updates) {
+		const previousAutoDetect = this.config.autoDetectTheme;
+		this.config = {
+			...this.config,
+			...updates
+		};
+		if (updates.autoDetectTheme !== void 0 && updates.autoDetectTheme !== previousAutoDetect) {
+			if (updates.autoDetectTheme) this.setupAutoThemeDetection();
+			else if (this.themeChangeListener) {
+				this.themeChangeListener();
+				this.themeChangeListener = null;
+			}
+		}
+	}
+	/**
+	* Establece el prefijo global para todos los mensajes de log
+	* 
+	* @param {string} prefix - Prefijo a usar
+	* 
+	* @example
+	* logger.setGlobalPrefix('MiApp');
+	* logger.info('Iniciado'); // [MiApp] Iniciado
+	* 
+	*/
+	setGlobalPrefix(prefix) {
+		this.config.globalPrefix = prefix;
+	}
+	/**
+	* Establece el nivel de verbosidad para filtrar la salida de logs
+	* 
+	* @param {Verbosity} level - Nivel mínimo a mostrar ('debug' | 'info' | 'warn' | 'error' | 'critical' | 'silent')
+	* 
+	* @example
+	* logger.setVerbosity('warn');  // Solo muestra warn, error y critical
+	* logger.setVerbosity('debug'); // Muestra todos los niveles
+	* logger.setVerbosity('silent'); // No muestra nada
+	* 
+	*/
+	setVerbosity(level) {
+		this.config.verbosity = level;
+	}
+	/**
+	* Establece el tema del logger
+	* 
+	* @param {ThemeVariant} theme - Tema a aplicar ('default' | 'dark' | 'light' | 'neon' | 'minimal' | 'cyberpunk')
+	* 
+	* @example
+	* logger.setTheme('neon');      // Tema con colores neón
+	* logger.setTheme('minimal');   // Tema minimalista
+	* logger.setTheme('cyberpunk'); // Tema cyberpunk con efectos
+	* 
+	*/
+	setTheme(theme) {
+		if (hasPreset(theme)) {
+			this.preset(theme);
+			return;
+		}
+		if (this.styleManager.setTheme(theme)) {
+			this.config.theme = theme;
+			const bannersRecord = THEME_BANNERS;
+			if (theme in bannersRecord) {
+				const themeBanner = bannersRecord[theme];
+				if (themeBanner) this.writeOutput(`%c${themeBanner.simple}`, "info", [themeBanner.style], []);
+			}
+			this.success(`Theme changed to: ${theme}`);
+		} else this.error(`Invalid theme: ${theme}. Available:`, [...getAvailablePresets(), ...Object.keys(THEME_PRESETS)]);
+	}
+	/**
+	* Establece el tipo de banner para mostrar en la inicialización
+	* 
+	* @param {BannerType} bannerType - Tipo de banner ('simple' | 'ascii' | 'unicode' | 'svg' | 'animated')
+	* 
+	* @example
+	* logger.setBannerType('ascii');    // Banner con arte ASCII
+	* logger.setBannerType('unicode');  // Banner con caracteres Unicode
+	* logger.setBannerType('animated'); // Banner con animación
+	* 
+	*/
+	setBannerType(bannerType) {
+		this.config.bannerType = bannerType;
+		this.success(`Banner type changed to: ${bannerType}`);
+	}
+	/**
+	* Ejecuta `fn` dentro de un scope AsyncLocalStorage donde `bindings` se
+	* merguean al contexto para todas las llamadas de log dentro de `fn`.
+	*
+	* Sin `fn` (el shape legacy de setter): no-op por backwards compatibility.
+	* Preferir `child()` para bindings persistentes o `withContextAsync()`
+	* para callbacks async.
+	*
+	* @param bindings - Pares key-value a adjuntar durante la ejecución de `fn`
+	* @param fn - Función sincrónica opcional a ejecutar con los bindings en scope
+	* @returns El valor de retorno de `fn`, o `undefined` si no se pasa `fn`
+	*
+	* @example
+	* // Callback sincrónico scoped
+	* logger.withContext({ requestId: 'r-42' }, () => {
+	*   doWork(); // los logs de aquí ven requestId en attributes
+	* });
+	*
+	* @example
+	* // Binding persistente: usar child()
+	* const reqLog = logger.child({ requestId: 'r-42' });
+	* reqLog.info('handling request'); // attributes incluye requestId
+	*
+	* @see {@link child} para una copia inmutable con el contexto mergueado
+	* @see {@link withContextAsync} para la variante con callback async
+	*/
+	withContext(bindings, fn) {
+		return this.logContext.withContext(bindings, fn);
+	}
+	/**
+	* Variante async de `withContext`. Ejecuta `fn` dentro de un scope
+	* AsyncLocalStorage para que los bindings estén disponibles a todas las
+	* llamadas de log async dentro de `fn`.
+	*
+	* @param bindings - Pares key-value a adjuntar durante la ejecución de `fn`
+	* @param fn - Función async a ejecutar con los bindings en scope
+	* @returns El valor de retorno de `fn`
+	*
+	* @example
+	* await logger.withContextAsync({ requestId: 'r-42' }, async () => {
+	*   await fetchData(); // los logs de aquí ven requestId en attributes
+	* });
+	*
+	* @see {@link child} para un child logger persistente
+	* @see {@link withContext} para la variante con callback sincrónico
+	*/
+	withContextAsync(bindings, fn) {
+		return this.logContext.withContextAsync(bindings, fn);
+	}
+	/**
+	* Devuelve una copia inmutable de este logger con el contexto extra bound.
+	* Las llamadas futuras sobre el child emiten con el contexto mergueado,
+	* sin mutar al parent — el patrón canónico de MDC.
+	*
+	* @param extra - Pares key-value a adjuntar (requestId, userId, ...)
+	* @returns Un nuevo Logger con el contexto mergueado
+	*
+	* @example
+	* const reqLog = logger.child({ requestId: req.id });
+	* reqLog.info('start');     // emite attributes: { requestId }
+	* logger.info('unrelated'); // NO afectado — el contexto del parent queda intacto
+	*
+	*/
+	child(extra) {
+		const childLogger = this.logContext.child(extra);
+		childLogger._parentContextRecord = childLogger["__parentSnapshot"] ?? {};
+		childLogger._bindings = extra;
+		return childLogger;
+	}
+	/**
+	* Descarta todas las keys del contexto bound. Tras esta llamada, los
+	* records emitidos dejan de llevar `attributes` hasta que
+	* {@link withContext} o {@link child} restablezcan uno.
+	*
+	* @returns La misma instancia del logger, ahora sin contexto
+	*/
+	clearContext() {
+		this.logContext.clearContext();
+		return this;
+	}
+	/**
+	* Snapshot del contexto bound. El objeto devuelto es una shallow copy:
+	* mutarlo NO afecta lo que emiten las llamadas de log posteriores.
+	*
+	* @returns Un snapshot read-only del contexto actual
+	*/
+	getContext() {
+		let merged = this._parentContextRecord ?? {};
+		if (this._bindings && Object.keys(this._bindings).length > 0) merged = {
+			...merged,
+			...this._bindings
+		};
+		return merged;
+	}
+	/**
+	* Actualiza el resource OTel por defecto (service.name, version, env).
+	* Se persiste en el campo `resource` de cada record emitido, salvo que
+	* el propio record lo override.
+	*
+	* @param resource - Resource OTel parcial a merguear con el actual
+	* @returns La misma instancia del logger, para chaining
+	*
+	* @example
+	* logger.setResource({ 'service.name': 'api', 'service.version': '1.2.3' });
+	*
+	*/
+	setResource(resource) {
+		this.logContext.setResource(resource);
+		return this;
+	}
+	/**
+	* Reinicia el logger a la configuración por defecto
+	* 
+	* @example
+	* logger.resetConfig();
+	* // Todo vuelve a la configuración inicial
+	* 
+	*/
+	resetConfig() {
+		if (this.themeChangeListener) {
+			this.themeChangeListener();
+			this.themeChangeListener = null;
+		}
+		this.config = { ...DEFAULT_CONFIG };
+		this.styleManager.resetStyles();
+		if (this.config.autoDetectTheme) this.setupAutoThemeDetection();
+		this.success("Logger configuration reset to defaults");
+	}
+	/**
+	* Método de limpieza para eliminar listeners y liberar recursos.
+	*
+	* Vacía los transports (drain), limpia timers, suelta la lista de
+	* handlers legacy, resetea el group depth y limpia el context.
+	* Seguro de invocar múltiples veces.
+	*
+	* @example
+	* // Antes de cerrar la aplicación
+	* await logger.cleanup();
+	*
+	*/
+	async cleanup() {
+		if (this.themeChangeListener) {
+			try {
+				this.themeChangeListener();
+			} catch {}
+			this.themeChangeListener = null;
+		}
+		await this.transportBridge.closeTransports();
+		this.handlers.length = 0;
+		this.timers.clear();
+		this.badgeList = [];
+		this.logContext.clearContext();
+		this.groupDepth = 0;
+	}
+	/**
+	* Aplica un preset inteligente - funciona perfectamente sin configuración
+	* 
+	* @param {string} name - Nombre del preset a aplicar
+	* 
+	* @example
+	* // Presets disponibles
+	* logger.preset('default');       // Limpio y adaptativo
+	* logger.preset('cyberpunk');     // Colores neón, efectos brillantes
+	* logger.preset('glassmorphism'); // Efectos de blur modernos
+	* logger.preset('minimal');       // Minimalista y elegante
+	* logger.preset('debug');         // Modo desarrollo detallado
+	* logger.preset('production');    // Enfocado en producción
+	* 
+	*/
+	preset(name) {
+		if (!hasPreset(name)) {
+			this.error(`Unknown preset: ${name}. Available presets:`, getAvailablePresets());
+			return;
+		}
+		const presetConfig = getSmartPreset(name);
+		if (presetConfig) {
+			this.displaySettings.showTimestamp = presetConfig.timestamp?.show ?? true;
+			this.displaySettings.showLocation = presetConfig.location?.show ?? true;
+			this._activePreset = presetConfig;
+			this._activePresetName = name;
+			if (getEnvironment() === "browser") this.success(`Applied preset: ${name}`);
+		}
+	}
+	/**
+	* Lista todos los presets disponibles
+	* 
+	* @returns {string[]} Array con nombres de presets disponibles
+	* 
+	* @example
+	* const disponibles = logger.presets();
+	* console.log(disponibles); // ['default', 'cyberpunk', 'glassmorphism', ...]
+	* 
+	*/
+	presets() {
+		return getAvailablePresets();
+	}
+	/**
+	* Oculta el timestamp en los logs
+	* 
+	* @example
+	* logger.hideTimestamp();
+	* logger.info('Sin marca de tiempo'); // Sin timestamp visible
+	* 
+	*/
+	hideTimestamp() {
+		this.displaySettings.showTimestamp = false;
+		return this;
+	}
+	/**
+	* Muestra el timestamp en los logs
+	* 
+	* @example
+	* logger.showTimestamp();
+	* logger.info('Con marca de tiempo'); // [2024-01-15 10:30:45] Con marca de tiempo
+	* 
+	*/
+	showTimestamp() {
+		this.displaySettings.showTimestamp = true;
+		return this;
+	}
+	/**
+	* Oculta la información de ubicación (archivo:línea) en los logs
+	* 
+	* @example
+	* logger.hideLocation();
+	* logger.debug('Sin ubicación'); // Sin mostrar archivo:línea
+	* 
+	*/
+	hideLocation() {
+		this.displaySettings.showLocation = false;
+		return this;
+	}
+	/**
+	* Muestra la información de ubicación (archivo:línea) en los logs
+	* 
+	* @example
+	* logger.showLocation();
+	* logger.debug('Con ubicación'); // app.js:42 Con ubicación
+	* 
+	*/
+	showLocation() {
+		this.displaySettings.showLocation = true;
+		return this;
+	}
+	/**
+	* Oculta los badges en los logs
+	* 
+	* @example
+	* logger.hideBadges();
+	* const api = logger.api('REST');
+	* api.info('Sin badges'); // Sin mostrar [API] [REST]
+	* 
+	*/
+	hideBadges() {
+		this.displaySettings.showBadges = false;
+		return this;
+	}
+	/**
+	* Muestra los badges en los logs
+	*
+	* @example
+	* logger.showBadges();
+	* const api = logger.api('GraphQL');
+	* api.info('Con badges'); // [API] [GraphQL] Con badges
+	*
+	*/
+	showBadges() {
+		this.displaySettings.showBadges = true;
+		return this;
+	}
+	/**
+	* Establece múltiples badges para los logs
+	*
+	* @param {string[]} badges - Array de badges a mostrar
+	* @returns {this} Logger instance para encadenamiento
+	*
+	* @example
+	* logger.badges(['v3', 'stable']).info('Release publicado');
+	* logger.badges(['API', 'v2']).warn('Endpoint deprecado');
+	*
+	*/
+	badges(badges) {
+		this.badgeList = [...badges];
+		return this;
+	}
+	/**
+	* Añade un badge individual a la lista
+	*
+	* @param {string} badge - Badge a añadir
+	* @returns {this} Logger instance para encadenamiento
+	*
+	* @example
+	* logger.badge('DEBUG').badge('AUTH').info('Token validado');
+	*
+	*/
+	badge(badge) {
+		if (!this.badgeList.includes(badge)) this.badgeList.push(badge);
+		return this;
+	}
+	/**
+	* Limpia todos los badges activos
+	*
+	* @returns {this} Logger instance para encadenamiento
+	*
+	* @example
+	* logger.clearBadges().info('Sin badges');
+	*
+	*/
+	clearBadges() {
+		this.badgeList = [];
+		return this;
+	}
+	/**
+	* Crea un logger scoped para un componente o módulo del dominio.
+	*
+	* El `ComponentLogger` resultante prepends un badge `[name]` a cada
+	* mensaje y comparte configuración, transports y hooks con el logger
+	* padre. Útil para trazar el origen de los logs en apps con muchos
+	* módulos (Auth, DB, Cache, ...).
+	*
+	* @param {string} name - Nombre del componente que aparecerá como badge
+	* @returns {ComponentLogger} Logger scoped para el componente
+	*
+	* @example
+	* const auth = logger.component('Auth');
+	* auth.info('Validando token');   // [Auth] Validando token
+	* auth.success('Token válido');
+	*
+	* @see {@link api} para loggers de endpoints REST/GraphQL
+	* @see {@link scope} para un scope genérico sin badge de componente
+	*/
+	component(name) {
+		return new ComponentLogger(this, name);
+	}
+	/**
+	* Crea un logger scoped para un endpoint o surface de API.
+	*
+	* Como `component()` pero con styling orientado a APIs (badge `[API]`
+	* por defecto más el nombre del sub-scope). Útil para distinguir
+	* tráfico REST vs GraphQL vs WebSocket en los logs.
+	*
+	* @param {string} name - Nombre de la API o surface (p.ej. `'REST'`, `'GraphQL'`)
+	* @returns {APILogger} Logger scoped para la API
+	*
+	* @example
+	* const rest = logger.api('REST');
+	* rest.info('GET /users/42');     // [API] [REST] GET /users/42
+	*
+	* @see {@link component} para loggers de componentes de dominio
+	*/
+	api(name) {
+		return new APILogger(this, name);
+	}
+	/**
+	* Crea un logger scoped genérico con un prefijo.
+	*
+	* Variante minimal de `component()` / `api()`: solo aplica un prefijo
+	* de scope sin badges ni styling especial. Útil para sub-módulos que
+	* no encajan en las categorías de `component`/`api`.
+	*
+	* @param {string} name - Texto del prefijo de scope
+	* @returns {ScopedLogger} Logger con el scope aplicado
+	*
+	* @example
+	* const db = logger.scope('db');
+	* db.info('Pool conectado');      // [db] Pool conectado
+	*
+	* @see {@link component} y {@link api} para variantes con badges
+	*/
+	scope(name) {
+		return new ScopedLogger(this, name);
+	}
+	/**
+	* Personalización simple con configuración mínima
+	* 
+	* @param {Object} overrides - Opciones de personalización
+	* @param {Object} overrides.message - Configuración del mensaje
+	* @param {Object} overrides.timestamp - Configuración del timestamp
+	* @param {Object} overrides.location - Configuración de ubicación
+	* @param {Object} overrides.level - Configuración del nivel
+	* @param {Object} overrides.prefix - Configuración del prefijo
+	* @param {string} overrides.spacing - Espaciado: 'compact' | 'normal' | 'spacious'
+	* 
+	* @example
+	* logger.customize({
+	*   message: { color: '#00ff00', size: '16px' },
+	*   timestamp: { show: false },
+	*   spacing: 'compact'
+	* });
+	* 
+	*/
+	customize(overrides) {
+		if (overrides.timestamp?.show !== void 0) this.displaySettings.showTimestamp = overrides.timestamp.show;
+		if (overrides.location?.show !== void 0) this.displaySettings.showLocation = overrides.location.show;
+		if (overrides.prefix?.show !== void 0) {}
+		this._customization = overrides;
+		this.success("Customization applied");
+	}
+	/**
+	* Añade un handler personalizado para extender funcionalidad
+	* 
+	* @param {ILogHandler} handler - Handler que implementa ILogHandler
+	*
+	* @example
+	* // Handler personalizado para enviar logs a servidor
+	* logger.addHandler({
+	*   handle(level, message, args, metadata) {
+	*     fetch('/logs', { method: 'POST', body: JSON.stringify({ level, message }) });
+	*   }
+	* });
+	*
+	* @example
+	* // Para escribir a archivo, usa `addTransport` con un `FileTransport`
+	* logger.addTransport({ target: new FileTransport({ destination: 'app.log' }) });
+	*
+	*/
+	addHandler(handler) {
+		this.handlers.push(handler);
+	}
+	/**
+	* Obtiene todos los handlers registrados
+	* 
+	* @returns {ILogHandler[]} Array de handlers activos
+	*/
+	getHandlers() {
+		return [...this.handlers];
+	}
+	/**
+	* Añade un serializador personalizado para un tipo específico
+	*
+	* @param type - Constructor del tipo a serializar
+	* @param serializer - Función de serialización
+	* @param priority - Prioridad (mayor = primero)
+	*
+	* @example
+	* logger.addSerializer(Error, (err) => ({
+	*   name: err.name,
+	*   message: err.message,
+	*   stack: err.stack?.split('\n').slice(0, 5)
+	* }));
+	*
+	*/
+	addSerializer(type, serializer, priority) {
+		this.serializerBridge.addSerializer(type, serializer, priority);
+	}
+	/**
+	* Elimina un serializador registrado
+	*
+	* @param type - Constructor del tipo a remover
+	* @returns true si se eliminó
+	*
+	*/
+	removeSerializer(type) {
+		return this.serializerBridge.removeSerializer(type);
+	}
+	/**
+	* Obtiene el registry de serializadores
+	*
+	* @returns SerializerRegistry
+	*/
+	getSerializerRegistry() {
+		return this.serializerBridge.getSerializerRegistry();
+	}
+	/**
+	* Registra un hook para un evento
+	*
+	* @param event - Evento: 'beforeLog' | 'afterLog' | 'onError'
+	* @param callback - Función a ejecutar
+	* @param priority - Prioridad (mayor = primero)
+	* @returns Función para desregistrar
+	*
+	* @example
+	* const unsubscribe = logger.on('beforeLog', (entry) => {
+	*   entry.correlationId = getCorrelationId();
+	*   return entry;
+	* });
+	*
+	*/
+	on(event, callback, priority) {
+		return this.hookBridge.on(event, callback, priority);
+	}
+	/**
+	* Registra un hook que se ejecuta solo una vez
+	*
+	* @param event - Evento: 'beforeLog' | 'afterLog' | 'onError'
+	* @param callback - Función a ejecutar
+	* @param priority - Prioridad (mayor = primero)
+	* @returns Función para desregistrar
+	*
+	*/
+	once(event, callback, priority) {
+		return this.hookBridge.once(event, callback, priority);
+	}
+	/**
+	* Elimina un hook registrado
+	*
+	* @param event - Evento del hook
+	* @param callback - Callback a remover
+	* @returns true si se eliminó
+	*
+	*/
+	off(event, callback) {
+		return this.hookBridge.off(event, callback);
+	}
+	/**
+	* Añade un middleware al pipeline
+	*
+	* @param middleware - Función middleware
+	* @param priority - Prioridad (mayor = primero)
+	* @returns Función para desregistrar
+	*
+	* @example
+	* logger.use((entry, next) => {
+	*   entry.requestId = asyncLocalStorage.getStore()?.requestId;
+	*   next();
+	* });
+	*
+	*/
+	use(middleware, priority) {
+		return this.hookBridge.use(middleware, priority);
+	}
+	/**
+	* Obtiene el HookManager
+	*
+	* @returns HookManager
+	*/
+	getHookManager() {
+		return this.hookBridge.getHookManager();
+	}
+	/**
+	* Añade un transport para envío de logs
+	*
+	* @param target - Configuración del transport
+	* @returns ID único del transport
+	*
+	* @example
+	* // File transport
+	* logger.addTransport({
+	*   target: 'file',
+	*   options: { destination: '/var/log/app.log' }
+	* });
+	*
+	* @example
+	* // HTTP transport con batching
+	* logger.addTransport({
+	*   target: 'http',
+	*   options: {
+	*     url: 'https://logs.example.com',
+	*     batchSize: 100,
+	*     flushInterval: 5000
+	*   },
+	*   level: 'warn'
+	* });
+	*
+	*/
+	addTransport(target) {
+		return this.transportBridge.addTransport(target);
+	}
+	/**
+	* Elimina un transport
+	*
+	* @param id - ID del transport a remover
+	* @returns true si se eliminó
+	*
+	*/
+	removeTransport(id) {
+		return this.transportBridge.removeTransport(id);
+	}
+	/**
+	* Fuerza el flush de todos los transports
+	*
+	* @returns Promise que resuelve cuando todos los buffers están vaciados
+	*
+	*/
+	async flushTransports() {
+		await this.transportBridge.flushTransports();
+	}
+	/**
+	* Cierra todos los transports
+	*
+	* @returns Promise que resuelve cuando todos están cerrados
+	*
+	*/
+	async closeTransports() {
+		await this.transportBridge.closeTransports();
+	}
+	/**
+	* Obtiene el TransportManager
+	*
+	* @returns TransportManager o undefined si no hay transports
+	*/
+	getTransportManager() {
+		return this.transportBridge.getTransportManager();
+	}
+	/**
+	* Verifica si un nivel de log debe mostrarse según la verbosidad actual.
+	* @private
+	* @param {LogLevel} level - Nivel de log a verificar
+	* @returns {boolean} True si debe mostrarse, false si no
+	*/
+	shouldLog(level) {
+		if (this.config.verbosity === "silent") return false;
+		return LOG_LEVELS[level] >= LOG_LEVELS[this.config.verbosity];
+	}
+	/**
+	* Tag pendiente de inyectar en el siguiente `TransportRecord` emitido
+	* por `log()`. Lo fijan `success()` y `logWithBindingsAndTag()` antes
+	* de delegar; `log()` lo consume y lo resetea a `undefined`.
+	*
+	* @internal
+	*/
+	_dispatchTag;
+	/**
+	* Computa el contexto completamente mergueado para este logger.
+	*
+	* La cadena de contexto se construye en el momento de crear el child:
+	* cada child almacena el contexto fully-merged de su parent (en ese
+	* instante) como `_parentContextRecord`. Esto implica que
+	* `_parentContextRecord` ya contiene los bindings de todos los ancestros
+	* en el orden de precedencia correcto (root primero, child más cercano al final).
+	*
+	* Orden de merge (gana el último):
+	*   1. _parentContextRecord — snapshot del contexto mergueado del parent en la creación
+	*   2. _bindings            — bindings propios de este logger (llamadas a `child()`)
+	*   3. ALS store            — scope de `withContext`/`withContextAsync` (prioridad máxima)
+	*
+	* @internal
+	* @returns El record de contexto mergueado
+	*/
+	_getMergedContext() {
+		let merged = this._parentContextRecord ?? {};
+		if (this._bindings && Object.keys(this._bindings).length > 0) merged = {
+			...merged,
+			...this._bindings
+		};
+		const alsContext = this.logContext._getAlsStore?.() ?? {};
+		if (alsContext && Object.keys(alsContext).length > 0) merged = {
+			...merged,
+			...alsContext
+		};
+		return merged;
+	}
+	/** @internal Expone el contexto base mergueado (sin ALS) a la closure de la child factory de LogContext. */
+	_captureMergedContext() {
+		let merged = this._parentContextRecord ?? {};
+		if (this._bindings && Object.keys(this._bindings).length > 0) merged = {
+			...merged,
+			...this._bindings
+		};
+		return merged;
+	}
+	/**
+	* Construye y despacha un `TransportRecord` al {@link TransportManager}
+	* (no-op si no hay transports registrados). Lo comparten todos los
+	* caminos de log — `log()`, `success()` y los métodos visuales como
+	* `table()` / `group()` / `time()` — para que toda emisión atraviese
+	* el mismo pipeline de transports.
+	*
+	* @protected
+	* @param {LogLevel} level - Nivel canónico (trace/debug/info/warn/error/critical)
+	* @param {string} message - Mensaje final, post-hook
+	* @param {string | undefined} prefix - Prefijo efectivo (global + scope)
+	* @param {StackInfo | null} stackInfo - Ubicación del caller, opcional
+	* @param {Partial<TransportRecord>} [extra] - Campos extra a mergear en el record
+	*        (p.ej. `{ tag: 'success' }` o `attributes` adicionales)
+	*/
+	dispatchToTransports(level, message, prefix, stackInfo, extra) {
+		const record = {
+			level,
+			levelValue: LOG_LEVELS[level],
+			severityNumber: LOG_LEVEL_TO_SEVERITY_NUMBER[level],
+			severityText: LOG_LEVEL_TO_SEVERITY_TEXT[level],
+			time: Date.now(),
+			msg: message,
+			prefix,
+			location: stackInfo ? {
+				file: stackInfo.file,
+				line: stackInfo.line,
+				column: stackInfo.column,
+				function: stackInfo.function
+			} : void 0,
+			attributes: Object.keys(this.logContext._getContextRecord()).length > 0 ? toLogAttributes(this.logContext._getContextRecord()) : void 0,
+			resource: this.logContext._getResource() ? { ...this.logContext._getResource() } : void 0,
+			...extra
+		};
+		this.transportBridge.writeRecord(record);
+	}
+	/**
+	* Obtiene el prefijo efectivo (global + scope)
+	* @private
+	* @returns {string | undefined} Prefijo combinado o undefined
+	*/
+	getEffectivePrefix() {
+		const parts = [this.config.globalPrefix, this.scopedPrefix].filter(Boolean);
+		return parts.length > 0 ? parts.join(":") : void 0;
+	}
+	/**
+	* Método central de logging. Espera el hook pipeline `beforeLog`
+	* antes de despachar a consola y transports, para que redacciones
+	* o enriquecimientos (PII, correlation IDs) se reflejen en el
+	* mensaje emitido.
+	*
+	* Los callers fire-and-forget (p.ej. `logger.info(...)` sin `await`)
+	* siguen funcionando: el `Promise<void>` resultante se descarta.
+	* Se recomienda `await` cuando los hooks `beforeLog` mutan `message`.
+	*
+	* El tag opcional (`TransportRecord.tag`) NO se pasa como argumento:
+	* se establece vía `_dispatchTag` (ver `success()` y
+	* {@link logWithBindingsAndTag}) antes de invocar este método.
+	*
+	* @protected
+	* @param {LogLevel} level - Nivel del log
+	* @param {unknown[]} args - Argumentos a loggear (mensaje + datos)
+	* @returns {Promise<void>} Promesa que resuelve al completar el dispatch
+	*
+	*/
+	async log(level, ...args) {
+		if (!this.shouldLog(level)) return;
+		const dispatchTag = this._dispatchTag;
+		this._dispatchTag = void 0;
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		const prefix = this.getEffectivePrefix();
+		const timestamp = formatTimestamp();
+		const serializedArgs = args.map((arg) => this.serializerBridge.getSerializerRegistry().serialize(arg));
+		let message = serializedArgs.length > 0 ? String(serializedArgs[0]) : "";
+		if (this.badgeList.length > 0 && this.displaySettings.showBadges) message = this.badgeList.map((b) => `[${b}]`).join("") + " " + message;
+		const additionalArgs = serializedArgs.slice(1);
+		const hookEntry = {
+			level,
+			message,
+			args: serializedArgs,
+			timestamp,
+			prefix,
+			stackInfo: stackInfo ?? void 0
+		};
+		let processed;
+		try {
+			processed = await this.hookBridge.getHookManager().emit("beforeLog", hookEntry);
+		} catch (error) {
+			console.error("HookManager beforeLog failed:", error);
+			processed = hookEntry;
+		}
+		message = processed.message;
+		const [format, ...styles] = createStyledOutput(level, this.styleManager.getStyles(), prefix, message, this.displaySettings.showLocation ? stackInfo : null, this.config.autoDetectTheme, this._activePreset, this._activePresetName);
+		const finalFormat = "  ".repeat(this.groupDepth) + format;
+		this.writeOutput(finalFormat, level, styles, additionalArgs);
+		const metadata = {
+			timestamp,
+			level,
+			prefix,
+			stackInfo: stackInfo ?? void 0
+		};
+		this.handlers.forEach((handler) => {
+			try {
+				handler.handle(level, message, serializedArgs, metadata);
+			} catch (error) {
+				console.error("Log handler failed:", error);
+			}
+		});
+		if (dispatchTag !== void 0) this.dispatchToTransports(level, message, prefix, stackInfo, { tag: dispatchTag });
+		else this.dispatchToTransports(level, message, prefix, stackInfo);
+		this.hookBridge.getHookManager().emit("afterLog", processed).catch(() => {});
+	}
+	/**
+	* Emite un log aplicando bindings (badges, scope) al prefijo del
+	* mensaje antes de delegar en {@link Logger.log}.
+	*
+	* No es API pública de consumo: existe para que `ScopedLogger`
+	* (`component()` / `api()` / `scope()`) pueda reutilizar el pipeline
+	* central de `log()` sin duplicar la lógica de styling/badges.
+	*
+	* @internal
+	* @param {Bindings} bindings - Bindings de scope (badges, scope name, ...)
+	* @param {LogLevel} level - Nivel de log
+	* @param {unknown[]} args - Argumentos a loggear
+	* @returns {Promise<void>} Promesa del dispatch
+	*
+	* @see {@link logWithBindingsAndTag} para la variante con `tag`
+	*/
+	logWithBindings(bindings, level, ...args) {
+		if (!this.shouldLog(level)) return Promise.resolve();
+		let prefix = "";
+		const colorCapability = getColorCapability();
+		if (bindings.badges?.length) prefix += bindings.badges.map((b) => formatBadge(b, "pill", colorCapability, "#00ff88")).join(" ") + " ";
+		if (bindings.scope) prefix += formatBadge(bindings.scope, "pill", colorCapability, "#00ffff") + " ";
+		if (prefix && args.length > 0) args[0] = prefix + String(args[0]);
+		return this.log(level, ...args);
+	}
+	/**
+	* Como {@link logWithBindings} pero fija `_dispatchTag` antes de
+	* delegar, para que `log()` despache el `TransportRecord` con el
+	* tag indicado. Lo usa `ScopedLogger.success()` para propagar
+	* `tag: 'success'` a través del pipeline normal de `log()`.
+	*
+	* @internal
+	* @param {Bindings} bindings - Bindings de scope (badges, scope name, ...)
+	* @param {LogLevel} level - Nivel de log
+	* @param {LogTag} tag - Tag a inyectar en el `TransportRecord`
+	* @param {unknown[]} args - Argumentos a loggear
+	* @returns {Promise<void>} Promesa del dispatch
+	*/
+	logWithBindingsAndTag(bindings, level, tag, ...args) {
+		this._dispatchTag = tag;
+		return this.logWithBindings(bindings, level, ...args);
+	}
+	/**
+	* Registra mensajes de debug (nivel más verboso junto a `trace`).
+	* Pensado para diagnóstico de desarrollo: valores intermedios, flags
+	* de control flow, estado interno. Devuelve `Promise<void>`.
+	*
+	* Filtrado por defecto cuando `verbosity > 'debug'` (ver `setVerbosity`).
+	*
+	* @param {unknown[]} args - Mensaje + datos a inspeccionar
+	* @returns {Promise<void>} Promesa del dispatch
+	*
+	* @example
+	* logger.debug('Estado interno:', { conn, queueSize });
+	* logger.debug('Entrando en branch X');
+	*
+	* @see {@link trace} para diagnósticos aún más granulares
+	* @see {@link setVerbosity} para controlar el nivel mínimo visible
+	*/
+	debug(...args) {
+		return this.log("debug", ...args);
+	}
+	/**
+	* Registra mensajes informativos. El `await` retorna cuando el hook
+	* `beforeLog` y el dispatch a transports han terminado.
+	*
+	* @param args - Mensajes y datos informativos
+	*
+	* @example
+	* logger.info('Servidor iniciado en puerto 3000');
+	* await logger.info('Procesando', totalItems, 'elementos'); // espera hooks
+	*
+	*/
+	info(...args) {
+		return this.log("info", ...args);
+	}
+	/**
+	* Registra mensajes de advertencia.
+	*
+	* @param args - Mensajes de advertencia
+	*
+	*/
+	warn(...args) {
+		return this.log("warn", ...args);
+	}
+	/**
+	* Registra mensajes de error.
+	*
+	* @param args - Mensaje de error y stack traces
+	*
+	*/
+	error(...args) {
+		return this.log("error", ...args);
+	}
+	/**
+	* Registra mensajes de éxito. Mapeado internamente a nivel `info` con
+	* styling de success y `record.tag = 'success'` para que los transports
+	* puedan distinguirlo (sin perder info semantics para filtering).
+	*
+	* @param args - Mensaje + datos adicionales
+	*
+	* @example
+	* logger.success('Base de datos conectada');
+	* logger.success('Usuario creado con ID:', userId);
+	* logger.success('✓ Tests pasados: 42/42');
+	*
+	*/
+	async success(...args) {
+		if (!this.shouldLog("info")) return;
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		const prefix = this.getEffectivePrefix();
+		const timestamp = formatTimestamp();
+		const serializedArgs = args.map((arg) => this.serializerBridge.getSerializerRegistry().serialize(arg));
+		let message = serializedArgs.length > 0 ? String(serializedArgs[0]) : "";
+		if (this.badgeList.length > 0 && this.displaySettings.showBadges) message = this.badgeList.map((b) => `[${b}]`).join("") + " " + message;
+		const additionalArgs = serializedArgs.slice(1);
+		const hookEntry = {
+			level: "info",
+			message,
+			args: serializedArgs,
+			timestamp,
+			prefix,
+			stackInfo: stackInfo ?? void 0
+		};
+		try {
+			message = (await this.hookBridge.getHookManager().emit("beforeLog", hookEntry)).message;
+		} catch {}
+		const [format, ...styles] = createStyledOutput("info", this.styleManager.getStyles(), prefix, message, this.displaySettings.showLocation ? stackInfo : null, this.config.autoDetectTheme, this._activePreset, this._activePresetName);
+		const successStyle = this.styleManager.getStyles().success;
+		const emoji = successStyle?.emoji ?? "✅";
+		const label = successStyle?.label ?? "SUCCESS";
+		const successFormat = format.replace(/ℹ️ INFO/, `${emoji} ${label}`);
+		const finalFormat = "  ".repeat(this.groupDepth) + successFormat;
+		this.writeOutput(finalFormat, "info", styles, additionalArgs);
+		const metadata = {
+			timestamp,
+			level: "info",
+			prefix,
+			stackInfo: stackInfo ?? void 0
+		};
+		this.handlers.forEach((handler) => {
+			try {
+				handler.handle("info", message, args, metadata);
+			} catch (error) {
+				console.error("Log handler failed:", error);
+			}
+		});
+		this._dispatchTag = "success";
+		await this.log("info", ...args);
+		this.hookBridge.getHookManager().emit("afterLog", hookEntry).catch(() => {});
+	}
+	/**
+	* Registra información de trace (nivel más bajo, debajo de debug).
+	* Alineado con OpenTelemetry `TRACE` severity (1-4).
+	*
+	* @param args - Datos muy verbosos (entrada/salida de funciones, valores intermedios)
+	*
+	* @example
+	* logger.trace('Entrando en función processData');
+	* logger.trace('Variables intermedias:', { a, b, c });
+	*
+	*/
+	trace(...args) {
+		this.log("trace", ...args);
+	}
+	/**
+	* Registra errores críticos (prioridad más alta).
+	*
+	* @param args - Errores críticos del sistema
+	*
+	* @example
+	* await logger.critical('Sistema caído - reinicio inmediato requerido');
+	*
+	*/
+	critical(...args) {
+		return this.log("critical", ...args);
+	}
+	/**
+	* Muestra datos en formato de tabla. Pasa por la pipeline completa
+	* (outputMode-respecting writeOutput + transports + hooks).
+	*
+	* @param data - Array de objetos o matriz
+	* @param columns - Columnas específicas a mostrar (opcional)
+	*
+	* @example
+	* logger.table([{ id: 1, nombre: 'Juan' }, { id: 2, nombre: 'María' }]);
+	*
+	*/
+	table(data, columns) {
+		if (!this.shouldLog("info")) return;
+		const prefix = this.getEffectivePrefix();
+		const tableStyle = StylePresets.accent().build();
+		const format = `%c${`📊 TABLE${prefix ? ` [${prefix}]` : ""}`}`;
+		const styles = [tableStyle];
+		this.writeOutput(format, "info", styles, []);
+		[...columns ? [columns] : []];
+		if (this.config.outputMode !== "silent") if (columns) console.table(data, columns);
+		else console.table(data);
+		const message = `table:${Array.isArray(data) ? `${data.length} rows` : "data"}`;
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		this.dispatchToTransports("info", message, prefix, stackInfo, { attributes: {
+			...this.logContext._getContextRecord(),
+			"logger.visual": "table",
+			"logger.data": JSON.stringify(data).slice(0, 4096),
+			...columns ? { "logger.columns": columns.join(",") } : {}
+		} });
+	}
+	/**
+	* Inicia un grupo colapsable en la consola. Emite un marker a
+	* transports con `attributes.logger.visual = 'groupStart'` para que
+	* backends puedan reconstruir la jerarquía.
+	*
+	* @param label - Etiqueta del grupo
+	* @param collapsed - Si el grupo inicia colapsado (default: false)
+	*
+	* @example
+	* logger.group('Procesando usuarios');
+	* logger.info('Usuario 1 procesado');
+	* logger.groupEnd();
+	*
+	*/
+	group(label, collapsed = false) {
+		const groupStyle = new StyleBuilder().bg("linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%)").color("#1565c0").border("1px solid #90caf9").padding("4px 12px").rounded("6px").bold().build();
+		const format = `%c📁 ${label}`;
+		if (this.config.outputMode !== "silent") if (collapsed) console.groupCollapsed(format, groupStyle);
+		else console.group(format, groupStyle);
+		this.groupDepth++;
+		const prefix = this.getEffectivePrefix();
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		this.dispatchToTransports("info", `group:start:${label}`, prefix, stackInfo, { attributes: {
+			...this.logContext._getContextRecord(),
+			"logger.visual": "groupStart",
+			"logger.group.label": label,
+			"logger.group.collapsed": collapsed,
+			"logger.group.depth": this.groupDepth
+		} });
+	}
+	/**
+	* Finaliza el grupo actual de la consola. Emite un marker a transports
+	* simétrico al `group()` start, para que backends puedan cerrar la
+	* jerarquía correctamente.
+	*
+	* @example
+	* logger.group('Operaciones');
+	* logger.info('Operación 1');
+	* logger.groupEnd();
+	*
+	*/
+	groupEnd() {
+		if (this.groupDepth > 0) {
+			this.groupDepth--;
+			if (this.config.outputMode !== "silent") console.groupEnd();
+			const prefix = this.getEffectivePrefix();
+			const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+			this.dispatchToTransports("info", "group:end", prefix, stackInfo, { attributes: {
+				...this.logContext._getContextRecord(),
+				"logger.visual": "groupEnd",
+				"logger.group.depth": this.groupDepth
+			} });
+		}
+	}
+	/**
+	* Inicia un temporizador con la etiqueta dada
+	* 
+	* @param {string} label - Etiqueta identificadora del temporizador
+	* 
+	* @example
+	* logger.time('proceso-datos');
+	* // ... operación costosa ...
+	* logger.timeEnd('proceso-datos'); // ⏱️ Timer ended: proceso-datos - 1523.45ms
+	* 
+	*/
+	time(label) {
+		const timer = {
+			label,
+			startTime: (typeof performance !== "undefined" ? performance : Date).now()
+		};
+		this.timers.set(label, timer);
+		const timerStyle = StylePresets.warning().build();
+		const format = `%c⏱️ Timer started: ${label}`;
+		this.writeOutput(format, "debug", [timerStyle], []);
+	}
+	/**
+	* Finaliza un temporizador y muestra el tiempo transcurrido
+	*
+	* @param {string} label - Etiqueta del temporizador a finalizar
+	* @returns {number} Milisegundos transcurridos, o `-1` si no se encuentra el timer
+	*
+	* @example
+	* logger.time('consulta-db');
+	* await consultarBaseDatos();
+	* const elapsed = logger.timeEnd('consulta-db'); // ⏱️ Timer ended: consulta-db - 234.56ms
+	*
+	*/
+	timeEnd(label) {
+		const timer = this.timers.get(label);
+		if (!timer) {
+			this.warn(`Timer '${label}' does not exist`);
+			return -1;
+		}
+		const elapsed = (typeof performance !== "undefined" ? performance : Date).now() - timer.startTime;
+		this.timers.delete(label);
+		const timerStyle = StylePresets.success().build();
+		const format = `%c⏱️ Timer ended: ${label} - ${elapsed.toFixed(2)}ms`;
+		this.writeOutput(format, "info", [timerStyle], []);
+		const prefix = this.getEffectivePrefix();
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		this.dispatchToTransports("info", `timer:${label}`, prefix, stackInfo, {
+			tag: "success",
+			attributes: {
+				...this.logContext._getContextRecord(),
+				"logger.visual": "timer",
+				"logger.timer.label": label,
+				"logger.timer.elapsedMs": elapsed
+			}
+		});
+		return elapsed;
+	}
+	/**
+	* Muestra un banner con el tipo especificado o configurado
+	* 
+	* @param {BannerType} bannerType - Tipo de banner (opcional)
+	* 
+	* @example
+	* logger.showBanner('ascii');    // Banner ASCII art
+	* logger.showBanner('unicode');  // Banner con caracteres Unicode
+	* logger.showBanner('svg');      // Banner con gráfico SVG
+	* logger.showBanner();           // Usa el tipo configurado
+	* 
+	*/
+	showBanner(bannerType) {
+		displayInitBanner(bannerType ? bannerType : this.config.bannerType);
+	}
+	/**
+	* Registra mensaje con imagen SVG de fondo
+	* 
+	* @param {string} message - Mensaje a mostrar
+	* @param {string} svgContent - Contenido SVG personalizado (opcional)
+	* @param {StyleOptions} options - Opciones de estilo (ancho, alto, padding)
+	* 
+	* @example
+	* // SVG automático con gradiente
+	* logger.logWithSVG('🎆 Bienvenido a Better Logger');
+	* 
+	* @example
+	* // SVG personalizado
+	* const customSVG = '<svg>...</svg>';
+	* logger.logWithSVG('Logo', customSVG, { width: 400, height: 100 });
+	* 
+	*/
+	logWithSVG(message, svgContent, options = {}) {
+		if (!this.shouldLog("info")) return;
+		const { width = 300, height = 60, padding = "30px 150px" } = options;
+		let svgDataUri = "";
+		if (svgContent) svgDataUri = `data:image/svg+xml,${encodeURIComponent(svgContent)}`;
+		else {
+			const defaultSVG = `<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 ${width} ${height}'><defs><linearGradient id='grad' x1='0%' y1='0%' x2='100%' y2='0%'><stop offset='0%' style='stop-color:%23667eea'/><stop offset='100%' style='stop-color:%23764ba2'/></linearGradient></defs><rect width='100%' height='100%' fill='url(%23grad)' rx='4'/><text x='${width / 2}' y='${height / 2 + 5}' text-anchor='middle' fill='white' font-family='monospace' font-size='14' font-weight='bold'>${message}</text></svg>`;
+			svgDataUri = `data:image/svg+xml,${encodeURIComponent(defaultSVG)}`;
+		}
+		const svgStyle = new StyleBuilder().bg(`url("${svgDataUri}") no-repeat center center`).padding(padding).color("transparent").rounded("4px").build();
+		this.writeOutput(`%c${message}`, "info", [svgStyle], []);
+		const prefix = this.getEffectivePrefix();
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		this.dispatchToTransports("info", `svg:${message}`, prefix, stackInfo, { attributes: {
+			...this.logContext._getContextRecord(),
+			"logger.visual": "svg",
+			"logger.svg.width": width,
+			"logger.svg.height": height
+		} });
+	}
+	/**
+	* Registra mensaje con gradiente animado de fondo
+	* 
+	* @param {string} message - Mensaje a animar
+	* @param {number} duration - Duración de la animación en segundos (default: 3)
+	* 
+	* @example
+	* logger.logAnimated('🌈 Animación en progreso');
+	* logger.logAnimated('Cargando...', 5); // Animación de 5 segundos
+	* 
+	*/
+	logAnimated(message, duration = 3) {
+		if (!this.shouldLog("info")) return;
+		if (typeof document !== "undefined") {
+			if (!document.getElementById("logger-animations")) {
+				const style = document.createElement("style");
+				style.id = "logger-animations";
+				style.textContent = `
+                    @keyframes loggerGradient {
+                        0% { background-position: 0% 50%; }
+                        50% { background-position: 100% 50%; }
+                        100% { background-position: 0% 50%; }
+                    }
+                `;
+				document.head.appendChild(style);
+			}
+		}
+		const animatedStyle = new StyleBuilder().bg("linear-gradient(-45deg, #667eea, #764ba2, #667eea, #764ba2)").css("background-size", "400% 400%").color("#ffffff").padding("12px 20px").rounded("8px").bold().font("Monaco, Consolas, monospace").animation(`loggerGradient ${duration}s ease infinite`).display("inline-block").build();
+		this.writeOutput(`%c${message}`, "info", [animatedStyle], []);
+		const prefix = this.getEffectivePrefix();
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		this.dispatchToTransports("info", `animated:${message}`, prefix, stackInfo, { attributes: {
+			...this.logContext._getContextRecord(),
+			"logger.visual": "animated",
+			"logger.animation.durationSec": duration
+		} });
+	}
+	/**
+	* Muestra un indicador de progreso de pasos en la terminal
+	*
+	* @param {number} current - Número de paso actual
+	* @param {number} total - Número total de pasos
+	* @param {string} message - Descripción del paso
+	*
+	* @example
+	* logger.step(1, 5, 'Analyzing repository...');
+	* logger.step(2, 5, 'Generating commit message...');
+	*
+	*/
+	step(current, total, message) {
+		this.terminalBridge.step(current, total, message);
+	}
+	/**
+	* Muestra un header con estilo y subtítulo opcional
+	*
+	* @param {string} title - Texto del título principal
+	* @param {string} subtitle - Subtítulo opcional (se renderiza atenuado)
+	*
+	* @example
+	* logger.header('Commit Wizard', 'v2.0.0');
+	*
+	*/
+	header(title, subtitle) {
+		this.terminalBridge.header(title, subtitle);
+	}
+	/**
+	* Muestra una línea divisoria horizontal
+	*
+	* @example
+	* logger.divider();
+	*
+	*/
+	divider() {
+		this.terminalBridge.divider();
+	}
+	/**
+	* Emite una línea en blanco
+	*
+	* @example
+	* logger.blank();
+	*
+	*/
+	blank() {
+		this.terminalBridge.blank();
+	}
+	/**
+	* Renderiza contenido dentro de un box con borde
+	*
+	* @param {string} content - String de contenido (puede contener newlines)
+	* @param {IBoxOptions} options - Opciones de renderizado del box
+	*
+	* @example
+	* logger.box('3 commits generated\nProvider: Groq', { title: 'Done', borderColor: '#00ff00' });
+	*
+	*/
+	box(content, options) {
+		this.terminalBridge.box(content, options);
+	}
+	/**
+	* Renderiza un array de objetos como una tabla ASCII formateada.
+	* Distinto del método `table()` existente, que usa `console.table`.
+	*
+	* @param {Record<string, unknown>[]} rows - Array de objetos fila
+	* @param {ITableOptions} options - Opciones de renderizado de la tabla
+	*
+	* @example
+	* logger.cliTable([
+	*   { provider: 'Groq', status: 'Available', model: 'llama-3.3-70b' },
+	*   { provider: 'Gemini', status: 'Configured', model: 'gemini-2.5-flash' },
+	* ]);
+	*
+	*/
+	cliTable(rows, options) {
+		this.terminalBridge.cliTable(rows, options);
+	}
+	/**
+	* Crea un handle de spinner para mostrar progreso durante operaciones async.
+	* Devuelve un `NoopSpinner` en entornos non-TTY.
+	*
+	* @param {string} message - Texto inicial del spinner
+	* @returns {ISpinnerHandle} Controller del spinner
+	*
+	* @example
+	* const s = logger.spinner('Analyzing repository...');
+	* s.start();
+	* await analyzeRepo();
+	* s.succeed('Analysis complete (1.2s)');
+	*
+	*/
+	spinner(message) {
+		return this.terminalBridge.spinner(message);
+	}
+	/**
+	* Fija el nivel de verbosidad del CLI, controlando a la vez la verbosidad
+	* de logs y la visibilidad de las primitives
+	*
+	* @param {CLILogLevel} level - Nivel de log del CLI
+	*
+	* @example
+	* logger.setCLILevel('quiet');   // Solo errors, sin CLI primitives
+	* logger.setCLILevel('verbose'); // Debug logs + todas las CLI primitives
+	*
+	*/
+	setCLILevel(level) {
+		const mapping = CLI_LEVEL_MAP[level];
+		this.setVerbosity(mapping.verbosity);
+		this.terminalBridge.setShowPrimitives(mapping.showPrimitives);
+		this.config.cliLevel = level;
+	}
+	/**
+	* Devuelve el nivel de log del CLI actual
+	* @returns {CLILogLevel} Nivel de log del CLI actual
+	*/
+	get cliLevel() {
+		return this.config.cliLevel ?? "normal";
+	}
+	/**
+	* Escribe output formateado al destino configurado.
+	* Respeta la configuración `outputMode` para output a consola, silencioso o custom.
+	*
+	* @private
+	* @param {string} message - Mensaje de log formateado
+	* @param {LogLevel} level - Nivel de log
+	* @param {string[]} styles - Estilos CSS para la consola del navegador
+	* @param {unknown[]} additionalArgs - Argumentos adicionales a loggear
+	*/
+	writeOutput(message, level, styles, additionalArgs) {
+		const mode = this.config.outputMode ?? "console";
+		if (mode === "silent") return;
+		if (mode === "custom" && this.config.outputWriter) {
+			const fullMessage = additionalArgs.length > 0 ? `${message} ${additionalArgs.map((a) => String(a)).join(" ")}` : message;
+			this.config.outputWriter.write(fullMessage, level, styles);
+			return;
+		}
+		if (additionalArgs.length > 0) console.log(message, ...styles, ...additionalArgs);
+		else console.log(message, ...styles);
+	}
+	/**
+	* Procesador de comandos CLI para configuración y exportación del logger
+	* 
+	* @param {string} command - Comando CLI a ejecutar
+	* @returns {Promise<void>}
+	* 
+	* @example
+	* // Comandos disponibles
+	* await logger.cli('export json');      // Exporta logs en JSON
+	* await logger.cli('export csv');       // Exporta logs en CSV
+	* await logger.cli('theme list');       // Lista temas disponibles
+	* await logger.cli('theme set neon');   // Cambia al tema neon
+	* await logger.cli('config show');      // Muestra configuración actual
+	* await logger.cli('history clear');    // Limpia historial de logs
+	* await logger.cli('status');           // Muestra estado del logger
+	* await logger.cli('help');             // Muestra ayuda de comandos
+	* 
+	*/
+	async cli(command) {
+		if (!this.cliProcessor) {
+			this.error("CLI processor not initialized");
+			return;
+		}
+		await this.cliProcessor.processCommand(command, this);
+	}
+};
+/**
+* Instancia singleton lazy — se inicializa en la primera llamada a
+* {@link getDefaultLogger}, no al importar el módulo.
+*
+* @private
+*/
+let _defaultLogger = null;
+/**
+* Crea el singleton del Logger por defecto de forma lazy.
+*
+* El singleton se construye solo en la primera llamada, de modo que
+* importar el módulo nunca ejecuta `new Logger(...)` ni
+* `displayInitBanner()`. Así los imports del módulo quedan side-effect free.
+*
+* @returns La instancia compartida de Logger
+*/
+function getDefaultLogger() {
+	if (!_defaultLogger) {
+		_defaultLogger = new Logger({
+			verbosity: "info",
+			enableColors: true,
+			enableTimestamps: true,
+			enableStackTrace: true,
+			cliLevel: "normal"
+		});
+		try {
+			if (typeof window !== "undefined" || typeof document !== "undefined") displayInitBanner();
+		} catch {}
+	}
+	return _defaultLogger;
+}
+new Proxy({}, { get(_target, prop, receiver) {
+	const instance = getDefaultLogger();
+	const value = Reflect.get(instance, prop, receiver);
+	return typeof value === "function" ? value.bind(instance) : value;
+} });
+/**
+* Estrecha un contexto free-form `Record<string, unknown>` a un bag tipado
+* `ILogAttributes`. Los shapes desconocidos caen a strings JSON-encoded,
+* lo que mantiene conforme al transport OTLP (cada valor cae en un slot tipado).
+*
+* @param input - Contexto suministrado por el usuario (típicamente `Logger.context`).
+* @returns Un nuevo bag de attributes que satisface `ILogAttributes`.
+*/
+function toLogAttributes(input) {
+	const out = {};
+	for (const [key, value] of Object.entries(input)) {
+		const mapped = toAttributeValue(value);
+		if (mapped !== void 0) out[key] = mapped;
+	}
+	return out;
+}
+function toAttributeValue(value) {
+	if (value === null || value === void 0) return void 0;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) {
+		const values = [];
+		for (const item of value) {
+			const mapped = toAttributeValue(item);
+			if (mapped !== void 0) values.push(mapped);
+		}
+		return values;
+	}
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/index.ts
+/**
+* @fileoverview Better Logger — default entry point.
+*
+* Re-exports `Logger`, the scoped loggers, subpath-style bridges, and
+* cross-runtime styling/utility helpers. Side-effect free at import.
+*/
+let _logger = null;
+function getLogger() {
+	if (!_logger) _logger = new Logger();
+	return _logger;
+}
+/**
+* Default Logger singleton (lazy). Use this for the common case.
+*/
+var src_default = getLogger();
+/**
+* Top-level log methods bound to the default singleton.
+*/
+const debug = (...args) => getLogger().debug(...args);
+const info = (...args) => getLogger().info(...args);
+const warn = (...args) => getLogger().warn(...args);
+const error = (...args) => getLogger().error(...args);
+const success = (...args) => getLogger().success(...args);
+const critical = (...args) => getLogger().critical(...args);
+const trace = (...args) => getLogger().trace(...args);
+const table = (data, columns) => getLogger().table(data, columns);
+const group = (label, collapsed) => getLogger().group(label, collapsed);
+const groupEnd = () => getLogger().groupEnd();
+const time = (label) => getLogger().time(label);
+const timeEnd = (label) => getLogger().timeEnd(label);
+const setGlobalPrefix = (prefix) => getLogger().setGlobalPrefix(prefix);
+const scope = (name) => getLogger().scope(name);
+const component = (name) => getLogger().component(name);
+const api = (name) => getLogger().api(name);
+const badges = (badgeList) => getLogger().badges(badgeList);
+const badge = (badgeName) => getLogger().badge(badgeName);
+const clearBadges = () => getLogger().clearBadges();
+const setVerbosity = (level) => getLogger().setVerbosity(level);
+const addHandler = (handler) => getLogger().addHandler(handler);
+const setTheme = (theme) => getLogger().setTheme(theme);
+const setBannerType = (bannerType) => getLogger().setBannerType(bannerType);
+const showBanner = (bannerType) => getLogger().showBanner(bannerType);
+const logWithSVG = (message, svgContent, options) => getLogger().logWithSVG(message, svgContent, options);
+const logAnimated = (message, duration) => getLogger().logAnimated(message, duration);
+const cli = (command) => getLogger().cli(command);
+const addSerializer = (type, serializer, priority) => getLogger().addSerializer(type, serializer, priority);
+const removeSerializer = (type) => getLogger().removeSerializer(type);
+const on = (event, callback, priority) => getLogger().on(event, callback, priority);
+const once = (event, callback, priority) => getLogger().once(event, callback, priority);
+const off = (event, callback) => getLogger().off(event, callback);
+const use = (middleware, priority) => getLogger().use(middleware, priority);
+const addTransport = (target) => getLogger().addTransport(target);
+const removeTransport = (id) => getLogger().removeTransport(id);
+const flushTransports = () => getLogger().flushTransports();
+const closeTransports = () => getLogger().closeTransports();
+//#endregion
+export { APILogger, BANNER_VARIANTS, ComponentLogger, ContextLogger, DEFAULT_CONFIG, Logger, ScopedLogger, StyleBuilder, StylePresets, THEME_BANNERS, THEME_PRESETS, addHandler, addSerializer, addTransport, ansiBackground, ansiBold, ansiColor, ansiDim, ansiStyle, ansiUnderline, api, badge, badges, clearBadges, cli, closeTransports, component, createLogEntry, critical, debug, src_default as default, error, flushTransports, formatLogLevelANSI, formatSuccessANSI, formatTablePlain, formatTimestamp, getColorCapability, getConsoleMethod, getEnvironment, getEnvironmentInfo, getTerminalHeight, getTerminalWidth, group, groupEnd, info, isRunningInTerminal, logAnimated, logWithSVG, off, on, once, parseStackTrace, removeSerializer, removeTransport, safeSerialize, scope, setBannerType, setGlobalPrefix, setTheme, setVerbosity, showBanner, success, supportsANSI, table, time, timeEnd, trace, use, warn };
+
+//# sourceMappingURL=index.js.map