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

package/dist/index.cjs

@@ -1,2 +1,3402 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("./chunks/Logger-D_p3xnbq.js"),t=require("./chunks/environment-Dm66zOML.js"),s=require("./chunks/formatting-DNCAV66-.js"),r=require("./chunks/RemoteLogHandler-ymkQ97xl.js"),o=new e.Logger,i={success:t.StylePresets.success().build(),error:t.StylePresets.error().build(),warning:t.StylePresets.warning().build(),info:t.StylePresets.info().build(),accent:t.StylePresets.accent().build()};exports.BANNER_VARIANTS=e.BANNER_VARIANTS,exports.Logger=e.Logger,exports.THEME_BANNERS=e.THEME_BANNERS,exports.THEME_PRESETS=e.THEME_PRESETS,exports.DEFAULT_CONFIG=t.DEFAULT_CONFIG,exports.StyleBuilder=t.StyleBuilder,exports.StylePresets=t.StylePresets,exports.formatTimestamp=t.formatTimestamp,exports.parseStackTrace=t.parseStackTrace,exports.RemoteLogHandler=r.RemoteLogHandler,exports.AnalyticsLogHandler=class{handle(e,t,s,r){"error"!==e&&"critical"!==e||r.timestamp}},exports.FileLogHandler=class{filename;maxSize;fs;constructor(e="app.log",s){if(this.filename=e,this.maxSize=s,t.isNode)try{this.fs=require("fs")}catch(r){console.warn("FileLogHandler: Unable to load fs module:",r)}}handle(e,r,o,i){const l={timestamp:i.timestamp,level:e.toUpperCase(),prefix:i.prefix,message:r,args:o.slice(1).map(e=>s.safeSerialize(e)),location:i.stackInfo},a=this.formatLogLine(l);t.isNode&&this.fs?this.writeToFileNode(a):t.isBrowser?this.writeToFileLocal(a):console.log(`[FILE-LOG] ${a}`)}formatLogLine(e){let t=[e.timestamp,`[${e.level}]`,e.prefix?`[${e.prefix}]`:"",e.message].filter(Boolean).join(" ");return e.args&&e.args.length>0&&(t+=" "+e.args.map(e=>"object"==typeof e?JSON.stringify(e):String(e)).join(" ")),e.location&&(t+=` (${e.location.file}:${e.location.line}:${e.location.column})`),t}writeToFileNode(e){if(this.fs)try{if(this.maxSize)try{if(this.fs.statSync(this.filename).size>this.maxSize){const e=`${this.filename}.bak`;this.fs.renameSync(this.filename,e)}}catch(t){}this.fs.appendFileSync(this.filename,e+"\n","utf8")}catch(t){console.error("FileLogHandler: Failed to write to file:",t)}}writeToFileLocal(e){try{const t=`logger_${this.filename}`,s=localStorage.getItem(t)||"";let r=s;if(s.length>0&&(r+="\n"),r+=e,this.maxSize||r.split("\n").length>1e3){const e=r.split("\n"),t=this.maxSize?Math.floor(this.maxSize/100):1e3;e.length>t&&(r=e.slice(-t).join("\n"))}localStorage.setItem(t,r)}catch(t){console.error("FileLogHandler: Failed to write to localStorage:",t)}}getLogs(){if(t.isNode&&this.fs)try{return this.fs.readFileSync(this.filename,"utf8")}catch(e){return null}else if(t.isBrowser){const e=`logger_${this.filename}`;return localStorage.getItem(e)}return null}clearLogs(){if(t.isNode&&this.fs)try{this.fs.writeFileSync(this.filename,"","utf8")}catch(e){console.error("FileLogHandler: Failed to clear file:",e)}else if(t.isBrowser){const e=`logger_${this.filename}`;localStorage.removeItem(e)}}},exports.addHandler=e=>o.addHandler(e),exports.cli=e=>o.cli(e),exports.createStyle=()=>new t.StyleBuilder,exports.critical=(...e)=>o.critical(...e),exports.debug=(...e)=>o.debug(...e),exports.default=o,exports.error=(...e)=>o.error(...e),exports.group=(e,t)=>o.group(e,t),exports.groupEnd=()=>o.groupEnd(),exports.info=(...e)=>o.info(...e),exports.logAnimated=(e,t)=>o.logAnimated(e,t),exports.logWithSVG=(e,t,s)=>o.logWithSVG(e,t,s),exports.scope=e=>o.scope(e),exports.setBannerType=e=>o.setBannerType(e),exports.setGlobalPrefix=e=>o.setGlobalPrefix(e),exports.setTheme=e=>o.setTheme(e),exports.setVerbosity=e=>o.setVerbosity(e),exports.showBanner=e=>o.showBanner(e),exports.stylePresets=i,exports.success=(...e)=>o.success(...e),exports.table=(e,t)=>o.table(e,t),exports.time=e=>o.time(e),exports.timeEnd=e=>o.timeEnd(e),exports.trace=(...e)=>o.trace(...e),exports.warn=(...e)=>o.warn(...e);
-//# sourceMappingURL=index.cjs.map
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_core = require("./chunks/core-CqS_UBzJ.cjs");
+const require_transports = require("./chunks/transports-yK6CL0Ml.cjs");
+const require_utils = require("./chunks/utils-W_cxqriN.cjs");
+const require_styling = require("./chunks/styling-Cel2wPRy.cjs");
+const require_environment_detector = require("./chunks/environment-detector-D-tHkKWA.cjs");
+const require_spinner = require("./chunks/spinner-BHyYEXsM.cjs");
+const require_LogContext = require("./chunks/LogContext-BaMXleWj.cjs");
+const require_HookBridge = require("./chunks/HookBridge-C-AvXmPD.cjs");
+const require_SerializerBridge = require("./chunks/SerializerBridge-C4a9Z37F.cjs");
+const require_server_fallback = require("./chunks/server-fallback-CaCPjWby.cjs");
+const require_StyleManager = require("./chunks/StyleManager-DQ6UNRB-.cjs");
+//#region src/ScopedLogger.ts
+/**
+* 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(require_styling.THEME_PRESETS).forEach((themeName) => {
+			const preview = require_styling.THEME_PRESETS[themeName];
+			const previewStyle = new require_styling.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(require_styling.BANNER_VARIANTS).forEach((bannerName) => {
+			const banner = require_styling.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 require_styling.BANNER_VARIANTS) {
+			logger.setBannerType(args);
+			logger.showBanner();
+		} else logger.error(`Invalid banner type: ${args}. Available: ${Object.keys(require_styling.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 require_styling.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 require_transports.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 (!require_environment_detector.isRunningInTerminal()) {
+				this.getServerFallback().step(current, total, message);
+				return;
+			}
+			const output = require_spinner.renderStep(current, total, message, require_environment_detector.getColorCapability());
+			process.stderr.write(output + "\n");
+		},
+		header(title, subtitle) {
+			if (!_showPrimitives) return;
+			if (!require_environment_detector.isRunningInTerminal()) {
+				this.getServerFallback().header(title, subtitle);
+				return;
+			}
+			const output = require_spinner.renderHeader(title, subtitle);
+			process.stderr.write(output + "\n");
+		},
+		divider() {
+			if (!_showPrimitives) return;
+			if (!require_environment_detector.isRunningInTerminal()) {
+				this.getServerFallback().divider();
+				return;
+			}
+			const output = require_spinner.renderDivider();
+			process.stderr.write(output + "\n");
+		},
+		blank() {
+			if (!_showPrimitives) return;
+			if (!require_environment_detector.isRunningInTerminal()) {
+				this.getServerFallback().blank();
+				return;
+			}
+			process.stderr.write("\n");
+		},
+		box(content, opts) {
+			if (!_showPrimitives) return;
+			if (!require_environment_detector.isRunningInTerminal()) {
+				this.getServerFallback().box(content, opts);
+				return;
+			}
+			const output = require_spinner.renderBox(content, opts, require_environment_detector.getColorCapability());
+			process.stderr.write(output + "\n");
+		},
+		cliTable(rows, opts) {
+			if (!_showPrimitives) return;
+			if (!require_environment_detector.isRunningInTerminal()) {
+				this.getServerFallback().cliTable(rows, opts);
+				return;
+			}
+			const output = require_spinner.renderTable(rows, opts, require_environment_detector.getColorCapability());
+			process.stderr.write(output + "\n");
+		},
+		spinner(message) {
+			const logger = options.getLogger();
+			if (!require_environment_detector.isRunningInTerminal() || options.config.outputMode === "silent") return new require_spinner.NoopSpinner(message, logger);
+			return new require_spinner.SpinnerManager(message, options.config, logger);
+		},
+		getShowPrimitives() {
+			return _showPrimitives;
+		},
+		setShowPrimitives(show) {
+			_showPrimitives = show;
+		},
+		getServerFallback() {
+			if (!_serverFallback) _serverFallback = new require_server_fallback.ServerFallback(options.getLogger());
+			return _serverFallback;
+		},
+		isInTerminal() {
+			return require_environment_detector.isRunningInTerminal();
+		}
+	};
+}
+//#endregion
+//#region src/Logger.ts
+require_styling.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 = {
+			...require_utils.DEFAULT_CONFIG,
+			...config
+		};
+		this.serializerBridge = require_SerializerBridge.createSerializerBridge();
+		this.hookBridge = require_HookBridge.createHookBridge();
+		this.logContext = require_LogContext.createLogContext({
+			initialResource: this.config.resource,
+			childLoggerFactory: (childConfig) => {
+				return new Logger({
+					...this.config,
+					...childConfig
+				});
+			},
+			getParentContextRecord: () => this._captureMergedContext()
+		});
+		this.transportBridge = createTransportBridge();
+		this.styleManager = require_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 = require_utils.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 (require_styling.hasPreset(theme)) {
+			this.preset(theme);
+			return;
+		}
+		if (this.styleManager.setTheme(theme)) {
+			this.config.theme = theme;
+			const bannersRecord = require_styling.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:`, [...require_styling.getAvailablePresets(), ...Object.keys(require_styling.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 = { ...require_utils.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 (!require_styling.hasPreset(name)) {
+			this.error(`Unknown preset: ${name}. Available presets:`, require_styling.getAvailablePresets());
+			return;
+		}
+		const presetConfig = require_styling.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 (require_environment_detector.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 require_styling.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 require_core.LOG_LEVELS[level] >= require_core.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: require_core.LOG_LEVELS[level],
+			severityNumber: require_transports.LOG_LEVEL_TO_SEVERITY_NUMBER[level],
+			severityText: require_transports.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 ? require_utils.parseStackTrace() : null;
+		const prefix = this.getEffectivePrefix();
+		const timestamp = require_utils.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] = require_utils.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 = require_environment_detector.getColorCapability();
+		if (bindings.badges?.length) prefix += bindings.badges.map((b) => require_spinner.formatBadge(b, "pill", colorCapability, "#00ff88")).join(" ") + " ";
+		if (bindings.scope) prefix += require_spinner.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 ? require_utils.parseStackTrace() : null;
+		const prefix = this.getEffectivePrefix();
+		const timestamp = require_utils.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] = require_utils.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 = require_styling.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 ? require_utils.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 require_styling.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 ? require_utils.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 ? require_utils.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 = require_styling.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 = require_styling.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 ? require_utils.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) {
+		require_styling.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 require_styling.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 ? require_utils.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 require_styling.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 ? require_utils.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 = require_utils.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") require_styling.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
+exports.APILogger = APILogger;
+exports.BANNER_VARIANTS = require_styling.BANNER_VARIANTS;
+exports.ComponentLogger = ComponentLogger;
+exports.ContextLogger = ContextLogger;
+exports.DEFAULT_CONFIG = require_utils.DEFAULT_CONFIG;
+exports.Logger = Logger;
+exports.ScopedLogger = ScopedLogger;
+exports.StyleBuilder = require_styling.StyleBuilder;
+exports.StylePresets = require_styling.StylePresets;
+exports.THEME_BANNERS = require_styling.THEME_BANNERS;
+exports.THEME_PRESETS = require_styling.THEME_PRESETS;
+exports.addHandler = addHandler;
+exports.addSerializer = addSerializer;
+exports.addTransport = addTransport;
+exports.ansiBackground = require_utils.ansiBackground;
+exports.ansiBold = require_utils.ansiBold;
+exports.ansiColor = require_utils.ansiColor;
+exports.ansiDim = require_utils.ansiDim;
+exports.ansiStyle = require_utils.ansiStyle;
+exports.ansiUnderline = require_utils.ansiUnderline;
+exports.api = api;
+exports.badge = badge;
+exports.badges = badges;
+exports.clearBadges = clearBadges;
+exports.cli = cli;
+exports.closeTransports = closeTransports;
+exports.component = component;
+exports.createLogEntry = require_utils.createLogEntry;
+exports.critical = critical;
+exports.debug = debug;
+exports.default = src_default;
+exports.error = error;
+exports.flushTransports = flushTransports;
+exports.formatLogLevelANSI = require_utils.formatLogLevelANSI;
+exports.formatSuccessANSI = require_utils.formatSuccessANSI;
+exports.formatTablePlain = require_utils.formatTablePlain;
+exports.formatTimestamp = require_utils.formatTimestamp;
+exports.getColorCapability = require_environment_detector.getColorCapability;
+exports.getConsoleMethod = require_utils.getConsoleMethod;
+exports.getEnvironment = require_environment_detector.getEnvironment;
+exports.getEnvironmentInfo = require_environment_detector.getEnvironmentInfo;
+exports.getTerminalHeight = require_environment_detector.getTerminalHeight;
+exports.getTerminalWidth = require_environment_detector.getTerminalWidth;
+exports.group = group;
+exports.groupEnd = groupEnd;
+exports.info = info;
+exports.isRunningInTerminal = require_environment_detector.isRunningInTerminal;
+exports.logAnimated = logAnimated;
+exports.logWithSVG = logWithSVG;
+exports.off = off;
+exports.on = on;
+exports.once = once;
+exports.parseStackTrace = require_utils.parseStackTrace;
+exports.removeSerializer = removeSerializer;
+exports.removeTransport = removeTransport;
+exports.safeSerialize = require_utils.safeSerialize;
+exports.scope = scope;
+exports.setBannerType = setBannerType;
+exports.setGlobalPrefix = setGlobalPrefix;
+exports.setTheme = setTheme;
+exports.setVerbosity = setVerbosity;
+exports.showBanner = showBanner;
+exports.success = success;
+exports.supportsANSI = require_environment_detector.supportsANSI;
+exports.table = table;
+exports.time = time;
+exports.timeEnd = timeEnd;
+exports.trace = trace;
+exports.use = use;
+exports.warn = warn;
+
+//# sourceMappingURL=index.cjs.map