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

package/dist/index.js

@@ -1,160 +1,2449 @@
+import { t as LOG_LEVELS } from "./chunks/core-PoT7RrTK.js";
+import { o as LOG_LEVEL_TO_SEVERITY_NUMBER, s as LOG_LEVEL_TO_SEVERITY_TEXT, t as TransportManager } from "./chunks/transports-BiDk345e.js";
+import { _ as DEFAULT_CONFIG, a as safeSerialize, b as parseStackTrace, c as ansiBackground, d as ansiDim, f as ansiStyle, g as CLI_LEVEL_MAP, h as formatSuccessANSI, i as getConsoleMethod, l as ansiBold, m as formatLogLevelANSI, o as createStyledOutput, p as ansiUnderline, r as formatTablePlain, s as setupThemeChangeListener, t as createLogEntry, u as ansiColor, y as formatTimestamp } from "./chunks/utils-VETbVpkR.js";
+import { a as THEME_BANNERS, c as StyleBuilder, i as BANNER_VARIANTS, l as StylePresets, n as getSmartPreset, o as displayInitBanner, r as hasPreset, s as THEME_PRESETS, t as getAvailablePresets } from "./chunks/styling-84N8T97t.js";
+import { a as getTerminalWidth, c as isRunningInTerminal, i as getTerminalHeight, l as supportsANSI, n as getEnvironment, r as getEnvironmentInfo, t as getColorCapability } from "./chunks/environment-detector-CI3TrWK_.js";
+import { a as renderDivider, c as formatBadge, i as renderBox, n as SpinnerManager, o as renderHeader, r as renderTable, s as renderStep, t as NoopSpinner } from "./chunks/spinner-D3FsF78o.js";
+import { t as createLogContext } from "./chunks/LogContext-Cwn-1Zzb.js";
+import { t as createHookBridge } from "./chunks/HookBridge-SgMmbXZB.js";
+import { t as createSerializerBridge } from "./chunks/SerializerBridge-BkpQu5c9.js";
+import { t as ServerFallback } from "./chunks/server-fallback-BsuWH1Dk.js";
+import { t as createStyleManager } from "./chunks/StyleManager-LCvVlVdx.js";
+//#region src/ScopedLogger.ts
+var ScopedLogger = class {
+	parent;
+	scopeName;
+	badgeList = [];
+	contextStack = [];
+	_timers;
+	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(":");
+	}
+	badges(badges) {
+		this.badgeList = [...badges];
+		return this;
+	}
+	badge(badge) {
+		if (!this.badgeList.includes(badge)) this.badgeList.push(badge);
+		return this;
+	}
+	clearBadges() {
+		this.badgeList = [];
+		return this;
+	}
+	style(presetName) {
+		this.parent.setTheme(presetName);
+		return this;
+	}
+	context(contextName) {
+		return new ContextLogger(this, contextName);
+	}
+	time(label) {
+		this.timers.set(label, {
+			label: `${this.scopeName}:${label}`,
+			startTime: performance.now()
+		});
+	}
+	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;
+	}
+	debug(...args) {
+		this.parent.logWithBindings(this.getBindings(), "debug", ...args);
+	}
+	info(...args) {
+		this.parent.logWithBindings(this.getBindings(), "info", ...args);
+	}
+	warn(...args) {
+		this.parent.logWithBindings(this.getBindings(), "warn", ...args);
+	}
+	error(...args) {
+		this.parent.logWithBindings(this.getBindings(), "error", ...args);
+	}
+	success(...args) {
+		const bindings = this.getBindings();
+		this.parent.logWithBindingsAndTag(bindings, "info", "success", ...args);
+	}
+	critical(...args) {
+		this.parent.logWithBindings(this.getBindings(), "critical", ...args);
+	}
+	trace(...args) {
+		this.parent.logWithBindings(this.getBindings(), "trace", ...args);
+	}
+	/** @see Logger.step */
+	step(current, total, message) {
+		this.parent.step(current, total, message);
+	}
+	/** @see Logger.header */
+	header(title, subtitle) {
+		this.parent.header(title, subtitle);
+	}
+	/** @see Logger.divider */
+	divider() {
+		this.parent.divider();
+	}
+	/** @see Logger.blank */
+	blank() {
+		this.parent.blank();
+	}
+	/** @see Logger.box */
+	box(content, options) {
+		this.parent.box(content, options);
+	}
+	/** @see Logger.cliTable */
+	cliTable(rows, options) {
+		this.parent.cliTable(rows, options);
+	}
+	/** @see Logger.spinner */
+	spinner(message) {
+		return this.parent.spinner(message);
+	}
+	/** @see Logger.setCLILevel */
+	setCLILevel(level) {
+		this.parent.setCLILevel(level);
+	}
+	_pushContext(context) {
+		this.contextStack.push(context);
+	}
+	_popContext() {
+		this.contextStack.pop();
+	}
+};
+var APILogger = class extends ScopedLogger {
+	constructor(parent, apiName) {
+		super(parent, `API:${apiName}`);
+		this.badge("API");
+	}
+	slow(message, duration) {
+		this.badge("SLOW");
+		const msg = duration ? `${message} (${duration}ms)` : message;
+		this.warn(msg);
+	}
+	rateLimit(message) {
+		this.badge("RATE_LIMIT");
+		this.warn(message);
+	}
+	auth(message) {
+		this.badge("AUTH");
+		this.error(message);
+	}
+	deprecated(message) {
+		this.badge("DEPRECATED");
+		this.warn(message);
+	}
+};
+var ComponentLogger = class extends ScopedLogger {
+	constructor(parent, componentName) {
+		super(parent, componentName);
+		this.badge("COMPONENT");
+	}
+	lifecycle(event, message) {
+		this.badge("LIFECYCLE");
+		const msg = message ? `${event}: ${message}` : event;
+		this.info(msg);
+	}
+	stateChange(from, to, data) {
+		this.badge("STATE");
+		const msg = `${from} → ${to}`;
+		if (data) this.info(msg, data);
+		else this.info(msg);
+	}
+	propsChange(changes) {
+		this.badge("PROPS");
+		this.debug("Props changed:", changes);
+	}
+};
+var ContextLogger = class {
+	parentLogger;
+	contextName;
+	constructor(parentLogger, contextName) {
+		this.parentLogger = parentLogger;
+		this.contextName = contextName;
+	}
+	run(fn) {
+		this.parentLogger._pushContext(this.contextName);
+		try {
+			return fn();
+		} finally {
+			this.parentLogger._popContext();
+		}
+	}
+	async runAsync(fn) {
+		this.parentLogger._pushContext(this.contextName);
+		try {
+			return await fn();
+		} finally {
+			this.parentLogger._popContext();
+		}
+	}
+	start() {
+		this.parentLogger._pushContext(this.contextName);
+	}
+	end() {
+		this.parentLogger._popContext();
+	}
+	debug(...args) {
+		this.parentLogger.debug(...args);
+	}
+	info(...args) {
+		this.parentLogger.info(...args);
+	}
+	warn(...args) {
+		this.parentLogger.warn(...args);
+	}
+	error(...args) {
+		this.parentLogger.error(...args);
+	}
+	success(...args) {
+		this.parentLogger.success(...args);
+	}
+	critical(...args) {
+		this.parentLogger.critical(...args);
+	}
+};
+//#endregion
+//#region src/cli/CommandProcessor.ts
+/**
+* CLI command processor
+*/
+var CommandProcessor = class {
+	commands = /* @__PURE__ */ new Map();
+	aliases = /* @__PURE__ */ new Map();
+	plugins = /* @__PURE__ */ new Map();
+	history = [];
+	maxHistorySize = 100;
+	isInteractiveMode = false;
+	/**
+	* Register a command
+	*/
+	registerCommand(command) {
+		this.commands.set(command.name, command);
+		if (command.aliases) for (const alias of command.aliases) this.aliases.set(alias, command.name);
+	}
+	/**
+	* Register a plugin
+	*/
+	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);
+	}
+	/**
+	* Unregister a plugin
+	*/
+	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);
+	}
+	/**
+	* Get all registered commands
+	*/
+	getCommands() {
+		return Array.from(this.commands.values());
+	}
+	/**
+	* Get a specific command
+	*/
+	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);
+	}
+	/**
+	* Get command history
+	*/
+	getHistory() {
+		return [...this.history];
+	}
+	/**
+	* Clear command history
+	*/
+	clearHistory() {
+		this.history = [];
+	}
+	/**
+	* Get registered plugins
+	*/
+	getPlugins() {
+		return Array.from(this.plugins.values());
+	}
+	/**
+	* Enter interactive mode
+	*/
+	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);
+	}
+	/**
+	* Exit interactive mode
+	*/
+	exitInteractiveMode() {
+		this.isInteractiveMode = false;
+	}
+	/**
+	* Setup browser interactive mode
+	*/
+	setupBrowserInteractiveMode(logger) {
+		window.cli = (commandString) => {
+			return this.processCommand(`/${commandString}`, logger);
+		};
+		logger.info("💡 Use cli(\"command\") to execute CLI commands in browser console.");
+	}
+	/**
+	* Process a CLI command
+	*/
+	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);
+		}
+	}
+	/**
+	* Add command to history
+	*/
+	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);
+	}
+	/**
+	* Get command suggestions for partial matches
+	*/
+	getSuggestions(partial) {
+		return Array.from(this.commands.keys()).filter((name) => name.startsWith(partial));
+	}
+};
+//#endregion
+//#region src/cli/commands/ConfigCommand.ts
+/**
+* Configuration command handler
+*/
+var ConfigCommand = class {
+	name = "config";
+	description = "Show or update logger configuration";
+	usage = "/config [json|key=value,...]";
+	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
+/**
+* Themes command - show available themes
+*/
+var ThemesCommand = class {
+	name = "themes";
+	description = "Show available theme presets";
+	usage = "/themes";
+	execute(_args, logger) {
+		logger.group("🎨 Available Themes");
+		Object.keys(THEME_PRESETS).forEach((themeName) => {
+			const preview = THEME_PRESETS[themeName];
+			const previewStyle = new StyleBuilder().bg(preview.info.background).color(preview.info.color).padding("4px 8px").rounded("4px").border(preview.info.border).build();
+			console.log(`%c${themeName}`, previewStyle, `- ${themeName} theme preview`);
+		});
+		logger.groupEnd();
+	}
+};
+/**
+* Banners command - show available banner types
+*/
+var BannersCommand = class {
+	name = "banners";
+	description = "Show available banner types";
+	usage = "/banners";
+	execute(_args, logger) {
+		logger.group("🖼️ Available Banner Types");
+		Object.keys(BANNER_VARIANTS).forEach((bannerName) => {
+			const banner = BANNER_VARIANTS[bannerName];
+			console.log(`%c${bannerName}`, "font-weight: bold; color: #667eea;");
+			console.log(`%cPreview:`, "color: #666; font-size: 12px;");
+			if (bannerName === "simple") console.log(`%c${banner.text}`, banner.style);
+			else if (bannerName === "ascii") console.log(`%c${banner.text.split("\n").slice(1, 4).join("\n")}...`, "font-family: monospace; color: #667eea; font-size: 10px;");
+			else if (bannerName === "unicode") console.log(`%c${banner.text}`, banner.style);
+			else console.log(`%c${bannerName} banner`, "color: #666; font-style: italic;");
+		});
+		logger.groupEnd();
+	}
+};
+/**
+* Banner command - change/show banner type
+*/
+var BannerCommand = class {
+	name = "banner";
+	description = "Change or show current banner type";
+	usage = "/banner [type]";
+	execute(args, logger) {
+		if (!args) {
+			logger.showBanner();
+			return;
+		}
+		if (args in BANNER_VARIANTS) {
+			logger.setBannerType(args);
+			logger.showBanner();
+		} else logger.error(`Invalid banner type: ${args}. Available: ${Object.keys(BANNER_VARIANTS).join(", ")}`);
+	}
+};
+//#endregion
+//#region src/cli/commands/ExportCommand.ts
+/**
+* Status command - show logger configuration and statistics
+*/
+var StatusCommand = class {
+	name = "status";
+	description = "Show current logger status and configuration";
+	usage = "/status";
+	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();
+	}
+};
 /**
- * @fileoverview Better Logger - Librería completa con todas las características
- * @version 0.3.0
- * @since 2024
- *
- * Punto de entrada principal que proporciona la experiencia completa de Better Logger
- * con características avanzadas incluyendo estilos CSS, soporte SVG, animaciones,
- * capacidades de exportación y logging remoto.
- *
- * @module @mks2508/better-logger
- */
-// Main Logger class with all features
-import { Logger } from './Logger.js';
-// Create singleton instance with all features enabled
-const logger = new Logger();
-/**
- * Clase principal Logger con conjunto completo de características
- *
- * @example
- * // Importación y uso básico
- * import { Logger } from '@mks2508/better-logger';
- *
- * const logger = new Logger();
- * logger.preset('cyberpunk');  // Aplicar preset completo
- * logger.info('¡Hola mundo!');
- *
- * @example
- * // Logger con scope para componentes
- * const auth = logger.component('Auth');
- * auth.info('Usuario autenticando...');
- * auth.success('Login exitoso');
- *
- * @example
- * // Logger para APIs con badges
- * const api = logger.api('GraphQL');
- * api.badges(['v2', 'cached']).info('Query ejecutada');
- *
- * @since 0.3.0
- */
-export { Logger };
-/**
- * Instancia singleton del logger lista para usar
- * @default
- *
- * @example
- * // Uso directo sin crear instancia
- * import logger from '@mks2508/better-logger';
- *
- * logger.info('Aplicación iniciada');
- * logger.success('Conexión establecida');
- * logger.warn('Memoria al 80%');
- * logger.error('Fallo en conexión');
- */
-export default logger;
-/**
- * Métodos de logging individuales (enlazados al singleton)
- *
- * @example
- * // Importar solo los métodos necesarios
- * import { info, error, success } from '@mks2508/better-logger';
- *
- * info('Proceso iniciado');
- * success('✓ Completado exitosamente');
- * error('Error:', errorDetails);
- *
- * @since 0.3.0
- */
-export const debug = (...args) => logger.debug(...args);
-export const info = (...args) => logger.info(...args);
-export const warn = (...args) => logger.warn(...args);
-export const error = (...args) => logger.error(...args);
-export const success = (...args) => logger.success(...args);
-export const critical = (...args) => logger.critical(...args);
-export const trace = (...args) => logger.trace(...args);
-export const table = (data, columns) => logger.table(data, columns);
-export const group = (label, collapsed) => logger.group(label, collapsed);
-export const groupEnd = () => logger.groupEnd();
-export const time = (label) => logger.time(label);
-export const timeEnd = (label) => logger.timeEnd(label);
-export const setGlobalPrefix = (prefix) => logger.setGlobalPrefix(prefix);
-export const scope = (prefix) => logger.scope(prefix);
-export const setVerbosity = (level) => logger.setVerbosity(level);
-export const addHandler = (handler) => logger.addHandler(handler);
-export const setTheme = (theme) => logger.setTheme(theme);
-export const setBannerType = (bannerType) => logger.setBannerType(bannerType);
-export const showBanner = (bannerType) => logger.showBanner(bannerType);
-export const logWithSVG = (message, svgContent, options) => logger.logWithSVG(message, svgContent, options);
-export const logAnimated = (message, duration) => logger.logAnimated(message, duration);
-export const cli = (command) => logger.cli(command);
-// Styling utilities
-export { StyleBuilder, StylePresets, THEME_PRESETS, THEME_BANNERS, BANNER_VARIANTS } from './styling/index.js';
-// Handler exports
-export { FileLogHandler, RemoteLogHandler, AnalyticsLogHandler } from './handlers/index.js';
-// Constants
-export { DEFAULT_CONFIG } from './constants.js';
-// Utility exports
-export { parseStackTrace, formatTimestamp } from './utils/index.js';
-/**
- * Utilidades de estilo para crear estilos personalizados de consola
- *
- * @example
- * // Crear estilo personalizado
- * import { createStyle, stylePresets } from '@mks2508/better-logger';
- *
- * const miEstilo = createStyle()
- *   .bg('linear-gradient(45deg, #ff6b6b, #feca57)')
- *   .color('white')
- *   .padding('10px')
- *   .rounded('8px')
- *   .bold()
- *   .build();
- *
- * console.log('%cMensaje estilizado', miEstilo);
- *
- * @example
- * // Usar presets predefinidos
- * console.log('%cÉxito!', stylePresets.success);
- * console.log('%cError!', stylePresets.error);
- *
- * @since 0.3.0
- */
-import { StyleBuilder, StylePresets } from './styling/index.js';
-/**
- * Crea una nueva instancia de StyleBuilder para estilos personalizados de consola
- *
- * @returns {StyleBuilder} Constructor de estilos encadenable
- *
- * @example
- * const estilo = createStyle()
- *   .gradient('#667eea', '#764ba2')
- *   .color('white')
- *   .padding('8px 16px')
- *   .rounded('4px')
- *   .shadow('0 2px 4px rgba(0,0,0,0.2)')
- *   .build();
- *
- * @since 0.3.0
- */
-export const createStyle = () => new StyleBuilder();
-/**
- * Presets de estilo predefinidos para casos de uso comunes
- *
- * @constant {Object} stylePresets
- *
- * @example
- * console.log('%cOperación exitosa', stylePresets.success);
- * console.log('%cAdvertencia', stylePresets.warning);
- * console.log('%cError crítico', stylePresets.error);
- * console.log('%cInformación', stylePresets.info);
- * console.log('%cDestacado', stylePresets.accent);
- *
- * @since 0.3.0
- */
-export const stylePresets = {
-    success: StylePresets.success().build(),
-    error: StylePresets.error().build(),
-    warning: StylePresets.warning().build(),
-    info: StylePresets.info().build(),
-    accent: StylePresets.accent().build(),
+* Reset command - reset logger to defaults
+*/
+var ResetCommand = class {
+	name = "reset";
+	description = "Reset logger configuration to defaults";
+	usage = "/reset";
+	execute(_args, logger) {
+		logger.resetConfig();
+	}
 };
+/**
+* Demo command - show logger feature demonstration
+*/
+var DemoCommand = class {
+	name = "demo";
+	description = "Show comprehensive feature demonstration";
+	usage = "/demo";
+	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
+/**
+* Help command - show comprehensive CLI help
+*/
+var HelpCommand = class {
+	name = "help";
+	description = "Show CLI help and available commands";
+	usage = "/help [command]";
+	execute(_args, logger) {
+		const helpStyle = new StyleBuilder().bg("linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%)").color("#495057").padding("15px 20px").rounded("8px").border("1px solid #dee2e6").font("Monaco, Consolas, monospace").size("13px").build();
+		console.log(`%c
+╭─────────────── ADVANCED LOGGER CLI COMMANDS ─────────────────╮
+│                                                             │
+│  CONFIGURATION                                              │
+│  /config            Show current configuration              │
+│  /config {json}     Apply JSON configuration                │
+│  /config key=val    Apply key-value configuration           │
+│  /themes            Show available themes                   │
+│  /banners           Show available banner types             │
+│  /banner [type]     Change/show banner type                 │
+│  /status            Show logger status & buffer stats       │
+│  /demo              Show feature demonstration              │
+│  /reset             Reset to default configuration          │
+│                                                             │
+│  EXPORT & CLIPBOARD                                         │
+│  /export <format>   Export logs (json|csv|md|plain|html)    │
+│  /copy <format>     Copy logs to clipboard                  │
+│  /buffer-size N     Set log buffer size                     │
+│  /buffer-info       Show buffer statistics                  │
+│  /clear-buffer      Clear stored logs                       │
+│                                                             │
+│  EXPORT FILTERS (for export/copy commands)                 │
+│  --level error,warn     Filter by log levels                │
+│  --since 2h             Logs from last 2 hours              │
+│  --until 1h             Logs until 1 hour ago               │
+│  --prefix API,DB        Filter by prefixes                  │
+│  --exclude-prefix INT   Exclude prefixes                    │
+│  --last 50             Last 50 logs only                    │
+│  --first 25            First 25 logs only                   │
+│  --search "error"      Search in log messages               │
+│  --with-stack          Only logs with stack traces          │
+│  --errors-only         Only error + critical logs           │
+│  --group-by level      Group by level/prefix/hour           │
+│                                                             │
+│  EXPORT OPTIONS                                             │
+│  --minimal             Minimal output format                │
+│  --compact             Remove extra whitespace              │
+│  --styled              Include styling (HTML format)        │
+│                                                             │
+├──────────────────── CONFIGURATION OPTIONS ─────────────────┤
+│                                                             │
+│  theme: default | dark | light | neon | minimal | cyberpunk│
+│  bannerType: simple | ascii | unicode | svg | animated     │
+│  verbosity: debug | info | warn | error | critical | silent│
+│  enableColors: true | false                                 │
+│  enableTimestamps: true | false                             │
+│  enableStackTrace: true | false                             │
+│  globalPrefix: "string"                                     │
+│  bufferSize: number (50-10000)                             │
+│                                                             │
+├──────────────────────── EXAMPLES ──────────────────────────┤
+│                                                             │
+│  Basic Configuration:                                       │
+│  /config {"theme":"dark","verbosity":"debug"}               │
+│  /config theme=neon,bufferSize=2000                        │
+│  /banner animated       Change to animated banner          │
+│                                                             │
+│  Export Examples:                                           │
+│  /export json --level=error,warn --last=25                 │
+│  /export csv --since=2h --prefix=API                       │
+│  /export markdown --group-by=level --errors-only           │
+│  /export html --styled --since=1h                          │
+│                                                             │
+│  Clipboard Examples:                                        │
+│  /copy plain --minimal --last=10                           │
+│  /copy json --search="authentication" --compact            │
+│  /copy csv --since=30m --exclude-prefix=DEBUG              │
+│                                                             │
+│  Buffer Management:                                         │
+│  /buffer-size 5000      Increase buffer to 5000 logs       │
+│  /buffer-info           Show detailed buffer statistics     │
+│  /clear-buffer          Clear all stored logs               │
+│                                                             │
+│  Time Formats:                                              │
+│  --since=2h            2 hours ago                          │
+│  --since=30m           30 minutes ago                       │
+│  --since=1d            1 day ago                            │
+│  --since="2024-01-01T10:00:00Z"  Specific ISO date         │
+│                                                             │
+╰─────────────────────────────────────────────────────────────╯`, helpStyle);
+		logger.group("💡 Quick Tips");
+		[
+			"Use /demo to see all logger features in action",
+			"Logs are automatically stored in a circular buffer for export",
+			"Export formats: JSON (structured), CSV (Excel), Markdown (readable), Plain (simple), HTML (styled)",
+			"Time filters support relative (2h, 30m) and absolute (ISO) formats",
+			"Combine multiple filters: /export json --level=error --since=1h --search=\"auth\"",
+			"Use /copy for quick clipboard access instead of /export"
+		].forEach((tip) => {
+			logger.info(`• ${tip}`);
+		});
+		logger.groupEnd();
+	}
+};
+//#endregion
+//#region src/cli/index.ts
+/**
+* Create and configure default CLI processor
+*/
+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
+/**
+* Creates a TransportBridge instance.
+*/
+function createTransportBridge() {
+	let transportManager;
+	return {
+		addTransport(target) {
+			if (!transportManager) transportManager = new TransportManager();
+			return transportManager.add(target);
+		},
+		removeTransport(id) {
+			return transportManager?.remove(id) ?? false;
+		},
+		async flushTransports() {
+			await transportManager?.flush();
+		},
+		async closeTransports() {
+			await transportManager?.close();
+		},
+		getTransportManager() {
+			return transportManager;
+		},
+		writeRecord(record) {
+			if (!transportManager) return;
+			transportManager.write(record).catch(() => {});
+		}
+	};
+}
+//#endregion
+//#region src/playground/TerminalBridge.ts
+/**
+* Creates a TerminalBridge using a getter to avoid circular reference at construction.
+*/
+function createTerminalBridge(options) {
+	let _showPrimitives = true;
+	let _serverFallback;
+	return {
+		step(current, total, message) {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().step(current, total, message);
+				return;
+			}
+			const output = renderStep(current, total, message, getColorCapability());
+			process.stderr.write(output + "\n");
+		},
+		header(title, subtitle) {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().header(title, subtitle);
+				return;
+			}
+			const output = renderHeader(title, subtitle);
+			process.stderr.write(output + "\n");
+		},
+		divider() {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().divider();
+				return;
+			}
+			const output = renderDivider();
+			process.stderr.write(output + "\n");
+		},
+		blank() {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().blank();
+				return;
+			}
+			process.stderr.write("\n");
+		},
+		box(content, opts) {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().box(content, opts);
+				return;
+			}
+			const output = renderBox(content, opts, getColorCapability());
+			process.stderr.write(output + "\n");
+		},
+		cliTable(rows, opts) {
+			if (!_showPrimitives) return;
+			if (!isRunningInTerminal()) {
+				this.getServerFallback().cliTable(rows, opts);
+				return;
+			}
+			const output = renderTable(rows, opts, getColorCapability());
+			process.stderr.write(output + "\n");
+		},
+		spinner(message) {
+			const logger = options.getLogger();
+			if (!isRunningInTerminal() || options.config.outputMode === "silent") return new NoopSpinner(message, logger);
+			return new SpinnerManager(message, options.config, logger);
+		},
+		getShowPrimitives() {
+			return _showPrimitives;
+		},
+		setShowPrimitives(show) {
+			_showPrimitives = show;
+		},
+		getServerFallback() {
+			if (!_serverFallback) _serverFallback = new ServerFallback(options.getLogger());
+			return _serverFallback;
+		},
+		isInTerminal() {
+			return isRunningInTerminal();
+		}
+	};
+}
+//#endregion
+//#region src/Logger.ts
+THEME_PRESETS.default;
+/**
+* Clase principal Logger con capacidades avanzadas de logging
+* 
+* @class Logger
+* @description Sistema completo de logging con temas, badges, contextos y exportación.
+*              Detecta automáticamente el tema claro/oscuro del navegador.
+* 
+* @example
+* // Uso básico sin configuración
+* import logger from '@mks2508/better-logger';
+* logger.info('Aplicación iniciada');
+* logger.success('Conexión establecida');
+* 
+* @example
+* // Aplicar un preset temático
+* logger.preset('cyberpunk');
+* logger.warn('Advertencia con estilo neón');
+* 
+* @example
+* // Logger con scope para componentes
+* const auth = logger.component('Autenticación');
+* auth.info('Usuario intentando login');
+* auth.success('Login exitoso');
+* 
+*/
+var Logger = class Logger {
+	config;
+	scopedPrefix;
+	handlers = [];
+	timers = /* @__PURE__ */ new Map();
+	groupDepth = 0;
+	cliProcessor;
+	themeChangeListener;
+	badgeList = [];
+	displaySettings = {
+		showTimestamp: true,
+		showLocation: true,
+		showBadges: true
+	};
+	serializerBridge;
+	hookBridge;
+	logContext;
+	transportBridge;
+	/** Set during success() so log() skips its own dispatch (N2 fix). */
+	_successTagDispatched = false;
+	styleManager;
+	/** Whether CLI primitives (step, box, header, etc.) should be shown*/
+	_showPrimitives = true;
+	terminalBridge;
+	/**
+	* Active smart-preset reference (set by `preset()`). Typed as `unknown`
+	* to keep the public surface clean; consumed by `createStyledOutput`.
+	*/
+	_activePreset;
+	/**
+	* Name of the active smart-preset. Stored separately so theme-change
+	* detection can re-render without re-running the preset body.
+	*/
+	_activePresetName;
+	/**
+	* Last-applied `customize()` overrides. Stored for later read by
+	* `createStyledOutput`.
+	*/
+	_customization;
+	/**
+	* This logger's own context bindings (from child() calls).
+	* Single source of truth for this logger's contribution to the context chain.
+	* @private
+	*/
+	_bindings = {};
+	/**
+	* Reference to the parent's merged context record at the time this logger
+	* was created. Together with _bindings, forms the context chain.
+	* Undefined for the root logger.
+	* @private
+	*/
+	_parentContextRecord;
+	/**
+	* Crea una nueva instancia del Logger
+	* 
+	* @param {Partial<LoggerConfig>} config - Configuración opcional del logger
+	* 
+	* @example
+	* // Logger con configuración personalizada
+	* const logger = new Logger({
+	*   theme: 'neon',
+	*   globalPrefix: 'MiApp',
+	*   verbosity: 'debug',
+	*   bufferSize: 1000
+	* });
+	*/
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+		this.serializerBridge = createSerializerBridge();
+		this.hookBridge = createHookBridge();
+		this.logContext = createLogContext({
+			initialResource: this.config.resource,
+			childLoggerFactory: (childConfig) => {
+				return new Logger({
+					...this.config,
+					...childConfig
+				});
+			},
+			getParentContextRecord: () => this._captureMergedContext()
+		});
+		this.transportBridge = createTransportBridge();
+		this.styleManager = createStyleManager();
+		this.terminalBridge = createTerminalBridge({
+			config: this.config,
+			getLogger: () => this
+		});
+		this.cliProcessor = createDefaultCLI();
+		if (this.config.autoDetectTheme) this.setupAutoThemeDetection();
+	}
+	/**
+	* Configura la detección automática de tema con listener de cambios
+	* @private
+	* @description Detecta automáticamente si el navegador está en modo claro u oscuro
+	*/
+	setupAutoThemeDetection() {
+		if (this.themeChangeListener) {
+			this.themeChangeListener();
+			this.themeChangeListener = null;
+		}
+		this.themeChangeListener = setupThemeChangeListener((theme) => {
+			this.debug(`DevTools theme changed to: ${theme}`);
+		});
+	}
+	/**
+	* Obtiene la configuración actual del logger
+	* 
+	* @returns {LoggerConfig} Configuración completa actual
+	* 
+	* @example
+	* const config = logger.getConfig();
+	* console.log('Verbosidad actual:', config.verbosity);
+	* console.log('Tema actual:', config.theme);
+	* 
+	*/
+	getConfig() {
+		return { ...this.config };
+	}
+	/**
+	* Actualiza la configuración del logger
+	* 
+	* @param {Partial<LoggerConfig>} updates - Propiedades a actualizar
+	* 
+	* @example
+	* logger.updateConfig({
+	*   verbosity: 'debug',
+	*   enableTimestamps: false,
+	*   theme: 'cyberpunk'
+	* });
+	* 
+	*/
+	updateConfig(updates) {
+		const previousAutoDetect = this.config.autoDetectTheme;
+		this.config = {
+			...this.config,
+			...updates
+		};
+		if (updates.autoDetectTheme !== void 0 && updates.autoDetectTheme !== previousAutoDetect) {
+			if (updates.autoDetectTheme) this.setupAutoThemeDetection();
+			else if (this.themeChangeListener) {
+				this.themeChangeListener();
+				this.themeChangeListener = null;
+			}
+		}
+	}
+	/**
+	* Establece el prefijo global para todos los mensajes de log
+	* 
+	* @param {string} prefix - Prefijo a usar
+	* 
+	* @example
+	* logger.setGlobalPrefix('MiApp');
+	* logger.info('Iniciado'); // [MiApp] Iniciado
+	* 
+	*/
+	setGlobalPrefix(prefix) {
+		this.config.globalPrefix = prefix;
+	}
+	/**
+	* Establece el nivel de verbosidad para filtrar la salida de logs
+	* 
+	* @param {Verbosity} level - Nivel mínimo a mostrar ('debug' | 'info' | 'warn' | 'error' | 'critical' | 'silent')
+	* 
+	* @example
+	* logger.setVerbosity('warn');  // Solo muestra warn, error y critical
+	* logger.setVerbosity('debug'); // Muestra todos los niveles
+	* logger.setVerbosity('silent'); // No muestra nada
+	* 
+	*/
+	setVerbosity(level) {
+		this.config.verbosity = level;
+	}
+	/**
+	* Establece el tema del logger
+	* 
+	* @param {ThemeVariant} theme - Tema a aplicar ('default' | 'dark' | 'light' | 'neon' | 'minimal' | 'cyberpunk')
+	* 
+	* @example
+	* logger.setTheme('neon');      // Tema con colores neón
+	* logger.setTheme('minimal');   // Tema minimalista
+	* logger.setTheme('cyberpunk'); // Tema cyberpunk con efectos
+	* 
+	*/
+	setTheme(theme) {
+		if (hasPreset(theme)) {
+			this.preset(theme);
+			return;
+		}
+		if (this.styleManager.setTheme(theme)) {
+			this.config.theme = theme;
+			const bannersRecord = THEME_BANNERS;
+			if (theme in bannersRecord) {
+				const themeBanner = bannersRecord[theme];
+				if (themeBanner) this.writeOutput(`%c${themeBanner.simple}`, "info", [themeBanner.style], []);
+			}
+			this.success(`Theme changed to: ${theme}`);
+		} else this.error(`Invalid theme: ${theme}. Available:`, [...getAvailablePresets(), ...Object.keys(THEME_PRESETS)]);
+	}
+	/**
+	* Establece el tipo de banner para mostrar en la inicialización
+	* 
+	* @param {BannerType} bannerType - Tipo de banner ('simple' | 'ascii' | 'unicode' | 'svg' | 'animated')
+	* 
+	* @example
+	* logger.setBannerType('ascii');    // Banner con arte ASCII
+	* logger.setBannerType('unicode');  // Banner con caracteres Unicode
+	* logger.setBannerType('animated'); // Banner con animación
+	* 
+	*/
+	setBannerType(bannerType) {
+		this.config.bannerType = bannerType;
+		this.success(`Banner type changed to: ${bannerType}`);
+	}
+	/**
+	* Runs `fn` within an AsyncLocalStorage scope where `bindings` are
+	* merged into the context for all log calls inside `fn`.
+	*
+	* Without `fn` (the old setter shape): no-op for backwards compatibility.
+	* Prefer `child()` for persistent bindings or `withContextAsync()` for
+	* async callbacks.
+	*
+	* @param bindings - Key-value pairs to attach for the duration of `fn`
+	* @param fn - Optional synchronous function to run with scoped bindings
+	* @returns The return value of `fn`, or undefined if no fn provided
+	*
+	* @example
+	* // Scoped synchronous callback
+	* logger.withContext({ requestId: 'r-42' }, () => {
+	*   doWork(); // logs inside see requestId in attributes
+	* });
+	*
+	* @example
+	* // Persistent binding: use child()
+	* const reqLog = logger.child({ requestId: 'r-42' });
+	* reqLog.info('handling request'); // attributes include requestId
+	*
+	* @see {@link child} for an immutable copy with the merged context
+	* @see {@link withContextAsync} for async callback variant
+	*/
+	withContext(bindings, fn) {
+		return this.logContext.withContext(bindings, fn);
+	}
+	/**
+	* Async variant of `withContext`. Runs `fn` within an AsyncLocalStorage
+	* scope so bindings are available to all async log calls inside `fn`.
+	*
+	* @param bindings - Key-value pairs to attach for the duration of `fn`
+	* @param fn - Async function to run with the scoped bindings
+	* @returns The return value of `fn`
+	*
+	* @example
+	* await logger.withContextAsync({ requestId: 'r-42' }, async () => {
+	*   await fetchData(); // logs inside see requestId in attributes
+	* });
+	*
+	* @see {@link child} for a persistent child logger
+	* @see {@link withContext} for synchronous callback variant
+	*/
+	withContextAsync(bindings, fn) {
+		return this.logContext.withContextAsync(bindings, fn);
+	}
+	/**
+	* Returns an immutable copy of this logger with the extra context bound.
+	* Future calls on the child emit with the merged context, without
+	* mutating the parent — the canonical MDC pattern.
+	*
+	* @param extra - Key-value pairs to attach (requestId, userId, ...)
+	* @returns A new Logger with merged context
+	*
+	* @example
+	* const reqLog = logger.child({ requestId: req.id });
+	* reqLog.info('start');     // emits attributes: { requestId }
+	* logger.info('unrelated'); // NOT affected — parent's context untouched
+	*
+	*/
+	child(extra) {
+		const childLogger = this.logContext.child(extra);
+		childLogger._parentContextRecord = childLogger["__parentSnapshot"] ?? {};
+		childLogger._bindings = extra;
+		return childLogger;
+	}
+	/**
+	* Drops every key from the bound context. After this call, emitted
+	* records no longer carry `attributes` until {@link withContext} or
+	* {@link child} re-establish one.
+	*
+	* @returns The same logger instance, now context-free
+	*/
+	clearContext() {
+		this.logContext.clearContext();
+		return this;
+	}
+	/**
+	* Snapshot of the bound context. Returned object is a shallow copy:
+	* mutating it does NOT affect what subsequent log calls emit.
+	*
+	* @returns A read-only snapshot of the current context
+	*/
+	getContext() {
+		let merged = this._parentContextRecord ?? {};
+		if (this._bindings && Object.keys(this._bindings).length > 0) merged = {
+			...merged,
+			...this._bindings
+		};
+		return merged;
+	}
+	/**
+	* Updates the default OTel resource (service.name, version, env).
+	* Persisted into every emitted record's `resource` field unless the
+	* record itself overrides it.
+	*
+	* @param resource - Partial OTel resource to merge into the current one
+	* @returns The same logger instance, for chaining
+	*
+	* @example
+	* logger.setResource({ 'service.name': 'api', 'service.version': '1.2.3' });
+	*
+	*/
+	setResource(resource) {
+		this.logContext.setResource(resource);
+		return this;
+	}
+	/**
+	* Reinicia el logger a la configuración por defecto
+	* 
+	* @example
+	* logger.resetConfig();
+	* // Todo vuelve a la configuración inicial
+	* 
+	*/
+	resetConfig() {
+		if (this.themeChangeListener) {
+			this.themeChangeListener();
+			this.themeChangeListener = null;
+		}
+		this.config = { ...DEFAULT_CONFIG };
+		this.styleManager.resetStyles();
+		if (this.config.autoDetectTheme) this.setupAutoThemeDetection();
+		this.success("Logger configuration reset to defaults");
+	}
+	/**
+	* Método de limpieza para eliminar listeners y liberar recursos
+	* 
+	* @example
+	* // Antes de cerrar la aplicación
+	* logger.cleanup();
+	* 
+	*/
+	/**
+	* Tears down every resource held by this Logger. Safe to call multiple
+	* times. Fixed in 5.1.0 to fully drain transports + clear timers +
+	* drop the legacy handler list + reset group depth + clear context.
+	*
+	* @example
+	* await logger.cleanup(); // before process exit / hot reload
+	*
+	*/
+	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');    // Optimizado para producción
+	* 
+	*/
+	preset(name) {
+		if (!hasPreset(name)) {
+			this.error(`Unknown preset: ${name}. Available presets:`, getAvailablePresets());
+			return;
+		}
+		const presetConfig = getSmartPreset(name);
+		if (presetConfig) {
+			this.displaySettings.showTimestamp = presetConfig.timestamp?.show ?? true;
+			this.displaySettings.showLocation = presetConfig.location?.show ?? true;
+			this._activePreset = presetConfig;
+			this._activePresetName = name;
+			if (getEnvironment() === "browser") this.success(`Applied preset: ${name}`);
+		}
+	}
+	/**
+	* Lista todos los presets disponibles
+	* 
+	* @returns {string[]} Array con nombres de presets disponibles
+	* 
+	* @example
+	* const disponibles = logger.presets();
+	* console.log(disponibles); // ['default', 'cyberpunk', 'glassmorphism', ...]
+	* 
+	*/
+	presets() {
+		return getAvailablePresets();
+	}
+	/**
+	* Oculta el timestamp en los logs
+	* 
+	* @example
+	* logger.hideTimestamp();
+	* logger.info('Sin marca de tiempo'); // Sin timestamp visible
+	* 
+	*/
+	hideTimestamp() {
+		this.displaySettings.showTimestamp = false;
+		return this;
+	}
+	/**
+	* Muestra el timestamp en los logs
+	* 
+	* @example
+	* logger.showTimestamp();
+	* logger.info('Con marca de tiempo'); // [2024-01-15 10:30:45] Con marca de tiempo
+	* 
+	*/
+	showTimestamp() {
+		this.displaySettings.showTimestamp = true;
+		return this;
+	}
+	/**
+	* Oculta la información de ubicación (archivo:línea) en los logs
+	* 
+	* @example
+	* logger.hideLocation();
+	* logger.debug('Sin ubicación'); // Sin mostrar archivo:línea
+	* 
+	*/
+	hideLocation() {
+		this.displaySettings.showLocation = false;
+		return this;
+	}
+	/**
+	* Muestra la información de ubicación (archivo:línea) en los logs
+	* 
+	* @example
+	* logger.showLocation();
+	* logger.debug('Con ubicación'); // app.js:42 Con ubicación
+	* 
+	*/
+	showLocation() {
+		this.displaySettings.showLocation = true;
+		return this;
+	}
+	/**
+	* Oculta los badges en los logs
+	* 
+	* @example
+	* logger.hideBadges();
+	* const api = logger.api('REST');
+	* api.info('Sin badges'); // Sin mostrar [API] [REST]
+	* 
+	*/
+	hideBadges() {
+		this.displaySettings.showBadges = false;
+		return this;
+	}
+	/**
+	* Muestra los badges en los logs
+	*
+	* @example
+	* logger.showBadges();
+	* const api = logger.api('GraphQL');
+	* api.info('Con badges'); // [API] [GraphQL] Con badges
+	*
+	*/
+	showBadges() {
+		this.displaySettings.showBadges = true;
+		return this;
+	}
+	/**
+	* Establece múltiples badges para los logs
+	*
+	* @param {string[]} badges - Array de badges a mostrar
+	* @returns {this} Logger instance para encadenamiento
+	*
+	* @example
+	* logger.badges(['v3', 'stable']).info('Release publicado');
+	* logger.badges(['API', 'v2']).warn('Endpoint deprecado');
+	*
+	*/
+	badges(badges) {
+		this.badgeList = [...badges];
+		return this;
+	}
+	/**
+	* Añade un badge individual a la lista
+	*
+	* @param {string} badge - Badge a añadir
+	* @returns {this} Logger instance para encadenamiento
+	*
+	* @example
+	* logger.badge('DEBUG').badge('AUTH').info('Token validado');
+	*
+	*/
+	badge(badge) {
+		if (!this.badgeList.includes(badge)) this.badgeList.push(badge);
+		return this;
+	}
+	/**
+	* Limpia todos los badges activos
+	*
+	* @returns {this} Logger instance para encadenamiento
+	*
+	* @example
+	* logger.clearBadges().info('Sin badges');
+	*
+	*/
+	clearBadges() {
+		this.badgeList = [];
+		return this;
+	}
+	component(name) {
+		return new ComponentLogger(this, name);
+	}
+	api(name) {
+		return new APILogger(this, name);
+	}
+	scope(name) {
+		return new ScopedLogger(this, name);
+	}
+	/**
+	* Personalización simple con configuración mínima
+	* 
+	* @param {Object} overrides - Opciones de personalización
+	* @param {Object} overrides.message - Configuración del mensaje
+	* @param {Object} overrides.timestamp - Configuración del timestamp
+	* @param {Object} overrides.location - Configuración de ubicación
+	* @param {Object} overrides.level - Configuración del nivel
+	* @param {Object} overrides.prefix - Configuración del prefijo
+	* @param {string} overrides.spacing - Espaciado: 'compact' | 'normal' | 'spacious'
+	* 
+	* @example
+	* logger.customize({
+	*   message: { color: '#00ff00', size: '16px' },
+	*   timestamp: { show: false },
+	*   spacing: 'compact'
+	* });
+	* 
+	*/
+	customize(overrides) {
+		if (overrides.timestamp?.show !== void 0) this.displaySettings.showTimestamp = overrides.timestamp.show;
+		if (overrides.location?.show !== void 0) this.displaySettings.showLocation = overrides.location.show;
+		if (overrides.prefix?.show !== void 0) {}
+		this._customization = overrides;
+		this.success("Customization applied");
+	}
+	/**
+	* Añade un handler personalizado para extender funcionalidad
+	* 
+	* @param {ILogHandler} handler - Handler que implementa ILogHandler
+	*
+	* @example
+	* // Handler personalizado para enviar logs a servidor
+	* logger.addHandler({
+	*   handle(level, message, args, metadata) {
+	*     fetch('/logs', { method: 'POST', body: JSON.stringify({ level, message }) });
+	*   }
+	* });
+	*
+	* @example
+	* // Para escribir a archivo, usa `addTransport` con un `FileTransport`
+	* logger.addTransport({ target: new FileTransport({ destination: 'app.log' }) });
+	*
+	*/
+	addHandler(handler) {
+		this.handlers.push(handler);
+	}
+	/**
+	* Obtiene todos los handlers registrados
+	* 
+	* @returns {ILogHandler[]} Array de handlers activos
+	*/
+	getHandlers() {
+		return [...this.handlers];
+	}
+	/**
+	* Añade un serializador personalizado para un tipo específico
+	*
+	* @param type - Constructor del tipo a serializar
+	* @param serializer - Función de serialización
+	* @param priority - Prioridad (mayor = primero)
+	*
+	* @example
+	* logger.addSerializer(Error, (err) => ({
+	*   name: err.name,
+	*   message: err.message,
+	*   stack: err.stack?.split('\n').slice(0, 5)
+	* }));
+	*
+	*/
+	addSerializer(type, serializer, priority) {
+		this.serializerBridge.addSerializer(type, serializer, priority);
+	}
+	/**
+	* Elimina un serializador registrado
+	*
+	* @param type - Constructor del tipo a remover
+	* @returns true si se eliminó
+	*
+	*/
+	removeSerializer(type) {
+		return this.serializerBridge.removeSerializer(type);
+	}
+	/**
+	* Obtiene el registry de serializadores
+	*
+	* @returns SerializerRegistry
+	*/
+	getSerializerRegistry() {
+		return this.serializerBridge.getSerializerRegistry();
+	}
+	/**
+	* Registra un hook para un evento
+	*
+	* @param event - Evento: 'beforeLog' | 'afterLog' | 'onError'
+	* @param callback - Función a ejecutar
+	* @param priority - Prioridad (mayor = primero)
+	* @returns Función para desregistrar
+	*
+	* @example
+	* const unsubscribe = logger.on('beforeLog', (entry) => {
+	*   entry.correlationId = getCorrelationId();
+	*   return entry;
+	* });
+	*
+	*/
+	on(event, callback, priority) {
+		return this.hookBridge.on(event, callback, priority);
+	}
+	/**
+	* Registra un hook que se ejecuta solo una vez
+	*
+	* @param event - Evento: 'beforeLog' | 'afterLog' | 'onError'
+	* @param callback - Función a ejecutar
+	* @param priority - Prioridad (mayor = primero)
+	* @returns Función para desregistrar
+	*
+	*/
+	once(event, callback, priority) {
+		return this.hookBridge.once(event, callback, priority);
+	}
+	/**
+	* Elimina un hook registrado
+	*
+	* @param event - Evento del hook
+	* @param callback - Callback a remover
+	* @returns true si se eliminó
+	*
+	*/
+	off(event, callback) {
+		return this.hookBridge.off(event, callback);
+	}
+	/**
+	* Añade un middleware al pipeline
+	*
+	* @param middleware - Función middleware
+	* @param priority - Prioridad (mayor = primero)
+	* @returns Función para desregistrar
+	*
+	* @example
+	* logger.use((entry, next) => {
+	*   entry.requestId = asyncLocalStorage.getStore()?.requestId;
+	*   next();
+	* });
+	*
+	*/
+	use(middleware, priority) {
+		return this.hookBridge.use(middleware, priority);
+	}
+	/**
+	* Obtiene el HookManager
+	*
+	* @returns HookManager
+	*/
+	getHookManager() {
+		return this.hookBridge.getHookManager();
+	}
+	/**
+	* Añade un transport para envío de logs
+	*
+	* @param target - Configuración del transport
+	* @returns ID único del transport
+	*
+	* @example
+	* // File transport
+	* logger.addTransport({
+	*   target: 'file',
+	*   options: { destination: '/var/log/app.log' }
+	* });
+	*
+	* @example
+	* // HTTP transport con batching
+	* logger.addTransport({
+	*   target: 'http',
+	*   options: {
+	*     url: 'https://logs.example.com',
+	*     batchSize: 100,
+	*     flushInterval: 5000
+	*   },
+	*   level: 'warn'
+	* });
+	*
+	*/
+	addTransport(target) {
+		return this.transportBridge.addTransport(target);
+	}
+	/**
+	* Elimina un transport
+	*
+	* @param id - ID del transport a remover
+	* @returns true si se eliminó
+	*
+	*/
+	removeTransport(id) {
+		return this.transportBridge.removeTransport(id);
+	}
+	/**
+	* Fuerza el flush de todos los transports
+	*
+	* @returns Promise que resuelve cuando todos los buffers están vaciados
+	*
+	*/
+	async flushTransports() {
+		await this.transportBridge.flushTransports();
+	}
+	/**
+	* Cierra todos los transports
+	*
+	* @returns Promise que resuelve cuando todos están cerrados
+	*
+	*/
+	async closeTransports() {
+		await this.transportBridge.closeTransports();
+	}
+	/**
+	* Obtiene el TransportManager
+	*
+	* @returns TransportManager o undefined si no hay transports
+	*/
+	getTransportManager() {
+		return this.transportBridge.getTransportManager();
+	}
+	/**
+	* Verifica si un nivel de log debe mostrarse según la verbosidad actual.
+	* @private
+	* @param {LogLevel} level - Nivel de log a verificar
+	* @returns {boolean} True si debe mostrarse, false si no
+	*/
+	shouldLog(level) {
+		if (this.config.verbosity === "silent") return false;
+		return LOG_LEVELS[level] >= LOG_LEVELS[this.config.verbosity];
+	}
+	/**
+	* Builds and dispatches a `TransportRecord` to the {@link TransportManager}
+	* (no-op if no transports are registered). Shared by every log path —
+	* `log()`, `success()`, and visual methods like `table()` / `group()` /
+	* `time()` — so all emissions hit the same transport pipeline.
+	*
+	* @param level - The canonical log level (trace/debug/info/warn/error/critical)
+	* @param message - Final, post-hook message text
+	* @param prefix - Effective prefix (global + scope)
+	* @param stackInfo - Optional caller location
+	* @param extra - Optional fields to merge into the record (e.g. `{ tag: 'success' }`)
+	*/
+	_dispatchTag;
+	/**
+	* Computes the fully-merged context for this logger.
+	*
+	* The context chain is built at child-creation time: each child stores
+	* its parent's fully-merged context (at that moment) as _parentContextRecord.
+	* This means _parentContextRecord already contains all ancestors' bindings
+	* in the correct precedence order (root first, nearest child last).
+	*
+	* Merge order (later wins):
+	*   1. _parentContextRecord — parent's merged context snapshot at creation time
+	*   2. _bindings            — this logger's own bindings (child() calls)
+	*   3. ALS store            — withContext/withContextAsync scope (highest priority)
+	*
+	* @internal
+	* @returns The merged context record
+	*/
+	_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 Exposes base merged context (no ALS) to LogContext child factory closure. */
+	_captureMergedContext() {
+		let merged = this._parentContextRecord ?? {};
+		if (this._bindings && Object.keys(this._bindings).length > 0) merged = {
+			...merged,
+			...this._bindings
+		};
+		return merged;
+	}
+	dispatchToTransports(level, message, prefix, stackInfo, extra) {
+		const record = {
+			level,
+			levelValue: LOG_LEVELS[level],
+			severityNumber: LOG_LEVEL_TO_SEVERITY_NUMBER[level],
+			severityText: LOG_LEVEL_TO_SEVERITY_TEXT[level],
+			time: Date.now(),
+			msg: message,
+			prefix,
+			location: stackInfo ? {
+				file: stackInfo.file,
+				line: stackInfo.line,
+				column: stackInfo.column,
+				function: stackInfo.function
+			} : void 0,
+			attributes: Object.keys(this.logContext._getContextRecord()).length > 0 ? toLogAttributes(this.logContext._getContextRecord()) : void 0,
+			resource: this.logContext._getResource() ? { ...this.logContext._getResource() } : void 0,
+			...extra
+		};
+		this.transportBridge.writeRecord(record);
+	}
+	/**
+	* Obtiene el prefijo efectivo (global + scope)
+	* @private
+	* @returns {string | undefined} Prefijo combinado o undefined
+	*/
+	getEffectivePrefix() {
+		const parts = [this.config.globalPrefix, this.scopedPrefix].filter(Boolean);
+		return parts.length > 0 ? parts.join(":") : void 0;
+	}
+	/**
+	* Método central de logging. Awaits the `beforeLog` hook pipeline
+	* synchronously (so redactions / enrichments are reflected in the
+	* emitted message before console + transport dispatch).
+	*
+	* Fire-and-forget callers (e.g. `logger.info(...)` without `await`)
+	* still work — the resulting `Promise<void>` is dropped on the floor.
+	* Awaiting is recommended when `beforeLog` hooks mutate `message`
+	* (e.g. PII redaction, correlation IDs).
+	*
+	* @protected
+	* @param level - Nivel del log
+	* @param args - Argumentos a loggear
+	* @returns Promise that resolves once the record has been dispatched
+	*
+	*/
+	/**
+	* Protected logging method. Awaits the `beforeLog` hook pipeline
+	* synchronously (so redactions / enrichments are reflected in the
+	* emitted message before console + transport dispatch).
+	*
+	* Fire-and-forget callers (e.g. `logger.info(...)` without `await`)
+	* still work — the resulting `Promise<void>` is dropped on the floor.
+	* Awaiting is recommended when `beforeLog` hooks mutate `message`
+	* (e.g. PII redaction, correlation IDs).
+	*
+	* @protected
+	* @param level - Nivel del log
+	* @param args - Argumentos a loggear
+	* @param tag - Optional tag forwarded to `dispatchToTransports` as
+	*              `TransportRecord.tag` (e.g. `'success'` for success records).
+	* @returns Promise that resolves once the record has been dispatched
+	*
+	*/
+	async log(level, ...args) {
+		if (!this.shouldLog(level)) return;
+		const dispatchTag = this._dispatchTag;
+		this._dispatchTag = void 0;
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		const prefix = this.getEffectivePrefix();
+		const timestamp = formatTimestamp();
+		const serializedArgs = args.map((arg) => this.serializerBridge.getSerializerRegistry().serialize(arg));
+		let message = serializedArgs.length > 0 ? String(serializedArgs[0]) : "";
+		if (this.badgeList.length > 0 && this.displaySettings.showBadges) message = this.badgeList.map((b) => `[${b}]`).join("") + " " + message;
+		const additionalArgs = serializedArgs.slice(1);
+		const hookEntry = {
+			level,
+			message,
+			args: serializedArgs,
+			timestamp,
+			prefix,
+			stackInfo: stackInfo ?? void 0
+		};
+		let processed;
+		try {
+			processed = await this.hookBridge.getHookManager().emit("beforeLog", hookEntry);
+		} catch (error) {
+			console.error("HookManager beforeLog failed:", error);
+			processed = hookEntry;
+		}
+		message = processed.message;
+		const [format, ...styles] = createStyledOutput(level, this.styleManager.getStyles(), prefix, message, this.displaySettings.showLocation ? stackInfo : null, this.config.autoDetectTheme, this._activePreset, this._activePresetName);
+		const finalFormat = "  ".repeat(this.groupDepth) + format;
+		this.writeOutput(finalFormat, level, styles, additionalArgs);
+		const metadata = {
+			timestamp,
+			level,
+			prefix,
+			stackInfo: stackInfo ?? void 0
+		};
+		this.handlers.forEach((handler) => {
+			try {
+				handler.handle(level, message, serializedArgs, metadata);
+			} catch (error) {
+				console.error("Log handler failed:", error);
+			}
+		});
+		if (dispatchTag !== void 0) this.dispatchToTransports(level, message, prefix, stackInfo, { tag: dispatchTag });
+		else this.dispatchToTransports(level, message, prefix, stackInfo);
+		this.hookBridge.getHookManager().emit("afterLog", processed).catch(() => {});
+	}
+	logWithBindings(bindings, level, ...args) {
+		if (!this.shouldLog(level)) return Promise.resolve();
+		let prefix = "";
+		const colorCapability = getColorCapability();
+		if (bindings.badges?.length) prefix += bindings.badges.map((b) => formatBadge(b, "pill", colorCapability, "#00ff88")).join(" ") + " ";
+		if (bindings.scope) prefix += formatBadge(bindings.scope, "pill", colorCapability, "#00ffff") + " ";
+		if (prefix && args.length > 0) args[0] = prefix + String(args[0]);
+		return this.log(level, ...args);
+	}
+	/**
+	* Like `logWithBindings()` but sets _dispatchTag first so that
+	* `log()` dispatches with the tag. Used by ScopedLogger.success()
+	* to propagate tag:'success' through the normal log() pipeline.
+	*/
+	logWithBindingsAndTag(bindings, level, tag, ...args) {
+		this._dispatchTag = tag;
+		return this.logWithBindings(bindings, level, ...args);
+	}
+	debug(...args) {
+		return this.log("debug", ...args);
+	}
+	/**
+	* Registra mensajes informativos. Devuelve `Promise<void>` desde 5.1.0.
+	*
+	* @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. Devuelve `Promise<void>` desde 5.1.0.
+	*
+	* @param args - Mensajes de advertencia
+	*
+	*/
+	warn(...args) {
+		return this.log("warn", ...args);
+	}
+	/**
+	* Registra mensajes de error. Devuelve `Promise<void>` desde 5.1.0.
+	*
+	* @param args - Mensaje de error y stack traces
+	*
+	*/
+	error(...args) {
+		return this.log("error", ...args);
+	}
+	/**
+	* Registra mensajes de éxito. Mapeado internamente a nivel `info` con
+	* styling de success y `record.tag = 'success'` para que los transports
+	* puedan distinguirlo (sin perder info semantics para filtering).
+	*
+	* @param args - Mensaje + datos adicionales
+	*
+	* @example
+	* logger.success('Base de datos conectada');
+	* logger.success('Usuario creado con ID:', userId);
+	* logger.success('✓ Tests pasados: 42/42');
+	*
+	*/
+	async success(...args) {
+		if (!this.shouldLog("info")) return;
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		const prefix = this.getEffectivePrefix();
+		const timestamp = formatTimestamp();
+		const serializedArgs = args.map((arg) => this.serializerBridge.getSerializerRegistry().serialize(arg));
+		let message = serializedArgs.length > 0 ? String(serializedArgs[0]) : "";
+		if (this.badgeList.length > 0 && this.displaySettings.showBadges) message = this.badgeList.map((b) => `[${b}]`).join("") + " " + message;
+		const additionalArgs = serializedArgs.slice(1);
+		const hookEntry = {
+			level: "info",
+			message,
+			args: serializedArgs,
+			timestamp,
+			prefix,
+			stackInfo: stackInfo ?? void 0
+		};
+		try {
+			message = (await this.hookBridge.getHookManager().emit("beforeLog", hookEntry)).message;
+		} catch {}
+		const [format, ...styles] = createStyledOutput("info", this.styleManager.getStyles(), prefix, message, this.displaySettings.showLocation ? stackInfo : null, this.config.autoDetectTheme, this._activePreset, this._activePresetName);
+		const successStyle = this.styleManager.getStyles().success;
+		const emoji = successStyle?.emoji ?? "✅";
+		const label = successStyle?.label ?? "SUCCESS";
+		const successFormat = format.replace(/ℹ️ INFO/, `${emoji} ${label}`);
+		const finalFormat = "  ".repeat(this.groupDepth) + successFormat;
+		this.writeOutput(finalFormat, "info", styles, additionalArgs);
+		const metadata = {
+			timestamp,
+			level: "info",
+			prefix,
+			stackInfo: stackInfo ?? void 0
+		};
+		this.handlers.forEach((handler) => {
+			try {
+				handler.handle("info", message, args, metadata);
+			} catch (error) {
+				console.error("Log handler failed:", error);
+			}
+		});
+		this._dispatchTag = "success";
+		await this.log("info", ...args);
+		this.hookBridge.getHookManager().emit("afterLog", hookEntry).catch(() => {});
+	}
+	/**
+	* Registra información de trace (nivel más bajo, debajo de debug).
+	* Alineado con OpenTelemetry `TRACE` severity (1-4).
+	*
+	* @param args - Datos muy verbosos (entrada/salida de funciones, valores intermedios)
+	*
+	* @example
+	* logger.trace('Entrando en función processData');
+	* logger.trace('Variables intermedias:', { a, b, c });
+	*
+	*/
+	trace(...args) {
+		this.log("trace", ...args);
+	}
+	/**
+	* Registra errores críticos (prioridad más alta). Devuelve `Promise<void>` desde 5.1.0.
+	*
+	* @param args - Errores críticos del sistema
+	*
+	* @example
+	* await logger.critical('Sistema caído - reinicio inmediato requerido');
+	*
+	*/
+	critical(...args) {
+		return this.log("critical", ...args);
+	}
+	/**
+	* Muestra datos en formato de tabla. Pasa por la pipeline completa
+	* (outputMode-respecting writeOutput + transports + hooks).
+	*
+	* @param data - Array de objetos o matriz
+	* @param columns - Columnas específicas a mostrar (opcional)
+	*
+	* @example
+	* logger.table([{ id: 1, nombre: 'Juan' }, { id: 2, nombre: 'María' }]);
+	*
+	*/
+	table(data, columns) {
+		if (!this.shouldLog("info")) return;
+		const prefix = this.getEffectivePrefix();
+		const tableStyle = StylePresets.accent().build();
+		const format = `%c${`📊 TABLE${prefix ? ` [${prefix}]` : ""}`}`;
+		const styles = [tableStyle];
+		this.writeOutput(format, "info", styles, []);
+		[...columns ? [columns] : []];
+		if (this.config.outputMode !== "silent") if (columns) console.table(data, columns);
+		else console.table(data);
+		const message = `table:${Array.isArray(data) ? `${data.length} rows` : "data"}`;
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		this.dispatchToTransports("info", message, prefix, stackInfo, { attributes: {
+			...this.logContext._getContextRecord(),
+			"logger.visual": "table",
+			"logger.data": JSON.stringify(data).slice(0, 4096),
+			...columns ? { "logger.columns": columns.join(",") } : {}
+		} });
+	}
+	/**
+	* Inicia un grupo colapsable en la consola. Emite un marker a
+	* transports con `attributes.logger.visual = 'groupStart'` para que
+	* backends puedan reconstruir la jerarquía.
+	*
+	* @param label - Etiqueta del grupo
+	* @param collapsed - Si el grupo inicia colapsado (default: false)
+	*
+	* @example
+	* logger.group('Procesando usuarios');
+	* logger.info('Usuario 1 procesado');
+	* logger.groupEnd();
+	*
+	*/
+	group(label, collapsed = false) {
+		const groupStyle = new StyleBuilder().bg("linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%)").color("#1565c0").border("1px solid #90caf9").padding("4px 12px").rounded("6px").bold().build();
+		const format = `%c📁 ${label}`;
+		if (this.config.outputMode !== "silent") if (collapsed) console.groupCollapsed(format, groupStyle);
+		else console.group(format, groupStyle);
+		this.groupDepth++;
+		const prefix = this.getEffectivePrefix();
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		this.dispatchToTransports("info", `group:start:${label}`, prefix, stackInfo, { attributes: {
+			...this.logContext._getContextRecord(),
+			"logger.visual": "groupStart",
+			"logger.group.label": label,
+			"logger.group.collapsed": collapsed,
+			"logger.group.depth": this.groupDepth
+		} });
+	}
+	/**
+	* Finaliza el grupo actual de la consola. Emite un marker a transports
+	* simétrico al `group()` start, para que backends puedan cerrar la
+	* jerarquía correctamente.
+	*
+	* @example
+	* logger.group('Operaciones');
+	* logger.info('Operación 1');
+	* logger.groupEnd();
+	*
+	*/
+	groupEnd() {
+		if (this.groupDepth > 0) {
+			this.groupDepth--;
+			if (this.config.outputMode !== "silent") console.groupEnd();
+			const prefix = this.getEffectivePrefix();
+			const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+			this.dispatchToTransports("info", "group:end", prefix, stackInfo, { attributes: {
+				...this.logContext._getContextRecord(),
+				"logger.visual": "groupEnd",
+				"logger.group.depth": this.groupDepth
+			} });
+		}
+	}
+	/**
+	* Inicia un temporizador con la etiqueta dada
+	* 
+	* @param {string} label - Etiqueta identificadora del temporizador
+	* 
+	* @example
+	* logger.time('proceso-datos');
+	* // ... operación costosa ...
+	* logger.timeEnd('proceso-datos'); // ⏱️ Timer ended: proceso-datos - 1523.45ms
+	* 
+	*/
+	time(label) {
+		const timer = {
+			label,
+			startTime: (typeof performance !== "undefined" ? performance : Date).now()
+		};
+		this.timers.set(label, timer);
+		const timerStyle = StylePresets.warning().build();
+		const format = `%c⏱️ Timer started: ${label}`;
+		this.writeOutput(format, "debug", [timerStyle], []);
+	}
+	/**
+	* Finaliza un temporizador y muestra el tiempo transcurrido
+	*
+	* @param {string} label - Etiqueta del temporizador a finalizar
+	* @returns {number} Elapsed milliseconds, or -1 if timer not found
+	*
+	* @example
+	* logger.time('consulta-db');
+	* await consultarBaseDatos();
+	* const elapsed = logger.timeEnd('consulta-db'); // ⏱️ Timer ended: consulta-db - 234.56ms
+	*
+	*/
+	timeEnd(label) {
+		const timer = this.timers.get(label);
+		if (!timer) {
+			this.warn(`Timer '${label}' does not exist`);
+			return -1;
+		}
+		const elapsed = (typeof performance !== "undefined" ? performance : Date).now() - timer.startTime;
+		this.timers.delete(label);
+		const timerStyle = StylePresets.success().build();
+		const format = `%c⏱️ Timer ended: ${label} - ${elapsed.toFixed(2)}ms`;
+		this.writeOutput(format, "info", [timerStyle], []);
+		const prefix = this.getEffectivePrefix();
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		this.dispatchToTransports("info", `timer:${label}`, prefix, stackInfo, {
+			tag: "success",
+			attributes: {
+				...this.logContext._getContextRecord(),
+				"logger.visual": "timer",
+				"logger.timer.label": label,
+				"logger.timer.elapsedMs": elapsed
+			}
+		});
+		return elapsed;
+	}
+	/**
+	* Muestra un banner con el tipo especificado o configurado
+	* 
+	* @param {BannerType} bannerType - Tipo de banner (opcional)
+	* 
+	* @example
+	* logger.showBanner('ascii');    // Banner ASCII art
+	* logger.showBanner('unicode');  // Banner con caracteres Unicode
+	* logger.showBanner('svg');      // Banner con gráfico SVG
+	* logger.showBanner();           // Usa el tipo configurado
+	* 
+	*/
+	showBanner(bannerType) {
+		displayInitBanner(bannerType ? bannerType : this.config.bannerType);
+	}
+	/**
+	* Registra mensaje con imagen SVG de fondo
+	* 
+	* @param {string} message - Mensaje a mostrar
+	* @param {string} svgContent - Contenido SVG personalizado (opcional)
+	* @param {StyleOptions} options - Opciones de estilo (ancho, alto, padding)
+	* 
+	* @example
+	* // SVG automático con gradiente
+	* logger.logWithSVG('🎆 Bienvenido a Better Logger');
+	* 
+	* @example
+	* // SVG personalizado
+	* const customSVG = '<svg>...</svg>';
+	* logger.logWithSVG('Logo', customSVG, { width: 400, height: 100 });
+	* 
+	*/
+	logWithSVG(message, svgContent, options = {}) {
+		if (!this.shouldLog("info")) return;
+		const { width = 300, height = 60, padding = "30px 150px" } = options;
+		let svgDataUri = "";
+		if (svgContent) svgDataUri = `data:image/svg+xml,${encodeURIComponent(svgContent)}`;
+		else {
+			const defaultSVG = `<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 ${width} ${height}'><defs><linearGradient id='grad' x1='0%' y1='0%' x2='100%' y2='0%'><stop offset='0%' style='stop-color:%23667eea'/><stop offset='100%' style='stop-color:%23764ba2'/></linearGradient></defs><rect width='100%' height='100%' fill='url(%23grad)' rx='4'/><text x='${width / 2}' y='${height / 2 + 5}' text-anchor='middle' fill='white' font-family='monospace' font-size='14' font-weight='bold'>${message}</text></svg>`;
+			svgDataUri = `data:image/svg+xml,${encodeURIComponent(defaultSVG)}`;
+		}
+		const svgStyle = new StyleBuilder().bg(`url("${svgDataUri}") no-repeat center center`).padding(padding).color("transparent").rounded("4px").build();
+		this.writeOutput(`%c${message}`, "info", [svgStyle], []);
+		const prefix = this.getEffectivePrefix();
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		this.dispatchToTransports("info", `svg:${message}`, prefix, stackInfo, { attributes: {
+			...this.logContext._getContextRecord(),
+			"logger.visual": "svg",
+			"logger.svg.width": width,
+			"logger.svg.height": height
+		} });
+	}
+	/**
+	* Registra mensaje con gradiente animado de fondo
+	* 
+	* @param {string} message - Mensaje a animar
+	* @param {number} duration - Duración de la animación en segundos (default: 3)
+	* 
+	* @example
+	* logger.logAnimated('🌈 Animación en progreso');
+	* logger.logAnimated('Cargando...', 5); // Animación de 5 segundos
+	* 
+	*/
+	logAnimated(message, duration = 3) {
+		if (!this.shouldLog("info")) return;
+		if (typeof document !== "undefined") {
+			if (!document.getElementById("logger-animations")) {
+				const style = document.createElement("style");
+				style.id = "logger-animations";
+				style.textContent = `
+                    @keyframes loggerGradient {
+                        0% { background-position: 0% 50%; }
+                        50% { background-position: 100% 50%; }
+                        100% { background-position: 0% 50%; }
+                    }
+                `;
+				document.head.appendChild(style);
+			}
+		}
+		const animatedStyle = new StyleBuilder().bg("linear-gradient(-45deg, #667eea, #764ba2, #667eea, #764ba2)").css("background-size", "400% 400%").color("#ffffff").padding("12px 20px").rounded("8px").bold().font("Monaco, Consolas, monospace").animation(`loggerGradient ${duration}s ease infinite`).display("inline-block").build();
+		this.writeOutput(`%c${message}`, "info", [animatedStyle], []);
+		const prefix = this.getEffectivePrefix();
+		const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+		this.dispatchToTransports("info", `animated:${message}`, prefix, stackInfo, { attributes: {
+			...this.logContext._getContextRecord(),
+			"logger.visual": "animated",
+			"logger.animation.durationSec": duration
+		} });
+	}
+	/**
+	* Displays a step progress indicator in the terminal
+	*
+	* @param {number} current - Current step number
+	* @param {number} total - Total number of steps
+	* @param {string} message - Step description
+	*
+	* @example
+	* logger.step(1, 5, 'Analyzing repository...');
+	* logger.step(2, 5, 'Generating commit message...');
+	*
+	*/
+	step(current, total, message) {
+		this.terminalBridge.step(current, total, message);
+	}
+	/**
+	* Displays a styled header with optional subtitle
+	*
+	* @param {string} title - Main title text
+	* @param {string} subtitle - Optional subtitle (rendered dimmed)
+	*
+	* @example
+	* logger.header('Commit Wizard', 'v2.0.0');
+	*
+	*/
+	header(title, subtitle) {
+		this.terminalBridge.header(title, subtitle);
+	}
+	/**
+	* Displays a horizontal divider line
+	*
+	* @example
+	* logger.divider();
+	*
+	*/
+	divider() {
+		this.terminalBridge.divider();
+	}
+	/**
+	* Outputs a blank line
+	*
+	* @example
+	* logger.blank();
+	*
+	*/
+	blank() {
+		this.terminalBridge.blank();
+	}
+	/**
+	* Renders content inside a bordered box
+	*
+	* @param {string} content - Content string (may contain newlines)
+	* @param {IBoxOptions} options - Box rendering options
+	*
+	* @example
+	* logger.box('3 commits generated\nProvider: Groq', { title: 'Done', borderColor: '#00ff00' });
+	*
+	*/
+	box(content, options) {
+		this.terminalBridge.box(content, options);
+	}
+	/**
+	* Renders an array of objects as a formatted ASCII table.
+	* Note: This is distinct from the existing table() method which uses console.table.
+	*
+	* @param {Record<string, unknown>[]} rows - Array of row objects
+	* @param {ITableOptions} options - Table rendering options
+	*
+	* @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);
+	}
+	/**
+	* Creates a spinner handle for showing progress during async operations.
+	* Returns a NoopSpinner in non-TTY environments.
+	*
+	* @param {string} message - Initial spinner text
+	* @returns {ISpinnerHandle} Spinner controller
+	*
+	* @example
+	* const s = logger.spinner('Analyzing repository...');
+	* s.start();
+	* await analyzeRepo();
+	* s.succeed('Analysis complete (1.2s)');
+	*
+	*/
+	spinner(message) {
+		return this.terminalBridge.spinner(message);
+	}
+	/**
+	* Sets the CLI verbosity level, controlling both log verbosity and primitive visibility
+	*
+	* @param {CLILogLevel} level - CLI log level
+	*
+	* @example
+	* logger.setCLILevel('quiet');   // Only errors, no CLI primitives
+	* logger.setCLILevel('verbose'); // Debug logs + all CLI primitives
+	*
+	*/
+	setCLILevel(level) {
+		const mapping = CLI_LEVEL_MAP[level];
+		this.setVerbosity(mapping.verbosity);
+		this.terminalBridge.setShowPrimitives(mapping.showPrimitives);
+		this.config.cliLevel = level;
+	}
+	/**
+	* Returns the current CLI log level
+	* @returns {CLILogLevel} Current CLI log level
+	*/
+	get cliLevel() {
+		return this.config.cliLevel ?? "normal";
+	}
+	/**
+	* Writes formatted output to the configured destination.
+	* Respects outputMode configuration for console, silent, or custom output.
+	*
+	* @private
+	* @param {string} message - Formatted log message
+	* @param {LogLevel} level - Log level
+	* @param {string[]} styles - CSS styles for browser console
+	* @param {unknown[]} additionalArgs - Additional arguments to log
+	*/
+	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);
+	}
+};
+/**
+/**
+* Lazy singleton instance — initialised on first call to {@link getDefaultLogger},
+* not on module import. Fixes BUG-N11 (eager side-effect at import time).
+*
+* @private
+*/
+let _defaultLogger = null;
+/**
+* Lazily creates the default Logger singleton.
+*
+* The singleton is only built on first call, so importing the module
+* never executes `new Logger(...)` or `displayInitBanner()`. This keeps
+* module imports side-effect free.
+*
+* @returns The shared Logger instance
+*/
+function getDefaultLogger() {
+	if (!_defaultLogger) {
+		_defaultLogger = new Logger({
+			verbosity: "info",
+			enableColors: true,
+			enableTimestamps: true,
+			enableStackTrace: true,
+			cliLevel: "normal"
+		});
+		try {
+			if (typeof window !== "undefined" || typeof document !== "undefined") displayInitBanner();
+		} catch {}
+	}
+	return _defaultLogger;
+}
+new Proxy({}, { get(_target, prop, receiver) {
+	const instance = getDefaultLogger();
+	const value = Reflect.get(instance, prop, receiver);
+	return typeof value === "function" ? value.bind(instance) : value;
+} });
+/**
+* Narrow a free-form `Record<string, unknown>` context into a typed
+* `ILogAttributes` bag. Unknown shapes fall back to JSON-encoded strings,
+* which keeps the OTLP transport happy (every value lands in a typed slot).
+*
+* @param input - The user-supplied context (typically `Logger.context`).
+* @returns A new attribute bag matching `ILogAttributes`.
+*/
+function toLogAttributes(input) {
+	const out = {};
+	for (const [key, value] of Object.entries(input)) {
+		const mapped = toAttributeValue(value);
+		if (mapped !== void 0) out[key] = mapped;
+	}
+	return out;
+}
+function toAttributeValue(value) {
+	if (value === null || value === void 0) return void 0;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) {
+		const values = [];
+		for (const item of value) {
+			const mapped = toAttributeValue(item);
+			if (mapped !== void 0) values.push(mapped);
+		}
+		return values;
+	}
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/index.ts
+/**
+* @fileoverview Better Logger — default entry point.
+*
+* Re-exports `Logger`, the scoped loggers, subpath-style bridges, and
+* cross-runtime styling/utility helpers. Side-effect free at import.
+*/
+let _logger = null;
+function getLogger() {
+	if (!_logger) _logger = new Logger();
+	return _logger;
+}
+/**
+* Default Logger singleton (lazy). Use this for the common case.
+*/
+var src_default = getLogger();
+/**
+* Top-level log methods bound to the default singleton.
+*/
+const debug = (...args) => getLogger().debug(...args);
+const info = (...args) => getLogger().info(...args);
+const warn = (...args) => getLogger().warn(...args);
+const error = (...args) => getLogger().error(...args);
+const success = (...args) => getLogger().success(...args);
+const critical = (...args) => getLogger().critical(...args);
+const trace = (...args) => getLogger().trace(...args);
+const table = (data, columns) => getLogger().table(data, columns);
+const group = (label, collapsed) => getLogger().group(label, collapsed);
+const groupEnd = () => getLogger().groupEnd();
+const time = (label) => getLogger().time(label);
+const timeEnd = (label) => getLogger().timeEnd(label);
+const setGlobalPrefix = (prefix) => getLogger().setGlobalPrefix(prefix);
+const scope = (name) => getLogger().scope(name);
+const component = (name) => getLogger().component(name);
+const api = (name) => getLogger().api(name);
+const badges = (badgeList) => getLogger().badges(badgeList);
+const badge = (badgeName) => getLogger().badge(badgeName);
+const clearBadges = () => getLogger().clearBadges();
+const setVerbosity = (level) => getLogger().setVerbosity(level);
+const addHandler = (handler) => getLogger().addHandler(handler);
+const setTheme = (theme) => getLogger().setTheme(theme);
+const setBannerType = (bannerType) => getLogger().setBannerType(bannerType);
+const showBanner = (bannerType) => getLogger().showBanner(bannerType);
+const logWithSVG = (message, svgContent, options) => getLogger().logWithSVG(message, svgContent, options);
+const logAnimated = (message, duration) => getLogger().logAnimated(message, duration);
+const cli = (command) => getLogger().cli(command);
+const addSerializer = (type, serializer, priority) => getLogger().addSerializer(type, serializer, priority);
+const removeSerializer = (type) => getLogger().removeSerializer(type);
+const on = (event, callback, priority) => getLogger().on(event, callback, priority);
+const once = (event, callback, priority) => getLogger().once(event, callback, priority);
+const off = (event, callback) => getLogger().off(event, callback);
+const use = (middleware, priority) => getLogger().use(middleware, priority);
+const addTransport = (target) => getLogger().addTransport(target);
+const removeTransport = (id) => getLogger().removeTransport(id);
+const flushTransports = () => getLogger().flushTransports();
+const closeTransports = () => getLogger().closeTransports();
+//#endregion
+export { APILogger, BANNER_VARIANTS, ComponentLogger, ContextLogger, DEFAULT_CONFIG, Logger, ScopedLogger, StyleBuilder, StylePresets, THEME_BANNERS, THEME_PRESETS, addHandler, addSerializer, addTransport, ansiBackground, ansiBold, ansiColor, ansiDim, ansiStyle, ansiUnderline, api, badge, badges, clearBadges, cli, closeTransports, component, createLogEntry, critical, debug, src_default as default, error, flushTransports, formatLogLevelANSI, formatSuccessANSI, formatTablePlain, formatTimestamp, getColorCapability, getConsoleMethod, getEnvironment, getEnvironmentInfo, getTerminalHeight, getTerminalWidth, group, groupEnd, info, isRunningInTerminal, logAnimated, logWithSVG, off, on, once, parseStackTrace, removeSerializer, removeTransport, safeSerialize, scope, setBannerType, setGlobalPrefix, setTheme, setVerbosity, showBanner, success, supportsANSI, table, time, timeEnd, trace, use, warn };
+
+//# sourceMappingURL=index.js.map