@mks2508/better-logger 2.1.0 → 3.0.0

package/dist/chunks/{Logger-B7L-ujY4.js → Logger-C126NTrD.js}

@@ -1,4 +1,364 @@
-import { h as getAdaptiveColor, A as ADAPTIVE_COLORS, b as StyleBuilder, j as BUFFER_LIMITS, k as generateLogId, l as parseTimeInput, m as formatDisplayTime, n as safeStringify, o as escapeHtml, q as EXPORT_FORMATS, D as DEFAULT_CONFIG, r as setupThemeChangeListener, t as getEnvironment, p as parseStackTrace, c as createStyledOutput, f as formatTimestamp, S as StylePresets } from "./environment-TI2ByCPT.js";
+import { h as getAdaptiveColor, A as ADAPTIVE_COLORS, b as StyleBuilder, j as BUFFER_LIMITS, k as generateLogId, l as parseTimeInput, m as formatDisplayTime, n as safeStringify, o as escapeHtml, q as EXPORT_FORMATS, D as DEFAULT_CONFIG$1, r as setupThemeChangeListener, t as getEnvironment, p as parseStackTrace, f as formatTimestamp, c as createStyledOutput, S as StylePresets } from "./environment-TI2ByCPT.js";
+const DEFAULT_CONFIG = {
+  maxDepth: 5,
+  circular: "placeholder",
+  preserveUndefined: false
+};
+class SerializerRegistry {
+  serializers = /* @__PURE__ */ new Map();
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.registerDefaults();
+  }
+  registerDefaults() {
+    this.add(Error, (err) => ({
+      name: err.name,
+      message: err.message,
+      stack: err.stack?.split("\n").slice(0, 10),
+      ...err.cause ? { cause: this.serialize(err.cause) } : {}
+    }), 100);
+    this.add(Date, (date) => ({
+      iso: date.toISOString(),
+      timestamp: date.getTime()
+    }), 90);
+    this.add(RegExp, (regex) => ({
+      pattern: regex.source,
+      flags: regex.flags
+    }), 90);
+    this.add(Map, (map, ctx) => {
+      const obj = {};
+      map.forEach((value, key) => {
+        const keyStr = typeof key === "object" ? JSON.stringify(key) : String(key);
+        obj[keyStr] = this.serializeInternal(value, {
+          ...ctx,
+          depth: ctx.depth + 1,
+          path: [...ctx.path, keyStr]
+        });
+      });
+      return { __type: "Map", entries: obj };
+    }, 80);
+    this.add(Set, (set, ctx) => ({
+      __type: "Set",
+      values: Array.from(set).map(
+        (v, i) => this.serializeInternal(v, {
+          ...ctx,
+          depth: ctx.depth + 1,
+          path: [...ctx.path, `[${i}]`]
+        })
+      )
+    }), 80);
+    if (typeof Buffer !== "undefined") {
+      this.add(Buffer, (buf) => ({
+        __type: "Buffer",
+        length: buf.length,
+        preview: buf.slice(0, 50).toString("hex")
+      }), 70);
+    }
+  }
+  add(type, serializer, priority = 50) {
+    this.serializers.set(type, { type, serializer, priority });
+  }
+  remove(type) {
+    return this.serializers.delete(type);
+  }
+  has(type) {
+    return this.serializers.has(type);
+  }
+  getAll() {
+    return Array.from(this.serializers.values()).sort((a, b) => (b.priority ?? 50) - (a.priority ?? 50));
+  }
+  findSerializer(value) {
+    const sorted = this.getAll();
+    for (const entry of sorted) {
+      if (value instanceof entry.type) {
+        return entry;
+      }
+    }
+    return null;
+  }
+  serializeInternal(value, context) {
+    if (value === null) return null;
+    if (value === void 0) return this.config.preserveUndefined ? void 0 : "[undefined]";
+    if (typeof value === "function") return `[Function: ${value.name || "anonymous"}]`;
+    if (typeof value !== "object") return value;
+    if (context.depth >= this.config.maxDepth) {
+      return "[Max Depth]";
+    }
+    if (context.seen.has(value)) {
+      switch (this.config.circular) {
+        case "error":
+          throw new Error(`Circular reference at ${context.path.join(".")}`);
+        case "skip":
+          return void 0;
+        case "placeholder":
+        default:
+          return "[Circular]";
+      }
+    }
+    context.seen.add(value);
+    const serializer = this.findSerializer(value);
+    if (serializer) {
+      return serializer.serializer(value, context);
+    }
+    if (Array.isArray(value)) {
+      return value.map(
+        (item, i) => this.serializeInternal(item, {
+          ...context,
+          depth: context.depth + 1,
+          path: [...context.path, `[${i}]`]
+        })
+      );
+    }
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = this.serializeInternal(val, {
+        ...context,
+        depth: context.depth + 1,
+        path: [...context.path, key]
+      });
+    }
+    return result;
+  }
+  serialize(value, config) {
+    const mergedConfig = { ...this.config, ...config };
+    return this.serializeInternal(value, {
+      depth: 0,
+      maxDepth: mergedConfig.maxDepth,
+      path: [],
+      seen: /* @__PURE__ */ new WeakSet()
+    });
+  }
+}
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+class HookManager {
+  hooks = /* @__PURE__ */ new Map();
+  middlewares = [];
+  constructor() {
+    this.hooks.set("beforeLog", []);
+    this.hooks.set("afterLog", []);
+    this.hooks.set("onError", []);
+  }
+  on(event, callback, priority = 50) {
+    const registration = {
+      id: generateId(),
+      event,
+      callback,
+      priority,
+      once: false
+    };
+    const hooks = this.hooks.get(event);
+    hooks.push(registration);
+    hooks.sort((a, b) => b.priority - a.priority);
+    return () => this.removeHook(event, registration.id);
+  }
+  once(event, callback, priority = 50) {
+    const registration = {
+      id: generateId(),
+      event,
+      callback,
+      priority,
+      once: true
+    };
+    const hooks = this.hooks.get(event);
+    hooks.push(registration);
+    hooks.sort((a, b) => b.priority - a.priority);
+    return () => this.removeHook(event, registration.id);
+  }
+  off(event, callback) {
+    const hooks = this.hooks.get(event);
+    if (!hooks) return false;
+    const index = hooks.findIndex((h) => h.callback === callback);
+    if (index >= 0) {
+      hooks.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  removeHook(event, id) {
+    const hooks = this.hooks.get(event);
+    if (hooks) {
+      const index = hooks.findIndex((h) => h.id === id);
+      if (index >= 0) {
+        hooks.splice(index, 1);
+      }
+    }
+  }
+  use(middleware, priority = 50) {
+    const registration = {
+      id: generateId(),
+      fn: middleware,
+      priority
+    };
+    this.middlewares.push(registration);
+    this.middlewares.sort((a, b) => b.priority - a.priority);
+    return () => {
+      const index = this.middlewares.findIndex((m) => m.id === registration.id);
+      if (index >= 0) {
+        this.middlewares.splice(index, 1);
+      }
+    };
+  }
+  async emit(event, entry) {
+    const hooks = this.hooks.get(event) || [];
+    let currentEntry = { ...entry };
+    const toRemove = [];
+    for (const hook of hooks) {
+      try {
+        const result = await hook.callback(currentEntry);
+        if (result) {
+          currentEntry = { ...currentEntry, ...result };
+        }
+        if (hook.once) {
+          toRemove.push(hook.id);
+        }
+      } catch (error) {
+        if (event !== "onError") {
+          await this.emit("onError", {
+            ...currentEntry,
+            error,
+            hookEvent: event
+          });
+        }
+      }
+    }
+    toRemove.forEach((id) => this.removeHook(event, id));
+    return currentEntry;
+  }
+  async process(entry) {
+    let currentEntry = { ...entry };
+    currentEntry = await this.emit("beforeLog", currentEntry);
+    if (this.middlewares.length > 0) {
+      let index = 0;
+      const executeNext = async () => {
+        if (index < this.middlewares.length) {
+          const middleware = this.middlewares[index++];
+          if (middleware) {
+            await middleware.fn(currentEntry, executeNext);
+          }
+        }
+      };
+      await executeNext();
+    }
+    return currentEntry;
+  }
+  async afterProcess(entry) {
+    await this.emit("afterLog", entry);
+  }
+  clear() {
+    this.hooks.forEach((hooks) => hooks.length = 0);
+    this.middlewares.length = 0;
+  }
+  getStats() {
+    return {
+      hooks: {
+        beforeLog: this.hooks.get("beforeLog")?.length || 0,
+        afterLog: this.hooks.get("afterLog")?.length || 0,
+        onError: this.hooks.get("onError")?.length || 0
+      },
+      middlewares: this.middlewares.length
+    };
+  }
+}
+const LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  critical: 4
+};
+function generateTransportId() {
+  return `transport-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
+}
+class TransportManager {
+  transports = /* @__PURE__ */ new Map();
+  defaultLevel = "info";
+  constructor(defaultLevel) {
+    if (defaultLevel) {
+      this.defaultLevel = defaultLevel;
+    }
+  }
+  add(target) {
+    const id = generateTransportId();
+    const level = target.level || this.defaultLevel;
+    let transport;
+    if (typeof target.target === "string") {
+      throw new Error(`String transport targets not supported. Use inline transport object.`);
+    } else {
+      transport = target.target;
+    }
+    const entry = {
+      id,
+      transport,
+      options: target.options || {},
+      level,
+      levelValue: LOG_LEVELS[level]
+    };
+    this.transports.set(id, entry);
+    return id;
+  }
+  remove(id) {
+    const entry = this.transports.get(id);
+    if (entry) {
+      entry.transport.close?.();
+      return this.transports.delete(id);
+    }
+    return false;
+  }
+  async write(record) {
+    const promises = [];
+    for (const entry of this.transports.values()) {
+      if (record.levelValue < entry.levelValue) {
+        continue;
+      }
+      let transformedRecord = record;
+      if (entry.options.transform) {
+        const result2 = entry.options.transform(record);
+        if (result2 === null) continue;
+        transformedRecord = result2;
+      }
+      const result = entry.transport.write(transformedRecord);
+      if (result instanceof Promise) {
+        promises.push(result);
+      }
+    }
+    await Promise.all(promises);
+  }
+  async flush() {
+    const promises = [];
+    for (const entry of this.transports.values()) {
+      if (entry.transport.flush) {
+        const result = entry.transport.flush();
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      }
+    }
+    await Promise.all(promises);
+  }
+  async close() {
+    await this.flush();
+    const promises = [];
+    for (const entry of this.transports.values()) {
+      if (entry.transport.close) {
+        const result = entry.transport.close();
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      }
+    }
+    await Promise.all(promises);
+    this.transports.clear();
+  }
+  get count() {
+    return this.transports.size;
+  }
+  list() {
+    return Array.from(this.transports.keys());
+  }
+}
 const THEME_PRESETS = {
   default: {
     debug: {
@@ -1210,6 +1570,193 @@ function getAvailablePresets() {
 function hasPreset(name) {
   return name in SMART_PRESETS;
 }
+class ScopedLogger {
+  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 void 0;
+    }
+    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.logWithBindings(bindings, "info", ...args);
+  }
+  critical(...args) {
+    this.parent.logWithBindings(this.getBindings(), "critical", ...args);
+  }
+  trace(...args) {
+    this.parent.logWithBindings(this.getBindings(), "debug", ...args);
+    console.trace(`[${this.scopeName}]`);
+  }
+  _pushContext(context) {
+    this.contextStack.push(context);
+  }
+  _popContext() {
+    this.contextStack.pop();
+  }
+}
+class APILogger 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);
+  }
+}
+class ComponentLogger 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);
+  }
+}
+class ContextLogger {
+  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);
+  }
+}
 class ExportLogHandler {
   buffer = [];
   maxSize;
@@ -2497,11 +3044,15 @@ class Logger {
   exportHandler;
   cliProcessor;
   themeChangeListener;
+  badgeList = [];
   displaySettings = {
     showTimestamp: true,
     showLocation: true,
     showBadges: true
   };
+  serializerRegistry;
+  hookManager;
+  transportManager;
   /**
    * Crea una nueva instancia del Logger
    * 
@@ -2518,9 +3069,11 @@ class Logger {
    */
   constructor(config = {}) {
     this.config = {
-      ...DEFAULT_CONFIG,
+      ...DEFAULT_CONFIG$1,
       ...config
     };
+    this.serializerRegistry = new SerializerRegistry();
+    this.hookManager = new HookManager();
     if (this.config.bufferSize) {
       this.exportHandler = new ExportLogHandler(this.config.bufferSize);
       this.handlers.push(this.exportHandler);
@@ -2675,7 +3228,7 @@ class Logger {
       this.themeChangeListener();
       this.themeChangeListener = null;
     }
-    this.config = { ...DEFAULT_CONFIG };
+    this.config = { ...DEFAULT_CONFIG$1 };
     LEVEL_STYLES = THEME_PRESETS.default;
     if (this.config.autoDetectTheme) {
       this.setupAutoThemeDetection();
@@ -2696,32 +3249,8 @@ class Logger {
       this.themeChangeListener();
       this.themeChangeListener = null;
     }
-  }
-  /**
-   * Factory method para crear loggers con scope evitando dependencias circulares
-   * @private
-   * @param {string} type - Tipo de logger ('scope' | 'api' | 'component')
-   * @param {string} name - Nombre del scope
-   * @returns {Promise<any>} Logger con scope
-   */
-  async createScopedLogger(type, name) {
-    try {
-      const { ScopedLogger, APILogger, ComponentLogger } = await import("./ScopedLogger-D-RbiFZn.js");
-      switch (type) {
-        case "component":
-          return new ComponentLogger(this, name);
-        case "api":
-          return new APILogger(this, name);
-        case "scope":
-        default:
-          return new ScopedLogger(this, name);
-      }
-    } catch (error2) {
-      this.error("Failed to load ScopedLogger, using basic logger with prefix:", error2);
-      const basicLogger = new Logger(this.getConfig());
-      basicLogger.setGlobalPrefix(`${this.config.globalPrefix || ""}:${name}`);
-      return basicLogger;
-    }
+    this.transportManager?.close().catch(() => {
+    });
   }
   // ===== SIMPLIFIED API =====
   /**
@@ -2839,77 +3368,74 @@ class Logger {
   }
   /**
    * Muestra los badges en los logs
-   * 
+   *
    * @example
    * logger.showBadges();
    * const api = logger.api('GraphQL');
    * api.info('Con badges'); // [API] [GraphQL] Con badges
-   * 
+   *
    * @since 0.3.0
    */
   showBadges() {
     this.displaySettings.showBadges = true;
     this.success("Badges shown");
   }
-  // ===== SCOPED LOGGERS =====
   /**
-   * Crea un logger para componentes con estilo automático
-   * 
-   * @param {string} name - Nombre del componente
-   * @returns {ComponentLogger} Logger con scope de componente
-   * 
+   * Establece múltiples badges para los logs
+   *
+   * @param {string[]} badges - Array de badges a mostrar
+   * @returns {this} Logger instance para encadenamiento
+   *
    * @example
-   * const authLogger = logger.component('Autenticación');
-   * authLogger.info('Validando credenciales');
-   * // [COMPONENT] [Autenticación] Validando credenciales
-   * 
-   * authLogger.success('Usuario autenticado');
-   * // [COMPONENT] [Autenticación] ✓ Usuario autenticado
-   * 
-   * @since 0.3.0
+   * logger.badges(['v3', 'stable']).info('Release publicado');
+   * logger.badges(['API', 'v2']).warn('Endpoint deprecado');
+   *
+   * @since 3.0.0
    */
-  component(name) {
-    return this.createScopedLogger("component", name);
+  badges(badges2) {
+    this.badgeList = [...badges2];
+    return this;
   }
   /**
-   * Crea un logger para APIs con badges automáticos
-   * 
-   * @param {string} name - Nombre de la API o endpoint
-   * @returns {APILogger} Logger con scope de API
-   * 
+   * Añade un badge individual a la lista
+   *
+   * @param {string} badge - Badge a añadir
+   * @returns {this} Logger instance para encadenamiento
+   *
    * @example
-   * const api = logger.api('REST');
-   * api.info('GET /users');
-   * // [API] [REST] GET /users
-   * 
-   * // Con badges adicionales
-   * api.badges(['v2', 'cached']).info('Respuesta desde caché');
-   * // [API] [v2] [cached] [REST] Respuesta desde caché
-   * 
-   * @since 0.3.0
+   * logger.badge('DEBUG').badge('AUTH').info('Token validado');
+   *
+   * @since 3.0.0
    */
-  api(name) {
-    return this.createScopedLogger("api", name);
+  badge(badge2) {
+    if (!this.badgeList.includes(badge2)) {
+      this.badgeList.push(badge2);
+    }
+    return this;
   }
   /**
-   * Crea un logger con scope general y soporte de badges
-   * 
-   * @param {string} name - Nombre del scope
-   * @returns {ScopedLogger} Logger con scope personalizado
-   * 
+   * Limpia todos los badges activos
+   *
+   * @returns {this} Logger instance para encadenamiento
+   *
    * @example
-   * const dbLogger = logger.scope('Database');
-   * dbLogger.info('Conectando a MongoDB');
-   * // [Database] Conectando a MongoDB
-   * 
-   * // Con badges personalizados
-   * dbLogger.badge('SLOW').warn('Query tardó 5s');
-   * // [SLOW] [Database] Query tardó 5s
-   * 
-   * @since 0.3.0
+   * logger.clearBadges().info('Sin badges');
+   *
+   * @since 3.0.0
    */
+  clearBadges() {
+    this.badgeList = [];
+    return this;
+  }
+  // ===== SCOPED LOGGERS =====
+  component(name) {
+    return new ComponentLogger(this, name);
+  }
+  api(name) {
+    return new APILogger(this, name);
+  }
   scope(name) {
-    return this.createScopedLogger("scope", name);
+    return new ScopedLogger(this, name);
   }
   // ===== SIMPLE CUSTOMIZATION =====
   /**
@@ -2981,13 +3507,199 @@ class Logger {
   }
   /**
    * Obtiene el handler de exportación si está disponible
-   * 
+   *
    * @returns {ExportLogHandler | undefined} Handler de exportación o undefined
    * @since 0.3.0
    */
   getExportHandler() {
     return this.exportHandler;
   }
+  // ===== SERIALIZERS =====
+  /**
+   * 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)
+   * }));
+   *
+   * @since 3.0.0
+   */
+  addSerializer(type, serializer, priority) {
+    this.serializerRegistry.add(type, serializer, priority);
+  }
+  /**
+   * Elimina un serializador registrado
+   *
+   * @param type - Constructor del tipo a remover
+   * @returns true si se eliminó
+   *
+   * @since 3.0.0
+   */
+  removeSerializer(type) {
+    return this.serializerRegistry.remove(type);
+  }
+  /**
+   * Obtiene el registry de serializadores
+   *
+   * @returns SerializerRegistry
+   * @since 3.0.0
+   */
+  getSerializerRegistry() {
+    return this.serializerRegistry;
+  }
+  // ===== HOOKS & MIDDLEWARE =====
+  /**
+   * 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;
+   * });
+   *
+   * @since 3.0.0
+   */
+  on(event, callback, priority) {
+    return this.hookManager.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
+   *
+   * @since 3.0.0
+   */
+  once(event, callback, priority) {
+    return this.hookManager.once(event, callback, priority);
+  }
+  /**
+   * Elimina un hook registrado
+   *
+   * @param event - Evento del hook
+   * @param callback - Callback a remover
+   * @returns true si se eliminó
+   *
+   * @since 3.0.0
+   */
+  off(event, callback) {
+    return this.hookManager.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();
+   * });
+   *
+   * @since 3.0.0
+   */
+  use(middleware, priority) {
+    return this.hookManager.use(middleware, priority);
+  }
+  /**
+   * Obtiene el HookManager
+   *
+   * @returns HookManager
+   * @since 3.0.0
+   */
+  getHookManager() {
+    return this.hookManager;
+  }
+  // ===== TRANSPORTS =====
+  /**
+   * 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'
+   * });
+   *
+   * @since 3.0.0
+   */
+  addTransport(target) {
+    if (!this.transportManager) {
+      this.transportManager = new TransportManager();
+    }
+    return this.transportManager.add(target);
+  }
+  /**
+   * Elimina un transport
+   *
+   * @param id - ID del transport a remover
+   * @returns true si se eliminó
+   *
+   * @since 3.0.0
+   */
+  removeTransport(id) {
+    return this.transportManager?.remove(id) ?? false;
+  }
+  /**
+   * Fuerza el flush de todos los transports
+   *
+   * @returns Promise que resuelve cuando todos los buffers están vaciados
+   *
+   * @since 3.0.0
+   */
+  async flushTransports() {
+    await this.transportManager?.flush();
+  }
+  /**
+   * Cierra todos los transports
+   *
+   * @returns Promise que resuelve cuando todos están cerrados
+   *
+   * @since 3.0.0
+   */
+  async closeTransports() {
+    await this.transportManager?.close();
+  }
+  /**
+   * Obtiene el TransportManager
+   *
+   * @returns TransportManager o undefined si no hay transports
+   * @since 3.0.0
+   */
+  getTransportManager() {
+    return this.transportManager;
+  }
   // ===== CORE LOGGING METHODS =====
   /**
    * Verifica si un nivel de log debe mostrarse según la verbosidad actual
@@ -3019,8 +3731,26 @@ class Logger {
     if (!this.shouldLog(level)) return;
     const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
     const prefix = this.getEffectivePrefix();
-    const message = args.length > 0 ? String(args[0]) : "";
-    const additionalArgs = args.slice(1);
+    const timestamp = formatTimestamp();
+    const serializedArgs = args.map((arg) => this.serializerRegistry.serialize(arg));
+    let message = serializedArgs.length > 0 ? String(serializedArgs[0]) : "";
+    if (this.badgeList.length > 0 && this.displaySettings.showBadges) {
+      const badgePrefix = this.badgeList.map((b) => `[${b}]`).join("");
+      message = badgePrefix + " " + message;
+    }
+    const additionalArgs = serializedArgs.slice(1);
+    let hookEntry = {
+      level,
+      message,
+      args: serializedArgs,
+      timestamp,
+      prefix,
+      stackInfo: stackInfo || void 0
+    };
+    this.hookManager.emit("beforeLog", hookEntry).then((processed) => {
+      message = processed.message;
+    }).catch(() => {
+    });
     const [format, ...styles2] = createStyledOutput(
       level,
       LEVEL_STYLES,
@@ -3042,30 +3772,59 @@ class Logger {
       this.exportHandler.setGroupInfo(this.groupDepth);
     }
     const metadata = {
-      timestamp: formatTimestamp(),
+      timestamp,
       level,
       prefix,
       stackInfo: stackInfo ? stackInfo : void 0
     };
     this.handlers.forEach((handler) => {
       try {
-        handler.handle(level, message, args, metadata);
+        handler.handle(level, message, serializedArgs, metadata);
       } catch (error2) {
         console.error("Log handler failed:", error2);
       }
     });
+    if (this.transportManager) {
+      const levelValues = {
+        debug: 0,
+        info: 1,
+        warn: 2,
+        error: 3,
+        critical: 4
+      };
+      const record = {
+        level,
+        levelValue: levelValues[level],
+        time: Date.now(),
+        msg: message,
+        prefix,
+        location: stackInfo ? {
+          file: stackInfo.file,
+          line: stackInfo.line,
+          column: stackInfo.column,
+          function: stackInfo.function
+        } : void 0
+      };
+      this.transportManager.write(record).catch(() => {
+      });
+    }
+    this.hookManager.emit("afterLog", hookEntry).catch(() => {
+    });
+  }
+  logWithBindings(bindings, level, ...args) {
+    if (!this.shouldLog(level)) return;
+    let prefix = "";
+    if (bindings.badges?.length) {
+      prefix += bindings.badges.map((b) => `[${b}]`).join("");
+    }
+    if (bindings.scope) {
+      prefix += `[${bindings.scope}] `;
+    }
+    if (prefix && args.length > 0) {
+      args[0] = prefix + String(args[0]);
+    }
+    this.log(level, ...args);
   }
-  /**
-   * Registra información de debug (prioridad más baja)
-   * 
-   * @param {...any} args - Mensajes y datos a loggear
-   * 
-   * @example
-   * logger.debug('Variable estado:', { usuario: 'Juan', activo: true });
-   * logger.debug('Iniciando proceso de validación');
-   * 
-   * @since 0.3.0
-   */
   debug(...args) {
     this.log("debug", ...args);
   }
@@ -3493,11 +4252,18 @@ function getDefaultLogger() {
 }
 getDefaultLogger();
 export {
+  APILogger as A,
   BANNER_VARIANTS as B,
+  ComponentLogger as C,
   ExportLogHandler as E,
+  HookManager as H,
   Logger as L,
+  SerializerRegistry as S,
   THEME_PRESETS as T,
   THEME_BANNERS as a,
-  displayInitBanner as d
+  TransportManager as b,
+  ScopedLogger as c,
+  ContextLogger as d,
+  displayInitBanner as e
 };
-//# sourceMappingURL=Logger-B7L-ujY4.js.map
+//# sourceMappingURL=Logger-C126NTrD.js.map