@syntropysoft/syntropyfront 0.4.3 → 0.4.5

package/dist/index.js

@@ -1,49 +1,43 @@
 /**
- * BreadcrumbStore - Almacén de huellas del usuario
- * Mantiene un historial de las últimas acciones del usuario
+ * BreadcrumbStore - User action timeline storage
+ * Maintains a history of the last user actions.
+ * Does not know about Agent or sending; the orchestrator wires onBreadcrumbAdded to decide what to do.
  */
 class BreadcrumbStore {
   constructor(maxBreadcrumbs = 25) {
     this.maxBreadcrumbs = maxBreadcrumbs;
     this.breadcrumbs = [];
-    this.agent = null;
+    /** @type {((crumb: object) => void)|null} Optional callback when a breadcrumb is added (set by orchestrator). */
+    this.onBreadcrumbAdded = null;
   }
 
   /**
-     * Configura el agent para envío automático
-     * @param {Object} agent - Instancia del agent
-     */
-  setAgent(agent) {
-    this.agent = agent;
-  }
-
-  /**
-     * Configura el tamaño máximo de breadcrumbs
-     * @param {number} maxBreadcrumbs - Nuevo tamaño máximo
+     * Configures the maximum breadcrumb size
+     * @param {number} maxBreadcrumbs - New maximum size
      */
   setMaxBreadcrumbs(maxBreadcrumbs) {
     this.maxBreadcrumbs = maxBreadcrumbs;
-        
-    // Si el nuevo tamaño es menor, eliminar breadcrumbs excedentes
+
+    // If new size is smaller, remove excess breadcrumbs
     if (this.breadcrumbs.length > this.maxBreadcrumbs) {
       this.breadcrumbs = this.breadcrumbs.slice(-this.maxBreadcrumbs);
     }
   }
 
   /**
-     * Obtiene el tamaño máximo actual
-     * @returns {number} Tamaño máximo de breadcrumbs
+     * Gets current maximum size
+     * @returns {number} Maximum breadcrumb size
      */
   getMaxBreadcrumbs() {
     return this.maxBreadcrumbs;
   }
 
   /**
-     * Añade un breadcrumb a la lista
-     * @param {Object} crumb - El breadcrumb a añadir
-     * @param {string} crumb.category - Categoría del evento (ui, network, error, etc.)
-     * @param {string} crumb.message - Mensaje descriptivo
-     * @param {Object} [crumb.data] - Datos adicionales opcionales
+     * Adds a breadcrumb to the list
+     * @param {Object} crumb - The breadcrumb to add
+     * @param {string} crumb.category - Event category (ui, network, error, etc.)
+     * @param {string} crumb.message - Descriptive message
+     * @param {Object} [crumb.data] - Optional additional data
      */
   add(crumb) {
     const breadcrumb = {
@@ -51,58 +45,57 @@ class BreadcrumbStore {
       timestamp: new Date().toISOString(),
     };
 
-    if (this.breadcrumbs.length >= this.maxBreadcrumbs) {
-      this.breadcrumbs.shift(); // Elimina el más antiguo
-    }
-        
-    this.breadcrumbs.push(breadcrumb);
-        
-    // Callback opcional para logging
+    // Functional limit management
+    this.breadcrumbs = [...this.breadcrumbs, breadcrumb].slice(-this.maxBreadcrumbs);
+
     if (this.onBreadcrumbAdded) {
-      this.onBreadcrumbAdded(breadcrumb);
-    }
-        
-    // Enviar al agent si está configurado y habilitado
-    if (this.agent && this.agent.isEnabled) {
       try {
-        this.agent.sendBreadcrumbs([breadcrumb]);
+        this.onBreadcrumbAdded(breadcrumb);
       } catch (error) {
-        console.warn('SyntropyFront: Error enviando breadcrumb al agent:', error);
+        console.warn('SyntropyFront: Error in onBreadcrumbAdded:', error);
       }
     }
   }
 
   /**
-     * Devuelve todos los breadcrumbs
-     * @returns {Array} Copia de todos los breadcrumbs
+     * Returns all breadcrumbs
+     * @returns {Array} List of all breadcrumbs
      */
   getAll() {
     return [...this.breadcrumbs];
   }
 
   /**
-     * Limpia todos los breadcrumbs
+     * Clears all breadcrumbs
      */
   clear() {
     this.breadcrumbs = [];
   }
 
   /**
-     * Obtiene breadcrumbs por categoría
-     * @param {string} category - Categoría a filtrar
-     * @returns {Array} Breadcrumbs de la categoría especificada
+     * Gets current breadcrumb count
+     * @returns {number} Breadcrumb count
+     */
+  count() {
+    return this.breadcrumbs.length;
+  }
+
+  /**
+     * Gets breadcrumbs by category
+     * @param {string} category - Category to filter
+     * @returns {Array} Breadcrumbs of the specified category
      */
   getByCategory(category) {
     return this.breadcrumbs.filter(b => b.category === category);
   }
 }
 
-// Instancia singleton
+// Singleton instance
 const breadcrumbStore = new BreadcrumbStore();
 
 /**
- * ConfigurationManager - Maneja la configuración del Agent
- * Responsabilidad única: Gestionar configuración y validación
+ * ConfigurationManager - Handles Agent configuration
+ * Single Responsibility: Manage configuration and validation
  */
 class ConfigurationManager {
   constructor() {
@@ -119,11 +112,12 @@ class ConfigurationManager {
     this.maxRetries = 5;
     this.baseDelay = 1000;
     this.maxDelay = 30000;
+    this.samplingRate = 1.0; // 100% by default
   }
 
   /**
-     * Configura el manager
-     * @param {Object} config - Configuración
+     * Configures the manager
+     * @param {Object} config - Configuration
      */
   configure(config) {
     this.endpoint = config.endpoint;
@@ -134,27 +128,28 @@ class ConfigurationManager {
     this.encrypt = config.encrypt || null;
     this.usePersistentBuffer = config.usePersistentBuffer === true;
     this.maxRetries = config.maxRetries || this.maxRetries;
-        
-    // Lógica simple: si hay batchTimeout = enviar breadcrumbs, sino = solo errores
+    this.samplingRate = typeof config.samplingRate === 'number' ? config.samplingRate : this.samplingRate;
+
+    // Simple logic: if batchTimeout exists = send breadcrumbs, else = errors only
     this.sendBreadcrumbs = !!config.batchTimeout;
   }
 
   /**
-     * Verifica si el agent está habilitado
+     * Checks if the agent is enabled
      */
   isAgentEnabled() {
     return this.isEnabled;
   }
 
   /**
-     * Verifica si debe enviar breadcrumbs
+     * Checks if it should send breadcrumbs
      */
   shouldSendBreadcrumbs() {
     return this.sendBreadcrumbs;
   }
 
   /**
-     * Obtiene la configuración actual
+     * Gets the current configuration
      */
   getConfig() {
     return {
@@ -168,59 +163,60 @@ class ConfigurationManager {
       usePersistentBuffer: this.usePersistentBuffer,
       maxRetries: this.maxRetries,
       baseDelay: this.baseDelay,
-      maxDelay: this.maxDelay
+      maxDelay: this.maxDelay,
+      samplingRate: this.samplingRate
     };
   }
 }
 
 /**
- * QueueManager - Maneja la cola de envío y batching
- * Responsabilidad única: Gestionar cola de items y batching
+ * QueueManager - Send queue and batching.
+ * Contract: add(item) enqueues or triggers flush; flush(cb) passes items to cb and clears queue; getSize/isEmpty/getAll are read-only.
  */
 class QueueManager {
+  /** @param {{ batchSize: number, batchTimeout: number|null }} configManager */
   constructor(configManager) {
     this.config = configManager;
     this.queue = [];
     this.batchTimer = null;
-    this.flushCallback = null; // Callback interno para flush automático
+    this.flushCallback = null;
   }
 
   /**
-     * Añade un item a la cola
-     * @param {Object} item - Item a añadir
-     */
+   * Adds an item; may trigger immediate or scheduled flush.
+   * @param {Object} item - Item to enqueue (non-null)
+   */
   add(item) {
+    // Guard: Avoid null items
+    if (!item) return;
+
     this.queue.push(item);
 
-    // Enviar inmediatamente si alcanza el tamaño del batch
+    // Guard: Immediate flush if batchSize is reached
     if (this.queue.length >= this.config.batchSize) {
-      this.flush(this.flushCallback);
-    } else if (this.config.batchSize && this.config.batchTimeout && !this.batchTimer) {
-      // Solo programar timeout si batchTimeout está configurado
-      this.batchTimer = setTimeout(() => {
-        this.flush(this.flushCallback);
-      }, this.config.batchTimeout);
+      return this.flush(this.flushCallback);
     }
+
+    // Guard: Only set Timer if one doesn't exist and we have a timeout configured
+    if (!this.config.batchTimeout || this.batchTimer) return;
+
+    this.batchTimer = setTimeout(() => {
+      this.flush(this.flushCallback);
+    }, this.config.batchTimeout);
   }
 
-  /**
-     * Obtiene todos los items de la cola
-     */
+  /** @returns {Array<Object>} Copy of the queue */
   getAll() {
     return [...this.queue];
   }
 
-  /**
-     * Limpia la cola
-     */
+  /** Clears the queue and cancels the timer. */
   clear() {
     this.queue = [];
     this.clearTimer();
   }
 
-  /**
-     * Limpia el timer
-     */
+  /** Cancels the scheduled flush timer. */
   clearTimer() {
     if (this.batchTimer) {
       clearTimeout(this.batchTimer);
@@ -228,24 +224,21 @@ class QueueManager {
     }
   }
 
-  /**
-     * Obtiene el tamaño de la cola
-     */
+  /** @returns {number} Queue length */
   getSize() {
     return this.queue.length;
   }
 
-  /**
-     * Verifica si la cola está vacía
-     */
+  /** @returns {boolean} */
   isEmpty() {
     return this.queue.length === 0;
   }
 
   /**
-     * Flush de la cola (método que será llamado por el Agent)
-     * @param {Function} flushCallback - Callback para procesar los items
-     */
+   * Sends current items to the callback and clears the queue.
+   * @param {(items: Array<Object>) => Promise<void>|void} flushCallback
+   * @returns {Promise<void>}
+   */
   async flush(flushCallback) {
     if (this.queue.length === 0) return;
 
@@ -260,10 +253,11 @@ class QueueManager {
 }
 
 /**
- * RetryManager - Maneja el sistema de reintentos
- * Responsabilidad única: Gestionar reintentos con backoff exponencial
+ * RetryManager - Retries with exponential backoff.
+ * Contract: addToRetryQueue enqueues and schedules; processRetryQueue(sendCb, removeCb) processes ready items.
  */
 class RetryManager {
+  /** @param {{ baseDelay: number, maxDelay: number, maxRetries: number }} configManager */
   constructor(configManager) {
     this.config = configManager;
     this.retryQueue = [];
@@ -271,14 +265,17 @@ class RetryManager {
   }
 
   /**
-     * Añade items a la cola de reintentos
-     * @param {Array} items - Items a reintentar
-     * @param {number} retryCount - Número de reintento
-     * @param {number} persistentId - ID en buffer persistente (opcional)
-     */
+   * Enqueues items for retry (delay = min(baseDelay*2^(retryCount-1), maxDelay)).
+   * @param {Array<Object>} items
+   * @param {number} [retryCount=1]
+   * @param {number|null} [persistentId=null]
+   */
   addToRetryQueue(items, retryCount = 1, persistentId = null) {
+    // Guard: Avoid empty items
+    if (!items || items.length === 0) return;
+
     const delay = Math.min(this.config.baseDelay * Math.pow(2, retryCount - 1), this.config.maxDelay);
-        
+
     this.retryQueue.push({
       items,
       retryCount,
@@ -290,71 +287,89 @@ class RetryManager {
   }
 
   /**
-     * Programa el próximo reintento
-     */
+   * Processes items with nextRetry <= now; calls sendCallback and removePersistentCallback on success.
+   * @param {(items: Array<Object>) => Promise<void>} sendCallback
+   * @param {(id: number) => Promise<void>} removePersistentCallback
+   * @returns {Promise<void>}
+   */
+  async processRetryQueue(sendCallback, removePersistentCallback) {
+    this.retryTimer = null;
+    if (this.retryQueue.length === 0) return;
+
+    const now = Date.now();
+    const itemsToRetry = this.retryQueue.filter(item => item.nextRetry <= now);
+
+    for (const item of itemsToRetry) {
+      await this.handleRetryItem(item, sendCallback, removePersistentCallback);
+    }
+
+    // Schedule next retry if items remain (Functional)
+    if (this.retryQueue.length > 0) {
+      this.scheduleRetry();
+    }
+  }
+
+  /**
+   * Schedules the next retry (Guard Clause style)
+   */
   scheduleRetry() {
+    // Guard: Avoid multiple simultaneous timers
     if (this.retryTimer) return;
 
+    // Functional: Find the first item that needs a retry
     const nextItem = this.retryQueue.find(item => item.nextRetry <= Date.now());
     if (!nextItem) return;
 
+    // Guard: Calculate delay and schedule
+    const delay = Math.max(0, nextItem.nextRetry - Date.now());
     this.retryTimer = setTimeout(() => {
-      this.processRetryQueue();
-    }, Math.max(0, nextItem.nextRetry - Date.now()));
+      this.processRetryQueue(this.sendCallback, this.removePersistentCallback);
+    }, delay);
   }
 
   /**
-     * Procesa la cola de reintentos
-     * @param {Function} sendCallback - Callback para enviar items
-     * @param {Function} removePersistentCallback - Callback para remover del buffer persistente
-     */
-  async processRetryQueue(sendCallback, removePersistentCallback) {
-    this.retryTimer = null;
+   * Handles an individual retry item (SOLID: Single Responsibility)
+   * @private
+   */
+  async handleRetryItem(item, sendCallback, removePersistentCallback) {
+    try {
+      if (sendCallback) await sendCallback(item.items);
 
-    const now = Date.now();
-    const itemsToRetry = this.retryQueue.filter(item => item.nextRetry <= now);
-        
-    for (const item of itemsToRetry) {
-      try {
-        if (sendCallback) {
-          await sendCallback(item.items);
-        }
-                
-        // ✅ Éxito: remover de cola de reintentos
-        this.retryQueue = this.retryQueue.filter(q => q !== item);
-                
-        // Remover del buffer persistente si existe
-        if (item.persistentId && removePersistentCallback) {
-          await removePersistentCallback(item.persistentId);
-        }
-                
-        console.log(`SyntropyFront: Reintento exitoso después de ${item.retryCount} intentos`);
-      } catch (error) {
-        console.warn(`SyntropyFront: Reintento ${item.retryCount} falló:`, error);
-                
-        if (item.retryCount >= this.config.maxRetries) {
-          // ❌ Máximo de reintentos alcanzado
-          this.retryQueue = this.retryQueue.filter(q => q !== item);
-          console.error('SyntropyFront: Item excedió máximo de reintentos, datos perdidos');
-        } else {
-          // Programar próximo reintento
-          item.retryCount++;
-          item.nextRetry = Date.now() + Math.min(
-            this.config.baseDelay * Math.pow(2, item.retryCount - 1), 
-            this.config.maxDelay
-          );
-        }
+      // Success: Clear state
+      this.retryQueue = this.retryQueue.filter(q => q !== item);
+      if (item.persistentId && removePersistentCallback) {
+        await removePersistentCallback(item.persistentId);
       }
+      console.log(`SyntropyFront: Successful retry (${item.retryCount})`);
+    } catch (error) {
+      this.handleRetryFailure(item, error);
     }
+  }
 
-    // Programar próximo reintento si quedan items
-    if (this.retryQueue.length > 0) {
-      this.scheduleRetry();
+  /**
+   * Manages a retry failure
+   * @private
+   */
+  handleRetryFailure(item, error) {
+    console.warn(`SyntropyFront: Retry ${item.retryCount} failed:`, error);
+
+    // Guard: Maximum retries reached
+    if (item.retryCount >= this.config.maxRetries) {
+      this.retryQueue = this.retryQueue.filter(q => q !== item);
+      console.error('SyntropyFront: Item exceeded maximum retries, data lost');
+      return;
     }
+
+    // Increment and reschedule
+    item.retryCount++;
+    item.nextRetry = Date.now() + Math.min(
+      this.config.baseDelay * Math.pow(2, item.retryCount - 1),
+      this.config.maxDelay
+    );
   }
 
   /**
-     * Limpia la cola de reintentos
+     * Clears the retry queue
      */
   clear() {
     this.retryQueue = [];
@@ -362,7 +377,7 @@ class RetryManager {
   }
 
   /**
-     * Limpia el timer
+     * Clears the timer
      */
   clearTimer() {
     if (this.retryTimer) {
@@ -372,14 +387,14 @@ class RetryManager {
   }
 
   /**
-     * Obtiene el tamaño de la cola de reintentos
+     * Gets the retry queue size
      */
   getSize() {
     return this.retryQueue.length;
   }
 
   /**
-     * Verifica si la cola de reintentos está vacía
+     * Checks if the retry queue is empty
      */
   isEmpty() {
     return this.retryQueue.length === 0;
@@ -387,8 +402,58 @@ class RetryManager {
 }
 
 /**
- * RobustSerializer - Serializador robusto que maneja referencias circulares
- * Implementa una solución similar a flatted pero sin dependencias externas
+ * Pure type-specific fragments: serialization/deserialization without state.
+ * Testable in isolation; state (circularRefs) is handled by RobustSerializer.
+ */
+
+const MAX_STRING_SNIPPET_LENGTH = 200;
+
+const serializedShapeOfDate = (date) => ({
+  __type: 'Date',
+  value: date.toISOString()
+});
+
+const serializedShapeOfError = (err, recurse) => ({
+  __type: 'Error',
+  name: err.name,
+  message: err.message,
+  stack: err.stack,
+  cause: err.cause ? recurse(err.cause) : undefined
+});
+
+const serializedShapeOfRegExp = (re) => ({
+  __type: 'RegExp',
+  source: re.source,
+  flags: re.flags
+});
+
+const serializedShapeOfFunction = (fn) => ({
+  __type: 'Function',
+  name: fn.name || 'anonymous',
+  length: fn.length,
+  toString: `${fn.toString().substring(0, MAX_STRING_SNIPPET_LENGTH)}...`
+});
+
+const serializedShapeOfUnknown = (obj) => ({
+  __type: 'Unknown',
+  constructor: obj.constructor ? obj.constructor.name : 'Unknown',
+  toString: `${String(obj).substring(0, MAX_STRING_SNIPPET_LENGTH)}...`
+});
+
+const restoreDate = (obj) => new Date(obj.value);
+const restoreError = (obj, recurse) => {
+  const err = new Error(obj.message);
+  err.name = obj.name;
+  err.stack = obj.stack;
+  if (obj.cause) err.cause = recurse(obj.cause);
+  return err;
+};
+const restoreRegExp = (obj) => new RegExp(obj.source, obj.flags);
+const restoreFunction = (obj) => `[Function: ${obj.name}]`;
+
+/**
+ * RobustSerializer - Robust serialization with circular references.
+ * Composes pure type-specific fragments; state (seen, circularRefs) only in arrays/objects.
  */
 class RobustSerializer {
   constructor() {
@@ -397,27 +462,14 @@ class RobustSerializer {
     this.refCounter = 0;
   }
 
-  /**
-     * Serializa un objeto de forma segura, manejando referencias circulares
-     * @param {any} obj - Objeto a serializar
-     * @returns {string} JSON string seguro
-     */
   serialize(obj) {
     try {
-      // Reset state
       this.seen = new WeakSet();
       this.circularRefs = new Map();
       this.refCounter = 0;
-
-      // Serializar con manejo de referencias circulares
-      const safeObj = this.makeSerializable(obj);
-            
-      // Convertir a JSON
-      return JSON.stringify(safeObj);
+      return JSON.stringify(this.makeSerializable(obj));
     } catch (error) {
-      console.error('SyntropyFront: Error en serialización robusta:', error);
-            
-      // Fallback: intentar serialización básica con información de error
+      console.error('SyntropyFront: Error in robust serialization:', error);
       return JSON.stringify({
         __serializationError: true,
         error: error.message,
@@ -428,253 +480,141 @@ class RobustSerializer {
     }
   }
 
-  /**
-     * Hace un objeto serializable, manejando referencias circulares
-     * @param {any} obj - Objeto a procesar
-     * @param {string} path - Ruta actual en el objeto
-     * @returns {any} Objeto serializable
-     */
-  makeSerializable(obj, path = '') {
-    // Casos primitivos
-    if (obj === null || obj === undefined) {
-      return obj;
-    }
-
-    if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean') {
-      return obj;
-    }
-
-    // Casos especiales
-    if (obj instanceof Date) {
-      return {
-        __type: 'Date',
-        value: obj.toISOString()
-      };
-    }
-
+  _serializeKnownType(obj, path) {
+    if (obj === null || obj === undefined) return obj;
+    if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean') return obj;
+    if (obj instanceof Date) return serializedShapeOfDate(obj);
     if (obj instanceof Error) {
-      return {
-        __type: 'Error',
-        name: obj.name,
-        message: obj.message,
-        stack: obj.stack,
-        cause: obj.cause ? this.makeSerializable(obj.cause, `${path}.cause`) : undefined
-      };
-    }
-
-    if (obj instanceof RegExp) {
-      return {
-        __type: 'RegExp',
-        source: obj.source,
-        flags: obj.flags
-      };
+      return serializedShapeOfError(obj, (x) => this.makeSerializable(x, `${path}.cause`));
     }
+    if (obj instanceof RegExp) return serializedShapeOfRegExp(obj);
+    if (typeof obj === 'function') return serializedShapeOfFunction(obj);
+    return undefined;
+  }
 
-    // Arrays
-    if (Array.isArray(obj)) {
-      // Verificar referencia circular
-      if (this.seen.has(obj)) {
-        const refId = this.circularRefs.get(obj);
-        return {
-          __circular: true,
-          refId
-        };
-      }
+  makeSerializable(obj, path = '') {
+    if (obj === null || obj === undefined) return obj;
+    const known = this._serializeKnownType(obj, path);
+    if (known !== undefined) return known;
+    if (Array.isArray(obj)) return this._serializeArray(obj, path);
+    if (typeof obj === 'object') return this._serializeObject(obj, path);
+    return serializedShapeOfUnknown(obj);
+  }
 
-      this.seen.add(obj);
-      const refId = `ref_${++this.refCounter}`;
-      this.circularRefs.set(obj, refId);
+  _serializeArray(obj, path) {
+    if (this.seen.has(obj)) return { __circular: true, refId: this.circularRefs.get(obj) };
+    this.seen.add(obj);
+    this.circularRefs.set(obj, `ref_${++this.refCounter}`);
+    return obj.map((item, i) => this.makeSerializable(item, `${path}[${i}]`));
+  }
 
-      return obj.map((item, index) => 
-        this.makeSerializable(item, `${path}[${index}]`)
-      );
+  _serializeObjectKey(result, obj, key, path) {
+    try {
+      result[key] = this.makeSerializable(obj[key], `${path}.${key}`);
+    } catch (error) {
+      result[key] = {
+        __serializationError: true,
+        error: error.message,
+        propertyName: key
+      };
     }
+  }
 
-    // Objetos
-    if (typeof obj === 'object') {
-      // Verificar referencia circular
-      if (this.seen.has(obj)) {
-        const refId = this.circularRefs.get(obj);
-        return {
-          __circular: true,
-          refId
+  _serializeObjectSymbols(obj, path, result) {
+    if (!Object.getOwnPropertySymbols) return;
+    const symbols = Object.getOwnPropertySymbols(obj);
+    for (const symbol of symbols) {
+      const symKey = `__symbol_${symbol.description || 'anonymous'}`;
+      try {
+        result[symKey] = this.makeSerializable(obj[symbol], `${path}[Symbol]`);
+      } catch (error) {
+        result[symKey] = {
+          __serializationError: true,
+          error: error.message,
+          symbolName: symbol.description || 'anonymous'
         };
       }
-
-      this.seen.add(obj);
-      const refId = `ref_${++this.refCounter}`;
-      this.circularRefs.set(obj, refId);
-
-      const result = {};
-
-      // Procesar propiedades del objeto
-      for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-          try {
-            const value = obj[key];
-            const safeValue = this.makeSerializable(value, `${path}.${key}`);
-            result[key] = safeValue;
-          } catch (error) {
-            // Si falla la serialización de una propiedad, la omitimos
-            result[key] = {
-              __serializationError: true,
-              error: error.message,
-              propertyName: key
-            };
-          }
-        }
-      }
-
-      // Procesar símbolos si están disponibles
-      if (Object.getOwnPropertySymbols) {
-        const symbols = Object.getOwnPropertySymbols(obj);
-        for (const symbol of symbols) {
-          try {
-            const value = obj[symbol];
-            const safeValue = this.makeSerializable(value, `${path}[Symbol(${symbol.description})]`);
-            result[`__symbol_${symbol.description || 'anonymous'}`] = safeValue;
-          } catch (error) {
-            result[`__symbol_${symbol.description || 'anonymous'}`] = {
-              __serializationError: true,
-              error: error.message,
-              symbolName: symbol.description || 'anonymous'
-            };
-          }
-        }
-      }
-
-      return result;
     }
+  }
 
-    // Funciones y otros tipos
-    if (typeof obj === 'function') {
-      return {
-        __type: 'Function',
-        name: obj.name || 'anonymous',
-        length: obj.length,
-        toString: `${obj.toString().substring(0, 200)  }...`
-      };
+  _serializeObject(obj, path) {
+    if (this.seen.has(obj)) return { __circular: true, refId: this.circularRefs.get(obj) };
+    this.seen.add(obj);
+    this.circularRefs.set(obj, `ref_${++this.refCounter}`);
+    const result = {};
+    for (const key in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+      this._serializeObjectKey(result, obj, key, path);
     }
-
-    // Fallback para otros tipos
-    return {
-      __type: 'Unknown',
-      constructor: obj.constructor ? obj.constructor.name : 'Unknown',
-      toString: `${String(obj).substring(0, 200)  }...`
-    };
+    this._serializeObjectSymbols(obj, path, result);
+    return result;
   }
 
   /**
-     * Deserializa un objeto serializado con referencias circulares
-     * @param {string} jsonString - JSON string a deserializar
-     * @returns {any} Objeto deserializado
+     * Deserializes a serialized object with circular references
+     * @param {string} jsonString - JSON string to deserialize
+     * @returns {any} Deserialized object
      */
   deserialize(jsonString) {
     try {
       const parsed = JSON.parse(jsonString);
       return this.restoreCircularRefs(parsed);
     } catch (error) {
-      console.error('SyntropyFront: Error en deserialización:', error);
+      console.error('SyntropyFront: Error in deserialization:', error);
       return null;
     }
   }
 
-  /**
-     * Restaura referencias circulares en un objeto deserializado
-     * @param {any} obj - Objeto a restaurar
-     * @param {Map} refs - Mapa de referencias
-     * @returns {any} Objeto con referencias restauradas
-     */
-  restoreCircularRefs(obj, refs = new Map()) {
-    if (obj === null || obj === undefined) {
-      return obj;
-    }
-
-    if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean') {
-      return obj;
-    }
-
-    // Restaurar tipos especiales
-    if (obj.__type === 'Date') {
-      return new Date(obj.value);
-    }
-
-    if (obj.__type === 'Error') {
-      const error = new Error(obj.message);
-      error.name = obj.name;
-      error.stack = obj.stack;
-      if (obj.cause) {
-        error.cause = this.restoreCircularRefs(obj.cause, refs);
-      }
-      return error;
-    }
-
-    if (obj.__type === 'RegExp') {
-      return new RegExp(obj.source, obj.flags);
-    }
-
-    if (obj.__type === 'Function') {
-      // No podemos restaurar funciones completamente, devolvemos info
-      return `[Function: ${obj.name}]`;
-    }
+  _restoreKnownType(obj, refs) {
+    if (obj === null || obj === undefined) return obj;
+    if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean') return obj;
+    if (obj.__type === 'Date') return restoreDate(obj);
+    if (obj.__type === 'Error') return restoreError(obj, (x) => this.restoreCircularRefs(x, refs));
+    if (obj.__type === 'RegExp') return restoreRegExp(obj);
+    if (obj.__type === 'Function') return restoreFunction(obj);
+    return undefined;
+  }
 
-    // Arrays
-    if (Array.isArray(obj)) {
-      const result = [];
-      refs.set(obj, result);
+  restoreCircularRefs(obj, refs = new Map()) {
+    const known = this._restoreKnownType(obj, refs);
+    if (known !== undefined) return known;
+    if (Array.isArray(obj)) return this._restoreArray(obj, refs);
+    if (typeof obj === 'object') return this._restoreObject(obj, refs);
+    return obj;
+  }
 
-      for (let i = 0; i < obj.length; i++) {
-        if (obj[i] && obj[i].__circular) {
-          const refId = obj[i].refId;
-          if (refs.has(refId)) {
-            result[i] = refs.get(refId);
-          } else {
-            result[i] = null; // Referencia no encontrada
-          }
-        } else {
-          result[i] = this.restoreCircularRefs(obj[i], refs);
-        }
+  _restoreArray(obj, refs) {
+    const result = [];
+    refs.set(obj, result);
+    for (let i = 0; i < obj.length; i++) {
+      if (obj[i]?.__circular) {
+        result[i] = refs.has(obj[i].refId) ? refs.get(obj[i].refId) : null;
+      } else {
+        result[i] = this.restoreCircularRefs(obj[i], refs);
       }
-
-      return result;
     }
+    return result;
+  }
 
-    // Objetos
-    if (typeof obj === 'object') {
-      const result = {};
-      refs.set(obj, result);
-
-      for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-          if (key.startsWith('__')) {
-            // Propiedades especiales
-            continue;
-          }
-
-          const value = obj[key];
-          if (value && value.__circular) {
-            const refId = value.refId;
-            if (refs.has(refId)) {
-              result[key] = refs.get(refId);
-            } else {
-              result[key] = null; // Referencia no encontrada
-            }
-          } else {
-            result[key] = this.restoreCircularRefs(value, refs);
-          }
-        }
+  _restoreObject(obj, refs) {
+    const result = {};
+    refs.set(obj, result);
+    for (const key in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, key) || key.startsWith('__')) continue;
+      const value = obj[key];
+      if (value?.__circular) {
+        result[key] = refs.has(value.refId) ? refs.get(value.refId) : null;
+      } else {
+        result[key] = this.restoreCircularRefs(value, refs);
       }
-
-      return result;
     }
-
-    return obj;
+    return result;
   }
 
   /**
-     * Serializa de forma segura para logging (versión simplificada)
-     * @param {any} obj - Objeto a serializar
-     * @returns {string} JSON string seguro para logs
+     * Safely serializes for logging (simplified version)
+     * @param {any} obj - Object to serialize
+     * @returns {string} Safe JSON string for logs
      */
   serializeForLogging(obj) {
     try {
@@ -682,7 +622,7 @@ class RobustSerializer {
     } catch (error) {
       return JSON.stringify({
         __logError: true,
-        message: 'Error serializando para logging',
+        message: 'Error serializing for logging',
         originalError: error.message,
         timestamp: new Date().toISOString()
       });
@@ -690,42 +630,45 @@ class RobustSerializer {
   }
 }
 
-// Instancia singleton
+// Singleton instance
 const robustSerializer = new RobustSerializer();
 
 /**
- * HttpTransport - Maneja el envío HTTP
- * Responsabilidad única: Gestionar envío HTTP y serialización
+ * HttpTransport - HTTP send to the backend.
+ * Contract: send(items) serializes and POSTs; applyEncryption(data) applies config.encrypt if present; isConfigured() by endpoint.
  */
 class HttpTransport {
+  /** @param {{ endpoint: string|null, headers: Object, encrypt?: function }} configManager */
   constructor(configManager) {
     this.config = configManager;
   }
 
   /**
-     * Envía datos al backend
-     * @param {Array} items - Items a enviar
-     */
+   * Serializes items, applies encrypt if configured, POSTs to endpoint.
+   * @param {Array<Object>} items - Items to send
+   * @returns {Promise<Object>} response.json()
+   * @throws {Error} If HTTP !ok or network failure
+   */
   async send(items) {
     const payload = {
       timestamp: new Date().toISOString(),
       items
     };
 
-    // ✅ SERIALIZACIÓN ROBUSTA: Usar serializador que maneja referencias circulares
+    // ✅ ROBUST SERIALIZATION: Use serializer that handles circular references
     let serializedPayload;
     try {
       serializedPayload = robustSerializer.serialize(payload);
     } catch (error) {
-      console.error('SyntropyFront: Error en serialización del payload:', error);
-            
-      // Fallback: intentar serialización básica con información de error
+      console.error('SyntropyFront: Error in payload serialization:', error);
+
+      // Fallback: attempt basic serialization with error info
       serializedPayload = JSON.stringify({
         __serializationError: true,
         error: error.message,
         timestamp: new Date().toISOString(),
         itemsCount: items.length,
-        fallbackData: 'Serialización falló, datos no enviados'
+        fallbackData: 'Serialization failed, data not sent'
       });
     }
 
@@ -743,9 +686,10 @@ class HttpTransport {
   }
 
   /**
-     * Aplica encriptación si está configurada
-     * @param {*} data - Datos a encriptar
-     */
+   * Applies encryption if configured.
+   * @param {*} data - Data to encrypt
+   * @returns {*} Encrypted data or unchanged
+   */
   applyEncryption(data) {
     if (this.config.encrypt) {
       return this.config.encrypt(data);
@@ -753,17 +697,15 @@ class HttpTransport {
     return data;
   }
 
-  /**
-     * Verifica si el transport está configurado
-     */
+  /** @returns {boolean} */
   isConfigured() {
     return !!this.config.endpoint;
   }
 }
 
 /**
- * DatabaseConfigManager - Maneja la configuración de IndexedDB
- * Responsabilidad única: Validar y gestionar la configuración de la base de datos
+ * DatabaseConfigManager - Handles IndexedDB configuration
+ * Single responsibility: Validate and manage database configuration
  */
 class DatabaseConfigManager {
   constructor(dbName, dbVersion, storeName) {
@@ -773,9 +715,9 @@ class DatabaseConfigManager {
   }
 
   /**
-     * Valida que la configuración sea correcta
-     * @returns {Object} Resultado de validación
-     */
+   * Validates that the configuration is correct
+   * @returns {Object} Validation result
+   */
   validateConfig() {
     const validationResult = {
       isValid: true,
@@ -785,26 +727,26 @@ class DatabaseConfigManager {
 
     if (!this.dbName || typeof this.dbName !== 'string') {
       validationResult.isValid = false;
-      validationResult.errors.push('dbName debe ser un string no vacío');
+      validationResult.errors.push('dbName must be a non-empty string');
     }
 
     if (!this.dbVersion || typeof this.dbVersion !== 'number' || this.dbVersion < 1) {
       validationResult.isValid = false;
-      validationResult.errors.push('dbVersion debe ser un número mayor a 0');
+      validationResult.errors.push('dbVersion must be a number greater than 0');
     }
 
     if (!this.storeName || typeof this.storeName !== 'string') {
       validationResult.isValid = false;
-      validationResult.errors.push('storeName debe ser un string no vacío');
+      validationResult.errors.push('storeName must be a non-empty string');
     }
 
     return validationResult;
   }
 
   /**
-     * Verifica si IndexedDB está disponible en el entorno
-     * @returns {Object} Resultado de disponibilidad
-     */
+   * Checks if IndexedDB is available in the environment
+   * @returns {Object} Availability result
+   */
   checkIndexedDBAvailability() {
     const availabilityResult = {
       isAvailable: false,
@@ -813,12 +755,12 @@ class DatabaseConfigManager {
     };
 
     if (typeof window === 'undefined') {
-      availabilityResult.reason = 'No estamos en un entorno de browser';
+      availabilityResult.reason = 'Not in a browser environment';
       return availabilityResult;
     }
 
     if (!window.indexedDB) {
-      availabilityResult.reason = 'IndexedDB no está disponible en este browser';
+      availabilityResult.reason = 'IndexedDB is not available in this browser';
       return availabilityResult;
     }
 
@@ -827,9 +769,9 @@ class DatabaseConfigManager {
   }
 
   /**
-     * Obtiene la configuración actual
-     * @returns {Object} Configuración
-     */
+   * Returns the current configuration
+   * @returns {Object} Configuration
+   */
   getConfig() {
     return {
       dbName: this.dbName,
@@ -839,9 +781,9 @@ class DatabaseConfigManager {
   }
 
   /**
-     * Crea la configuración del object store
-     * @returns {Object} Configuración del store
-     */
+   * Returns the object store configuration
+   * @returns {Object} Store configuration
+   */
   getStoreConfig() {
     return {
       keyPath: 'id',
@@ -851,8 +793,8 @@ class DatabaseConfigManager {
 }
 
 /**
- * DatabaseConnectionManager - Maneja la conexión con IndexedDB
- * Responsabilidad única: Gestionar la apertura y cierre de conexiones
+ * DatabaseConnectionManager - Handles IndexedDB connection.
+ * Single responsibility: Manage opening and closing of connections. Uses guard clauses (return early).
  */
 class DatabaseConnectionManager {
   constructor(configManager) {
@@ -862,53 +804,55 @@ class DatabaseConnectionManager {
   }
 
   /**
-     * Inicializa la conexión con IndexedDB
-     * @returns {Promise<Object>} Resultado de la inicialización
-     */
+   * Initializes the connection to IndexedDB
+   * @returns {Promise<Object>} Init result
+   */
   async init() {
-    const initResult = {
-      success: false,
-      error: null,
-      timestamp: new Date().toISOString()
-    };
-
-    try {
-      // Validar configuración
-      const configValidation = this.configManager.validateConfig();
-      if (!configValidation.isValid) {
-        initResult.error = `Configuración inválida: ${configValidation.errors.join(', ')}`;
-        return initResult;
-      }
+    // Guard: validate configuration
+    const configValidation = this.configManager.validateConfig();
+    if (!configValidation.isValid) {
+      return {
+        success: false,
+        error: `Invalid configuration: ${configValidation.errors.join(', ')}`,
+        timestamp: new Date().toISOString()
+      };
+    }
 
-      // Verificar disponibilidad de IndexedDB
-      const availabilityCheck = this.configManager.checkIndexedDBAvailability();
-      if (!availabilityCheck.isAvailable) {
-        initResult.error = availabilityCheck.reason;
-        return initResult;
-      }
+    const availabilityCheck = this.configManager.checkIndexedDBAvailability();
+    if (!availabilityCheck.isAvailable) {
+      return {
+        success: false,
+        error: availabilityCheck.reason,
+        timestamp: new Date().toISOString()
+      };
+    }
 
-      // Abrir conexión
+    try {
       const connectionResult = await this.openConnection();
       if (!connectionResult.success) {
-        initResult.error = connectionResult.error;
-        return initResult;
+        return {
+          success: false,
+          error: connectionResult.error,
+          timestamp: new Date().toISOString()
+        };
       }
 
       this.db = connectionResult.db;
       this.isAvailable = true;
-      initResult.success = true;
 
-      return initResult;
+      return { success: true, error: null, timestamp: new Date().toISOString() };
     } catch (error) {
-      initResult.error = `Error inesperado: ${error.message}`;
-      return initResult;
+      return {
+        success: false,
+        error: `Unexpected error: ${error.message}`,
+        timestamp: new Date().toISOString()
+      };
     }
   }
 
   /**
-     * Abre la conexión con IndexedDB
-     * @returns {Promise<Object>} Resultado de la conexión
-     */
+   * Opens the connection to IndexedDB
+   */
   openConnection() {
     return new Promise((resolve) => {
       const config = this.configManager.getConfig();
@@ -917,7 +861,7 @@ class DatabaseConnectionManager {
       request.onerror = () => {
         resolve({
           success: false,
-          error: 'Error abriendo IndexedDB',
+          error: 'Error opening IndexedDB',
           db: null
         });
       };
@@ -925,7 +869,7 @@ class DatabaseConnectionManager {
       request.onupgradeneeded = (event) => {
         const db = event.target.result;
         const storeConfig = this.configManager.getStoreConfig();
-                
+
         if (!db.objectStoreNames.contains(config.storeName)) {
           db.createObjectStore(config.storeName, storeConfig);
         }
@@ -942,52 +886,42 @@ class DatabaseConnectionManager {
   }
 
   /**
-     * Cierra la conexión con la base de datos
-     * @returns {Object} Resultado del cierre
-     */
+   * Closes the database connection
+   */
   close() {
-    const closeResult = {
-      success: false,
-      error: null,
-      timestamp: new Date().toISOString()
-    };
+    // Guard: no active connection
+    if (!this.db) {
+      return { success: false, error: 'No active connection to close', timestamp: new Date().toISOString() };
+    }
 
     try {
-      if (this.db) {
-        this.db.close();
-        this.db = null;
-        this.isAvailable = false;
-        closeResult.success = true;
-      } else {
-        closeResult.error = 'No hay conexión activa para cerrar';
-      }
+      this.db.close();
+      this.db = null;
+      this.isAvailable = false;
+      return { success: true, error: null, timestamp: new Date().toISOString() };
     } catch (error) {
-      closeResult.error = `Error cerrando conexión: ${error.message}`;
+      return { success: false, error: `Error closing connection: ${error.message}`, timestamp: new Date().toISOString() };
     }
-
-    return closeResult;
   }
 
   /**
-     * Verifica si la base de datos está disponible
-     * @returns {boolean} True si está disponible
-     */
+   * Returns whether the database is available
+   */
   isDatabaseAvailable() {
     return this.isAvailable && this.db !== null;
   }
 
   /**
-     * Obtiene la instancia de la base de datos
-     * @returns {IDBDatabase|null} Instancia de la base de datos
-     */
+   * Returns the database instance
+   */
   getDatabase() {
     return this.isDatabaseAvailable() ? this.db : null;
   }
 }
 
 /**
- * DatabaseTransactionManager - Maneja las transacciones de IndexedDB
- * Responsabilidad única: Gestionar transacciones de lectura y escritura
+ * DatabaseTransactionManager - Handles IndexedDB transactions
+ * Single responsibility: Manage read and write transactions
  */
 class DatabaseTransactionManager {
   constructor(connectionManager, configManager) {
@@ -996,10 +930,10 @@ class DatabaseTransactionManager {
   }
 
   /**
-     * Obtiene una transacción de lectura
-     * @returns {IDBTransaction} Transacción de lectura
-     * @throws {Error} Si la base de datos no está disponible
-     */
+   * Returns a read transaction
+   * @returns {IDBTransaction} Read transaction
+   * @throws {Error} If the database is not available
+   */
   getReadTransaction() {
     this.ensureDatabaseAvailable();
         
@@ -1010,10 +944,10 @@ class DatabaseTransactionManager {
   }
 
   /**
-     * Obtiene una transacción de escritura
-     * @returns {IDBTransaction} Transacción de escritura
-     * @throws {Error} Si la base de datos no está disponible
-     */
+   * Returns a write transaction
+   * @returns {IDBTransaction} Write transaction
+   * @throws {Error} If the database is not available
+   */
   getWriteTransaction() {
     this.ensureDatabaseAvailable();
         
@@ -1024,20 +958,20 @@ class DatabaseTransactionManager {
   }
 
   /**
-     * Obtiene el object store para una transacción
-     * @param {IDBTransaction} transaction - Transacción activa
-     * @returns {IDBObjectStore} Object store
-     */
+   * Returns the object store for a transaction
+   * @param {IDBTransaction} transaction - Active transaction
+   * @returns {IDBObjectStore} Object store
+   */
   getObjectStore(transaction) {
     const config = this.configManager.getConfig();
     return transaction.objectStore(config.storeName);
   }
 
   /**
-     * Ejecuta una operación de lectura de manera segura
-     * @param {Function} operation - Operación a ejecutar
-     * @returns {Promise<Object>} Resultado de la operación
-     */
+   * Executes a read operation safely
+   * @param {Function} operation - Operation to execute
+   * @returns {Promise<Object>} Operation result
+   */
   async executeReadOperation(operation) {
     const operationResult = {
       success: false,
@@ -1057,16 +991,16 @@ class DatabaseTransactionManager {
             
       return operationResult;
     } catch (error) {
-      operationResult.error = `Error en operación de lectura: ${error.message}`;
+      operationResult.error = `Error in read operation: ${error.message}`;
       return operationResult;
     }
   }
 
   /**
-     * Ejecuta una operación de escritura de manera segura
-     * @param {Function} operation - Operación a ejecutar
-     * @returns {Promise<Object>} Resultado de la operación
-     */
+   * Executes a write operation safely
+   * @param {Function} operation - Operation to execute
+   * @returns {Promise<Object>} Operation result
+   */
   async executeWriteOperation(operation) {
     const operationResult = {
       success: false,
@@ -1086,15 +1020,15 @@ class DatabaseTransactionManager {
             
       return operationResult;
     } catch (error) {
-      operationResult.error = `Error en operación de escritura: ${error.message}`;
+      operationResult.error = `Error in write operation: ${error.message}`;
       return operationResult;
     }
   }
 
   /**
-     * Verifica que la base de datos esté disponible
-     * @throws {Error} Si la base de datos no está disponible
-     */
+   * Ensures the database is available
+   * @throws {Error} If the database is not available
+   */
   ensureDatabaseAvailable() {
     if (!this.connectionManager.isDatabaseAvailable()) {
       throw new Error('Database not available');
@@ -1102,9 +1036,9 @@ class DatabaseTransactionManager {
   }
 
   /**
-     * Obtiene información sobre el estado de las transacciones
-     * @returns {Object} Estado de las transacciones
-     */
+   * Returns transaction status information
+   * @returns {Object} Transaction status
+   */
   getTransactionStatus() {
     return {
       isDatabaseAvailable: this.connectionManager.isDatabaseAvailable(),
@@ -1115,8 +1049,8 @@ class DatabaseTransactionManager {
 }
 
 /**
- * DatabaseManager - Coordinador de la gestión de IndexedDB
- * Responsabilidad única: Coordinar los managers especializados
+ * DatabaseManager - Coordinates IndexedDB access.
+ * Single responsibility: Coordinate specialized managers. Uses guard clauses.
  */
 class DatabaseManager {
   constructor(dbName, dbVersion, storeName) {
@@ -1126,56 +1060,57 @@ class DatabaseManager {
   }
 
   /**
-     * Inicializa la conexión con IndexedDB
-     */
+   * Initializes the connection to IndexedDB
+   */
   async init() {
     const initResult = await this.connectionManager.init();
-        
-    if (initResult.success) {
-      console.log('SyntropyFront: Base de datos inicializada');
-    } else {
-      console.warn('SyntropyFront: Error inicializando base de datos:', initResult.error);
+
+    if (!initResult.success) {
+      console.warn('SyntropyFront: Error initializing database:', initResult.error);
+      return false;
     }
-        
-    return initResult.success;
+
+    console.log('SyntropyFront: Database initialized');
+    return true;
   }
 
   /**
-     * Obtiene una transacción de lectura
-     */
+   * Returns a read transaction
+   */
   getReadTransaction() {
     return this.transactionManager.getReadTransaction();
   }
 
   /**
-     * Obtiene una transacción de escritura
-     */
+   * Returns a write transaction
+   */
   getWriteTransaction() {
     return this.transactionManager.getWriteTransaction();
   }
 
   /**
-     * Cierra la conexión con la base de datos
-     */
+   * Closes the database connection
+   */
   close() {
     const closeResult = this.connectionManager.close();
-        
+
     if (!closeResult.success) {
-      console.warn('SyntropyFront: Error cerrando base de datos:', closeResult.error);
+      console.warn('SyntropyFront: Error closing database:', closeResult.error);
+      return false;
     }
-        
-    return closeResult.success;
+
+    return true;
   }
 
   /**
-     * Verifica si la base de datos está disponible
-     */
+   * Returns whether the database is available
+   */
   isDatabaseAvailable() {
     return this.connectionManager.isDatabaseAvailable();
   }
 
-  // ===== Propiedades de compatibilidad =====
-    
+  // ===== Compatibility properties =====
+
   /**
      * @deprecated Usar configManager.getConfig().dbName
      */
@@ -1213,8 +1148,8 @@ class DatabaseManager {
 }
 
 /**
- * StorageManager - Maneja las operaciones CRUD de IndexedDB
- * Responsabilidad única: Gestionar operaciones de almacenamiento y recuperación
+ * StorageManager - Handles IndexedDB CRUD operations
+ * Single responsibility: Manage storage and retrieval operations
  */
 class StorageManager {
   constructor(databaseManager, serializationManager) {
@@ -1223,10 +1158,10 @@ class StorageManager {
   }
 
   /**
-     * Guarda items en el almacenamiento
-     * @param {Array} items - Items a guardar
-     * @returns {Promise<number>} ID del item guardado
-     */
+   * Saves items to storage
+   * @param {Array} items - Items to save
+   * @returns {Promise<number>} Saved item ID
+   */
   async save(items) {
     this.ensureDatabaseAvailable();
 
@@ -1244,9 +1179,9 @@ class StorageManager {
   }
 
   /**
-     * Obtiene todos los items del almacenamiento
-     * @returns {Promise<Array>} Items deserializados
-     */
+   * Retrieves all items from storage
+   * @returns {Promise<Array>} Deserialized items
+   */
   async retrieve() {
     if (!this.databaseManager.isDatabaseAvailable()) {
       return [];
@@ -1257,10 +1192,10 @@ class StorageManager {
   }
 
   /**
-     * Obtiene un item específico por ID
-     * @param {number} id - ID del item
-     * @returns {Promise<Object|null>} Item deserializado o null
-     */
+   * Retrieves a single item by ID
+   * @param {number} id - Item ID
+   * @returns {Promise<Object|null>} Deserialized item or null
+   */
   async retrieveById(id) {
     if (!this.databaseManager.isDatabaseAvailable()) {
       return null;
@@ -1271,21 +1206,21 @@ class StorageManager {
   }
 
   /**
-     * Remueve un item del almacenamiento
-     * @param {number} id - ID del item a remover
-     * @returns {Promise<void>}
-     */
+   * Removes an item from storage
+   * @param {number} id - ID of the item to remove
+   * @returns {Promise<void>}
+   */
   async remove(id) {
     this.ensureDatabaseAvailable();
     return this.executeWriteOperation(store => store.delete(id));
   }
 
   /**
-     * Actualiza un item en el almacenamiento
-     * @param {number} id - ID del item
-     * @param {Object} updates - Campos a actualizar
-     * @returns {Promise<number>} ID del item actualizado
-     */
+   * Updates an item in storage
+   * @param {number} id - Item ID
+   * @param {Object} updates - Fields to update
+   * @returns {Promise<number>} Updated item ID
+   */
   async update(id, updates) {
     this.ensureDatabaseAvailable();
 
@@ -1299,20 +1234,20 @@ class StorageManager {
   }
 
   /**
-     * Limpia todo el almacenamiento
-     * @returns {Promise<void>}
-     */
+   * Clears all storage
+   * @returns {Promise<void>}
+   */
   async clear() {
     this.ensureDatabaseAvailable();
     return this.executeWriteOperation(store => store.clear());
   }
 
-  // ===== Métodos privados declarativos =====
+  // ===== Private declarative methods =====
 
   /**
-     * Verifica que la base de datos esté disponible
-     * @throws {Error} Si la base de datos no está disponible
-     */
+   * Ensures the database is available
+   * @throws {Error} If the database is not available
+   */
   ensureDatabaseAvailable() {
     if (!this.databaseManager.isDatabaseAvailable()) {
       throw new Error('Database not available');
@@ -1320,10 +1255,10 @@ class StorageManager {
   }
 
   /**
-     * Ejecuta una operación de lectura de manera declarativa
-     * @param {Function} operation - Operación a ejecutar en el store
-     * @returns {Promise<*>} Resultado de la operación
-     */
+   * Executes a read operation in a declarative way
+   * @param {Function} operation - Operation to run on the store
+   * @returns {Promise<*>} Operation result
+   */
   executeReadOperation(operation) {
     return new Promise((resolve, reject) => {
       try {
@@ -1340,10 +1275,10 @@ class StorageManager {
   }
 
   /**
-     * Ejecuta una operación de escritura de manera declarativa
-     * @param {Function} operation - Operación a ejecutar en el store
-     * @returns {Promise<*>} Resultado de la operación
-     */
+   * Executes a write operation in a declarative way
+   * @param {Function} operation - Operation to run on the store
+   * @returns {Promise<*>} Operation result
+   */
   executeWriteOperation(operation) {
     return new Promise((resolve, reject) => {
       try {
@@ -1360,19 +1295,19 @@ class StorageManager {
   }
 
   /**
-     * Deserializa un array de items
-     * @param {Array} rawItems - Items crudos de la base de datos
-     * @returns {Array} Items deserializados
-     */
+   * Deserializes an array of items
+   * @param {Array} rawItems - Raw items from the database
+   * @returns {Array} Deserialized items
+   */
   deserializeItems(rawItems) {
     return rawItems.map(item => this.deserializeItem(item));
   }
 
   /**
-     * Deserializa un item individual
-     * @param {Object} rawItem - Item crudo de la base de datos
-     * @returns {Object} Item deserializado
-     */
+   * Deserializes a single item
+   * @param {Object} rawItem - Raw item from the database
+   * @returns {Object} Deserialized item
+   */
   deserializeItem(rawItem) {
     const deserializationResult = this.serializationManager.deserialize(rawItem.items);
     const deserializedItems = this.serializationManager.getData(deserializationResult, []);
@@ -1386,8 +1321,8 @@ class StorageManager {
 }
 
 /**
- * RetryLogicManager - Maneja la lógica de reintentos y limpieza
- * Responsabilidad única: Gestionar reintentos y limpieza de items fallidos
+ * RetryLogicManager - Handles retry logic and cleanup
+ * Single responsibility: Manage retries and cleanup of failed items
  */
 class RetryLogicManager {
   constructor(storageManager, configManager) {
@@ -1396,13 +1331,13 @@ class RetryLogicManager {
   }
 
   /**
-     * Intenta enviar items fallidos del buffer persistente
-     * @param {Function} sendCallback - Callback para enviar items
-     * @param {Function} removeCallback - Callback para remover items exitosos
+     * Attempts to send failed items from the persistent buffer
+     * @param {Function} sendCallback - Callback to send items
+     * @param {Function} removeCallback - Callback to remove successful items
      */
   async retryFailedItems(sendCallback, removeCallback) {
     if (!this.storageManager) {
-      console.warn('SyntropyFront: Storage manager no disponible');
+      console.warn('SyntropyFront: Storage manager not available');
       return;
     }
 
@@ -1411,7 +1346,7 @@ class RetryLogicManager {
             
       for (const item of failedItems) {
         if (item.retryCount < this.config.maxRetries) {
-          // Deserializar items del buffer
+          // Deserialize items from buffer
           let deserializedItems;
           try {
             if (typeof item.items === 'string') {
@@ -1420,7 +1355,7 @@ class RetryLogicManager {
               deserializedItems = item.items;
             }
           } catch (error) {
-            console.error('SyntropyFront: Error deserializando items del buffer:', error);
+            console.error('SyntropyFront: Error deserializing buffer items:', error);
             await this.removeFailedItem(item.id);
             continue;
           }
@@ -1429,35 +1364,35 @@ class RetryLogicManager {
             try {
               await sendCallback(deserializedItems, item.retryCount + 1, item.id);
                             
-              // Si el envío fue exitoso, remover del buffer
+              // On successful send, remove from buffer
               if (removeCallback) {
                 await removeCallback(item.id);
               } else {
                 await this.removeFailedItem(item.id);
               }
                             
-              console.log(`SyntropyFront: Reintento exitoso para item ${item.id}`);
+              console.log(`SyntropyFront: Retry successful for item ${item.id}`);
             } catch (error) {
-              console.warn(`SyntropyFront: Reintento falló para item ${item.id}:`, error);
+              console.warn(`SyntropyFront: Retry failed for item ${item.id}:`, error);
                             
-              // Incrementar contador de reintentos
+              // Increment retry count
               await this.incrementRetryCount(item.id);
             }
           }
         } else {
-          console.warn(`SyntropyFront: Item ${item.id} excedió máximo de reintentos, removiendo del buffer`);
+          console.warn(`SyntropyFront: Item ${item.id} exceeded maximum retries, removing from buffer`);
           await this.removeFailedItem(item.id);
         }
       }
     } catch (error) {
-      console.error('SyntropyFront: Error procesando reintentos:', error);
+      console.error('SyntropyFront: Error processing retries:', error);
     }
   }
 
   /**
-     * Incrementa el contador de reintentos de un item
-     * @param {number} id - ID del item
-     */
+   * Increments the retry count for an item
+   * @param {number} id - Item ID
+   */
   async incrementRetryCount(id) {
     try {
       const currentItem = await this.storageManager.retrieveById(id);
@@ -1467,25 +1402,25 @@ class RetryLogicManager {
         });
       }
     } catch (error) {
-      console.error('SyntropyFront: Error incrementando contador de reintentos:', error);
+      console.error('SyntropyFront: Error incrementing retry count:', error);
     }
   }
 
   /**
-     * Remueve un item fallido del buffer
-     * @param {number} id - ID del item
-     */
+   * Removes a failed item from the buffer
+   * @param {number} id - Item ID
+   */
   async removeFailedItem(id) {
     try {
       await this.storageManager.remove(id);
     } catch (error) {
-      console.error('SyntropyFront: Error removiendo item fallido:', error);
+      console.error('SyntropyFront: Error removing failed item:', error);
     }
   }
 
   /**
-     * Limpia items que han excedido el máximo de reintentos
-     */
+   * Cleans items that have exceeded the maximum retry count
+   */
   async cleanupExpiredItems() {
     try {
       const allItems = await this.storageManager.retrieve();
@@ -1493,20 +1428,20 @@ class RetryLogicManager {
             
       for (const item of expiredItems) {
         await this.removeFailedItem(item.id);
-        console.warn(`SyntropyFront: Item ${item.id} removido por exceder máximo de reintentos`);
+        console.warn(`SyntropyFront: Item ${item.id} removed for exceeding maximum retries`);
       }
             
       if (expiredItems.length > 0) {
-        console.log(`SyntropyFront: Limpieza completada, ${expiredItems.length} items removidos`);
+        console.log(`SyntropyFront: Cleanup completed, ${expiredItems.length} items removed`);
       }
     } catch (error) {
-      console.error('SyntropyFront: Error en limpieza de items expirados:', error);
+      console.error('SyntropyFront: Error cleaning up expired items:', error);
     }
   }
 
   /**
-     * Obtiene estadísticas de reintentos
-     */
+   * Returns retry statistics
+   */
   async getRetryStats() {
     try {
       const allItems = await this.storageManager.retrieve();
@@ -1529,7 +1464,7 @@ class RetryLogicManager {
 
       return stats;
     } catch (error) {
-      console.error('SyntropyFront: Error obteniendo estadísticas de reintentos:', error);
+      console.error('SyntropyFront: Error getting retry statistics:', error);
       return {
         totalItems: 0,
         itemsByRetryCount: {},
@@ -1540,77 +1475,253 @@ class RetryLogicManager {
 }
 
 /**
- * SerializationManager - Maneja la serialización y deserialización de datos
- * Responsabilidad única: Gestionar la transformación de datos para almacenamiento
+ * Functional Fragments: Pure masking strategies.
+ */
+const MASKING_STRATEGIES = {
+  credit_card: (value, rule) => {
+    const clean = value.replace(/\D/g, '');
+    if (rule.preserveLength) {
+      return value.replace(/\d/g, (match, offset) => {
+        const digitIndex = value.substring(0, offset).replace(/\D/g, '').length;
+        return digitIndex < clean.length - 4 ? rule.maskChar : match;
+      });
+    }
+    return `${rule.maskChar.repeat(4)}-${rule.maskChar.repeat(4)}-${rule.maskChar.repeat(4)}-${clean.slice(-4)}`;
+  },
+
+  ssn: (value, rule) => {
+    const clean = value.replace(/\D/g, '');
+    if (rule.preserveLength) {
+      return value.replace(/\d/g, (match, offset) => {
+        const digitIndex = value.substring(0, offset).replace(/\D/g, '').length;
+        return digitIndex < clean.length - 4 ? rule.maskChar : match;
+      });
+    }
+    return `***-**-${clean.slice(-4)}`;
+  },
+
+  email: (value, rule) => {
+    const atIndex = value.indexOf('@');
+    if (atIndex <= 0) return MASKING_STRATEGIES.default(value, rule);
+
+    const username = value.substring(0, atIndex);
+    const domain = value.substring(atIndex);
+
+    if (rule.preserveLength) {
+      const maskedUsername = username.length > 1
+        ? username.charAt(0) + rule.maskChar.repeat(username.length - 1)
+        : rule.maskChar.repeat(username.length);
+      return maskedUsername + domain;
+    }
+    return `${username.charAt(0)}***${domain}`;
+  },
+
+  phone: (value, rule) => {
+    const clean = value.replace(/\D/g, '');
+    if (rule.preserveLength) {
+      return value.replace(/\d/g, (match, offset) => {
+        const digitIndex = value.substring(0, offset).replace(/\D/g, '').length;
+        return digitIndex < clean.length - 4 ? rule.maskChar : match;
+      });
+    }
+    return `${rule.maskChar.repeat(3)}-${rule.maskChar.repeat(3)}-${clean.slice(-4)}`;
+  },
+
+  secret: (value, rule) => {
+    if (rule.preserveLength) return rule.maskChar.repeat(value.length);
+    return rule.maskChar.repeat(8);
+  },
+
+  custom: (value, rule) => {
+    return typeof rule.customMask === 'function' ? rule.customMask(value) : value;
+  },
+
+  default: (value, rule) => {
+    if (rule.preserveLength) return rule.maskChar.repeat(value.length);
+    return rule.maskChar.repeat(Math.min(value.length, 8));
+  }
+};
+
+// Compatibility Aliases
+MASKING_STRATEGIES.password = MASKING_STRATEGIES.secret;
+MASKING_STRATEGIES.token = MASKING_STRATEGIES.secret;
+
+const MaskingStrategy = {
+  CREDIT_CARD: 'credit_card',
+  SSN: 'ssn',
+  EMAIL: 'email',
+  PHONE: 'phone',
+  PASSWORD: 'password'};
+
+/**
+ * DataMaskingManager - PII Obfuscation Engine.
+ * Implements Strategy Pattern (SOLID: OCP).
+ */
+class DataMaskingManager {
+  constructor(options = {}) {
+    this.maskChar = options.maskChar || '*';
+    this.preserveLength = options.preserveLength !== false;
+    this.rules = [];
+    this.strategies = new Map(Object.entries(MASKING_STRATEGIES));
+
+    // ANSI escape code regex (intentional control chars for stripping terminal codes)
+    // eslint-disable-next-line no-control-regex
+    this.ansiRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+
+    if (options.enableDefaultRules !== false) {
+      this.addDefaultRules();
+    }
+
+    if (options.rules) {
+      options.rules.forEach(rule => this.addRule(rule));
+    }
+  }
+
+  addDefaultRules() {
+    const defaultRules = [
+      { pattern: /credit_card|card_number|payment_number/i, strategy: MaskingStrategy.CREDIT_CARD },
+      { pattern: /ssn|social_security|security_number/i, strategy: MaskingStrategy.SSN },
+      { pattern: /email/i, strategy: MaskingStrategy.EMAIL },
+      { pattern: /phone|phone_number|mobile_number/i, strategy: MaskingStrategy.PHONE },
+      { pattern: /password|pass|pwd|secret|api_key|token|auth_token|jwt|bearer/i, strategy: MaskingStrategy.PASSWORD }
+    ];
+
+    defaultRules.forEach(rule => this.addRule(rule));
+  }
+
+  addRule(rule) {
+    this.rules.push({
+      ...rule,
+      _compiledPattern: typeof rule.pattern === 'string' ? new RegExp(rule.pattern, 'i') : rule.pattern,
+      preserveLength: rule.preserveLength ?? this.preserveLength,
+      maskChar: rule.maskChar ?? this.maskChar
+    });
+  }
+
+  registerStrategy(name, strategyFn) {
+    if (typeof strategyFn === 'function') {
+      this.strategies.set(name, strategyFn);
+    }
+  }
+
+  process(data) {
+    if (data === null || data === undefined) return data;
+
+    const processors = {
+      string: (val) => val.replace(this.ansiRegex, ''),
+      object: (val) => {
+        if (Array.isArray(val)) return val.map(item => this.process(item));
+        if (val && val.constructor === Object) return this.maskObject(val);
+        return val;
+      }
+    };
+
+    return (processors[typeof data] || ((v) => v))(data);
+  }
+
+  maskObject(data) {
+    return Object.entries(data).reduce((acc, [key, value]) => {
+      acc[key] = this.maskValue(key, value);
+      return acc;
+    }, {});
+  }
+
+  maskValue(key, value) {
+    if (typeof value !== 'string') return this.process(value);
+
+    const rule = this.rules.find(r => r._compiledPattern?.test(key));
+    return rule ? this.applyStrategy(value, rule) : value.replace(this.ansiRegex, '');
+  }
+
+  applyStrategy(value, rule) {
+    const strategy = this.strategies.get(rule.strategy) || this.strategies.get('default');
+    return strategy(value, rule);
+  }
+}
+
+const dataMaskingManager = new DataMaskingManager();
+
+/**
+ * SerializationManager - Handles serialization and deserialization of data.
+ * Single responsibility: Manage data transformation for storage.
+ * DIP: Accepts serializer and masking via constructor for testability and substitution.
+ * @param {Object} [deps] - Injected dependencies
+ * @param {{ serialize: function(*): string, deserialize: function(string): * }} [deps.serializer] - Serializer (circular ref handling)
+ * @param {{ process: function(*): * }} [deps.masking] - Object with process(data) for PII obfuscation
  */
 class SerializationManager {
-  constructor() {
-    this.serializer = robustSerializer;
+  constructor(deps = {}) {
+    this.serializer = deps.serializer ?? robustSerializer;
+    this.masking = deps.masking ?? dataMaskingManager;
   }
 
   /**
-     * Serializa items con manejo declarativo de errores
-     * @param {Array} items - Items a serializar
-     * @returns {Object} Resultado de serialización
+     * Serializes items with declarative error handling
+     * @param {Array} items - Items to serialize
+     * @returns {Object} Serialization result
      */
   serialize(items) {
-    const serializationResult = {
-      success: false,
-      data: null,
-      error: null,
-      timestamp: new Date().toISOString()
-    };
-
     try {
-      const serializedData = this.serializer.serialize(items);
+      // Guard: Validate basic input
+      if (items === null || items === undefined) {
+        return { success: true, data: this.serializer.serialize([]), error: null, timestamp: new Date().toISOString() };
+      }
+
+      // Apply masking before store/send
+      const maskedItems = this.masking.process(items);
+      const serializedData = this.serializer.serialize(maskedItems);
+
       return {
-        ...serializationResult,
         success: true,
-        data: serializedData
+        data: serializedData,
+        error: null,
+        timestamp: new Date().toISOString()
       };
     } catch (error) {
       return {
-        ...serializationResult,
+        success: false,
+        data: this.createFallbackData(error),
         error: this.createSerializationError(error),
-        data: this.createFallbackData(error)
+        timestamp: new Date().toISOString()
       };
     }
   }
 
   /**
-     * Deserializa datos con manejo declarativo de errores
+     * Deserializes data with declarative error handling
      * @param {string} serializedData - Datos serializados
-     * @returns {Object} Resultado de deserialización
+     * @returns {Object} Deserialization result
      */
   deserialize(serializedData) {
-    const deserializationResult = {
-      success: false,
-      data: null,
-      error: null,
-      timestamp: new Date().toISOString()
-    };
-
     try {
+      // Guard: Empty or null data
+      if (!serializedData) {
+        return { success: true, data: [], error: null, timestamp: new Date().toISOString() };
+      }
+
       const deserializedData = this.serializer.deserialize(serializedData);
+
       return {
-        ...deserializationResult,
         success: true,
-        data: deserializedData
+        data: deserializedData,
+        error: null,
+        timestamp: new Date().toISOString()
       };
     } catch (error) {
       return {
-        ...deserializationResult,
+        success: false,
+        data: [],
         error: this.createDeserializationError(error),
-        data: []
+        timestamp: new Date().toISOString()
       };
     }
   }
 
   /**
-     * Crea un error de serialización estructurado
-     * @param {Error} error - Error original
-     * @returns {Object} Error estructurado
-     */
+   * Creates a structured serialization error
+   * @param {Error} error - Original error
+   * @returns {Object} Structured error
+   */
   createSerializationError(error) {
     return {
       type: 'serialization_error',
@@ -1621,10 +1732,10 @@ class SerializationManager {
   }
 
   /**
-     * Crea un error de deserialización estructurado
-     * @param {Error} error - Error original
-     * @returns {Object} Error estructurado
-     */
+   * Creates a structured deserialization error
+   * @param {Error} error - Original error
+   * @returns {Object} Structured error
+   */
   createDeserializationError(error) {
     return {
       type: 'deserialization_error',
@@ -1635,83 +1746,87 @@ class SerializationManager {
   }
 
   /**
-     * Crea datos de fallback cuando falla la serialización
-     * @param {Error} error - Error que causó el fallback
-     * @returns {string} Datos de fallback serializados
+     * Creates fallback data when serialization fails
+     * @param {Error} error - Error that caused the fallback
+     * @returns {string} Serialized fallback data
      */
   createFallbackData(error) {
     const fallbackPayload = {
       __serializationError: true,
       error: error.message,
       timestamp: new Date().toISOString(),
-      fallbackData: 'Items no serializables - usando fallback'
+      fallbackData: 'Items not serializable - using fallback'
     };
 
     return JSON.stringify(fallbackPayload);
   }
 
   /**
-     * Verifica si un resultado de serialización fue exitoso
-     * @param {Object} result - Resultado de serialización/deserialización
-     * @returns {boolean} True si fue exitoso
-     */
+   * Checks if a serialization result was successful
+   * @param {Object} result - Serialization/deserialization result
+   * @returns {boolean} True if successful
+   */
   isSuccessful(result) {
     return Boolean(result && result.success === true);
   }
 
   /**
-     * Obtiene los datos de un resultado, con fallback
-     * @param {Object} result - Resultado de serialización/deserialización
-     * @param {*} fallback - Valor por defecto si falla
-     * @returns {*} Datos o fallback
+     * Gets data from a result, with fallback
+     * @param {Object} result - Serialization/deserialization result
+     * @param {*} fallback - Default value if failed
+     * @returns {*} Data or fallback
      */
   getData(result, fallback = null) {
     return this.isSuccessful(result) ? result.data : fallback;
   }
 }
 
+const DEFAULT_DB_NAME = 'SyntropyFrontBuffer';
+const DEFAULT_DB_VERSION = 1;
+const DEFAULT_STORE_NAME = 'failedItems';
+
 /**
- * PersistentBufferManager - Coordinador del buffer persistente
- * Responsabilidad única: Coordinar los componentes de almacenamiento persistente
+ * PersistentBufferManager - Persistent buffer coordinator
+ * Single Responsibility: Coordinate persistent storage components
+ * DIP: Accepts injected components (databaseManager, serializationManager, storageManager, retryLogicManager) for tests and substitution.
+ * @param {Object} configManager - Config (usePersistentBuffer, maxRetries, etc.)
+ * @param {Object} [deps] - Injected components; defaults created if not provided
  */
 class PersistentBufferManager {
-  constructor(configManager) {
+  constructor(configManager, deps = {}) {
     this.config = configManager;
     this.usePersistentBuffer = false;
-        
-    // Inicializar componentes especializados
-    this.databaseManager = new DatabaseManager(
-      'SyntropyFrontBuffer',
-      1,
-      'failedItems'
+
+    this.databaseManager = deps.databaseManager ?? new DatabaseManager(
+      DEFAULT_DB_NAME,
+      DEFAULT_DB_VERSION,
+      DEFAULT_STORE_NAME
     );
-        
-    this.serializationManager = new SerializationManager();
-    this.storageManager = new StorageManager(this.databaseManager, this.serializationManager);
-    this.retryLogicManager = new RetryLogicManager(this.storageManager, this.config);
-        
-    // Inicializar buffer persistente si está disponible
+    this.serializationManager = deps.serializationManager ?? new SerializationManager();
+    this.storageManager = deps.storageManager ?? new StorageManager(this.databaseManager, this.serializationManager);
+    this.retryLogicManager = deps.retryLogicManager ?? new RetryLogicManager(this.storageManager, this.config);
+
     this.initPersistentBuffer();
   }
 
   /**
-     * Inicializa el buffer persistente
+     * Initializes the persistent buffer
      */
   async initPersistentBuffer() {
     try {
       const success = await this.databaseManager.init();
       if (success) {
         this.usePersistentBuffer = this.config.usePersistentBuffer;
-        console.log('SyntropyFront: Buffer persistente inicializado');
+        console.log('SyntropyFront: Persistent buffer initialized');
       }
     } catch (error) {
-      console.warn('SyntropyFront: Error inicializando buffer persistente:', error);
+      console.warn('SyntropyFront: Error initializing persistent buffer:', error);
     }
   }
 
   /**
-     * Guarda items fallidos en el buffer persistente
-     * @param {Array} items - Items a guardar
+     * Saves failed items to the persistent buffer
+     * @param {Array} items - Items to save
      */
   async save(items) {
     if (!this.usePersistentBuffer) {
@@ -1720,14 +1835,14 @@ class PersistentBufferManager {
 
     try {
       await this.storageManager.save(items);
-      console.log('SyntropyFront: Items guardados en buffer persistente');
+      console.log('SyntropyFront: Items saved to persistent buffer');
     } catch (error) {
-      console.error('SyntropyFront: Error guardando en buffer persistente:', error);
+      console.error('SyntropyFront: Error saving to persistent buffer:', error);
     }
   }
 
   /**
-     * Obtiene items fallidos del buffer persistente
+     * Retrieves failed items from the persistent buffer
      */
   async retrieve() {
     if (!this.usePersistentBuffer) {
@@ -1737,14 +1852,14 @@ class PersistentBufferManager {
     try {
       return await this.storageManager.retrieve();
     } catch (error) {
-      console.error('SyntropyFront: Error obteniendo del buffer persistente:', error);
+      console.error('SyntropyFront: Error retrieving from persistent buffer:', error);
       return [];
     }
   }
 
   /**
-     * Remueve items del buffer persistente
-     * @param {number} id - ID del item a remover
+     * Removes items from the persistent buffer
+     * @param {number} id - ID of the item to remove
      */
   async remove(id) {
     if (!this.usePersistentBuffer) {
@@ -1754,14 +1869,14 @@ class PersistentBufferManager {
     try {
       await this.storageManager.remove(id);
     } catch (error) {
-      console.error('SyntropyFront: Error removiendo del buffer persistente:', error);
+      console.error('SyntropyFront: Error removing from persistent buffer:', error);
     }
   }
 
   /**
-     * Intenta enviar items fallidos del buffer persistente
-     * @param {Function} sendCallback - Callback para enviar items
-     * @param {Function} removeCallback - Callback para remover items exitosos
+     * Attempts to send failed items from the persistent buffer
+     * @param {Function} sendCallback - Callback to send items
+     * @param {Function} removeCallback - Callback to remove successful items
      */
   async retryFailedItems(sendCallback, removeCallback) {
     if (!this.usePersistentBuffer) {
@@ -1772,7 +1887,7 @@ class PersistentBufferManager {
   }
 
   /**
-     * Limpia items que han excedido el máximo de reintentos
+     * Cleans up items that have exceeded the maximum retry count
      */
   async cleanupExpiredItems() {
     if (!this.usePersistentBuffer) {
@@ -1783,7 +1898,7 @@ class PersistentBufferManager {
   }
 
   /**
-     * Obtiene estadísticas del buffer persistente
+     * Gets persistent buffer statistics
      */
   async getStats() {
     if (!this.usePersistentBuffer) {
@@ -1802,7 +1917,7 @@ class PersistentBufferManager {
         isAvailable: this.isAvailable()
       };
     } catch (error) {
-      console.error('SyntropyFront: Error obteniendo estadísticas:', error);
+      console.error('SyntropyFront: Error getting statistics:', error);
       return {
         totalItems: 0,
         itemsByRetryCount: {},
@@ -1813,14 +1928,14 @@ class PersistentBufferManager {
   }
 
   /**
-     * Verifica si el buffer persistente está disponible
+     * Checks if the persistent buffer is available
      */
   isAvailable() {
     return this.usePersistentBuffer && this.databaseManager.isDatabaseAvailable();
   }
 
   /**
-     * Limpia todo el buffer persistente
+     * Clears the entire persistent buffer
      */
   async clear() {
     if (!this.usePersistentBuffer) {
@@ -1829,14 +1944,14 @@ class PersistentBufferManager {
 
     try {
       await this.storageManager.clear();
-      console.log('SyntropyFront: Buffer persistente limpiado');
+      console.log('SyntropyFront: Persistent buffer cleared');
     } catch (error) {
-      console.error('SyntropyFront: Error limpiando buffer persistente:', error);
+      console.error('SyntropyFront: Error clearing persistent buffer:', error);
     }
   }
 
   /**
-     * Cierra la conexión con la base de datos
+     * Closes the database connection
      */
   close() {
     this.databaseManager.close();
@@ -1845,60 +1960,56 @@ class PersistentBufferManager {
 }
 
 /**
- * Copyright 2024 Syntropysoft
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ * Agent - Coordinates sending traceability data to the backend.
+ * DIP: All dependencies (config, queue, retry, transport, buffer, masking) are injectable.
  *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-/**
- * Agent - Envía datos de trazabilidad al backend
- * Coordinador que usa componentes especializados para cada responsabilidad
+ * @contract
+ * - configure(config): updates agent configuration.
+ * - sendError(payload, context?): if enabled and not dropped by sampling, enqueues an item of type 'error'.
+ * - sendBreadcrumbs(breadcrumbs): if enabled, batchTimeout set and non-empty, enqueues type 'breadcrumbs'.
+ * - flush(): drains queue via flushCallback. forceFlush(): flush + processes pending retries.
+ * - getStats(): returns { queueLength, retryQueueLength, isEnabled, usePersistentBuffer, maxRetries }.
  */
 class Agent {
-  constructor() {
-    // Componentes especializados
-    this.config = new ConfigurationManager();
-    this.queue = new QueueManager(this.config);
-    this.retry = new RetryManager(this.config);
-    this.transport = new HttpTransport(this.config);
-    this.buffer = new PersistentBufferManager(this.config);
-        
-    // Configurar callbacks para coordinación
+  /**
+   * @param {Object} [deps] - Injected dependencies (config, queue, retry, transport, buffer, masking). Defaults created if not provided.
+   */
+  constructor(deps = {}) {
+    // Components (Injected or Defaults)
+    this.config = deps.config || new ConfigurationManager();
+    this.masking = deps.masking || dataMaskingManager;
+
+    // Managers that depend on config
+    this.queue = deps.queue || new QueueManager(this.config);
+    this.retry = deps.retry || new RetryManager(this.config);
+    this.transport = deps.transport || new HttpTransport(this.config);
+    this.buffer = deps.buffer || new PersistentBufferManager(this.config);
+
+    // Setup coordination callbacks
     this.setupCallbacks();
   }
 
   /**
-     * Configura callbacks para coordinación entre componentes
-     */
+   * Configures callbacks for coordination between components
+   */
   setupCallbacks() {
-    // Callback para el QueueManager cuando hace flush
+    // QueueManager flush callback
     this.queue.flushCallback = async (items) => {
       try {
         await this.transport.send(items);
-        console.log('SyntropyFront: Datos enviados exitosamente');
+        console.log('SyntropyFront: Data sent successfully');
       } catch (error) {
-        console.error('SyntropyFront Agent: Error enviando datos:', error);
-                
-        // Agregar a cola de reintentos
+        console.error('SyntropyFront Agent: Error sending data:', error);
+
+        // Add to retry queue
         this.retry.addToRetryQueue(items);
-                
-        // Guardar en buffer persistente
+
+        // Save to persistent buffer
         await this.buffer.save(items);
       }
     };
 
-    // Callback para el RetryManager cuando procesa reintentos
+    // RetryManager send callback
     this.retry.sendCallback = async (items) => {
       return await this.transport.send(items);
     };
@@ -1907,90 +2018,95 @@ class Agent {
       await this.buffer.remove(id);
     };
 
-    // Callback para el PersistentBufferManager cuando retry items
+    // PersistentBufferManager retry callback
     this.buffer.sendCallback = (items, retryCount, persistentId) => {
       this.retry.addToRetryQueue(items, retryCount, persistentId);
     };
   }
 
-
-
   /**
-     * Configura el agent
-     * @param {Object} config - Configuración del agent
-     */
+   * Updates configuration (endpoint, headers, batchSize, batchTimeout, samplingRate, etc.).
+   * @param {Object} config - Ver ConfigurationManager.configure
+   * @returns {void}
+   */
   configure(config) {
     this.config.configure(config);
   }
 
   /**
-     * Envía un error al backend
-     * @param {Object} errorPayload - Payload del error
-     * @param {Object} context - Contexto adicional (opcional)
-     */
+   * Enqueues an error for send. Does not send if agent is disabled or sampling discards it.
+   * @param {Object} errorPayload - Payload with type, error, breadcrumbs, timestamp
+   * @param {Object|null} [context=null] - Additional context (merged into payload)
+   * @returns {void}
+   */
   sendError(errorPayload, context = null) {
+    // 🛡️ Guard: Agent enabled
     if (!this.config.isAgentEnabled()) {
-      console.warn('SyntropyFront Agent: No configurado, error no enviado');
+      console.warn('SyntropyFront Agent: Not configured, error not sent');
       return;
     }
 
-    // Agregar contexto si está disponible
-    const payloadWithContext = context ? {
-      ...errorPayload,
-      context
-    } : errorPayload;
+    // 🎲 Guard: Sampling
+    if (Math.random() > this.config.samplingRate) return;
 
-    // Aplicar encriptación si está configurada
+    // Functional Pipeline: Generate payload with context
+    const payloadWithContext = context
+      ? { ...errorPayload, context }
+      : errorPayload;
+
+    // Apply transformations (Encryption and Obfuscation)
     const dataToSend = this.transport.applyEncryption(payloadWithContext);
+    const maskedData = this.masking.process(dataToSend);
 
     this.queue.add({
       type: 'error',
-      data: dataToSend,
+      data: maskedData,
       timestamp: new Date().toISOString()
     });
   }
 
   /**
-     * Envía breadcrumbs al backend
-     * @param {Array} breadcrumbs - Lista de breadcrumbs
-     */
+   * Enqueues breadcrumbs for send. Does not send if disabled, no batchTimeout, or empty array.
+   * @param {Array<Object>} breadcrumbs - List of traces (category, message, data, timestamp)
+   * @returns {void}
+   */
   sendBreadcrumbs(breadcrumbs) {
-    // Solo enviar breadcrumbs si está habilitado (batchTimeout configurado)
+    // 🛡️ Guard: Enabled and with data
     if (!this.config.isAgentEnabled() || !this.config.shouldSendBreadcrumbs() || !breadcrumbs.length) {
       return;
     }
 
-    // Aplicar encriptación si está configurada
+    // 🎲 Guard: Sampling
+    if (Math.random() > this.config.samplingRate) return;
+
+    // Apply transformations
     const dataToSend = this.transport.applyEncryption(breadcrumbs);
+    const maskedData = this.masking.process(dataToSend);
 
     this.queue.add({
       type: 'breadcrumbs',
-      data: dataToSend,
+      data: maskedData,
       timestamp: new Date().toISOString()
     });
   }
 
   /**
-     * Añade un item a la cola de envío (método público para compatibilidad)
-     * @param {Object} item - Item a añadir
-     */
+   * Adds an item to the queue (compatibility)
+   */
   addToQueue(item) {
     this.queue.add(item);
   }
 
   /**
-     * Añade items a la cola de reintentos (método público para compatibilidad)
-     * @param {Array} items - Items a reintentar
-     * @param {number} retryCount - Número de reintento
-     * @param {number} persistentId - ID en buffer persistente (opcional)
-     */
+   * Adds to retry queue (compatibility)
+   */
   addToRetryQueue(items, retryCount = 1, persistentId = null) {
     this.retry.addToRetryQueue(items, retryCount, persistentId);
   }
 
   /**
-     * Procesa la cola de reintentos (método público para compatibilidad)
-     */
+   * Processes retry queue (compatibility)
+   */
   async processRetryQueue() {
     await this.retry.processRetryQueue(
       this.retry.sendCallback,
@@ -1999,29 +2115,28 @@ class Agent {
   }
 
   /**
-     * Envía todos los items en cola
-     */
+   * Forces flush of current queue
+   */
   async flush() {
     await this.queue.flush(this.queue.flushCallback);
   }
 
   /**
-     * Fuerza el envío inmediato de todos los datos pendientes
-     */
+   * Forces immediate flush of everything
+   */
   async forceFlush() {
     await this.flush();
-        
-    // También intentar enviar items en cola de reintentos
+
+    // Also attempt pending retries
     if (!this.retry.isEmpty()) {
-      console.log('SyntropyFront: Intentando enviar items en cola de reintentos...');
+      console.log('SyntropyFront: Attempting to send pending retries...');
       await this.processRetryQueue();
     }
   }
 
   /**
-     * Obtiene estadísticas del agent
-     * @returns {Object} Estadísticas
-     */
+   * Gets agent stats
+   */
   getStats() {
     const config = this.config.getConfig();
     return {
@@ -2034,670 +2149,770 @@ class Agent {
   }
 
   /**
-     * Intenta enviar items fallidos del buffer persistente
-     */
+   * Attempts to send failed items from persistent buffer
+   */
   async retryFailedItems() {
     await this.buffer.retryFailedItems(this.buffer.sendCallback);
   }
 
   /**
-     * Desactiva el agent
-     */
+   * Returns whether the agent is enabled (for consumers that need to check without depending on config shape).
+   */
+  isEnabled() {
+    return this.config.isAgentEnabled();
+  }
+
+  /**
+   * Returns whether breadcrumbs should be sent (e.g. batch mode with timeout).
+   */
+  shouldSendBreadcrumbs() {
+    return this.config.shouldSendBreadcrumbs();
+  }
+
+  /**
+   * Disables the agent
+   */
   disable() {
-    this.config.configure({ endpoint: null }); // Deshabilitar
+    this.config.configure({ endpoint: null });
     this.queue.clear();
     this.retry.clear();
   }
 }
 
-// Instancia singleton
+// Singleton Instance
 const agent = new Agent();
 
 /**
- * ContextCollector - Recolector dinámico de contexto
- * Sistema elegante para recolectar datos según lo que pida el usuario
- * Por defecto: Sets curados y seguros
- * Configuración específica: El usuario elige exactamente qué quiere
+ * Environment - Centralized detection of browser environment and capabilities.
+ * Browser-only: targets modern browsers per browserslist config.
  */
-class ContextCollector {
-  constructor() {
-    // Sets curados por defecto (seguros y útiles)
-    this.defaultContexts = {
-      device: {
-        userAgent: () => navigator.userAgent,
-        language: () => navigator.language,
-        screen: () => ({
-          width: window.screen.width,
-          height: window.screen.height
-        }),
-        timezone: () => Intl.DateTimeFormat().resolvedOptions().timeZone
-      },
-      window: {
-        url: () => window.location.href,
-        viewport: () => ({
-          width: window.innerWidth,
-          height: window.innerHeight
-        }),
-        title: () => document.title
-      },
-      session: {
-        sessionId: () => this.generateSessionId(),
-        pageLoadTime: () => performance.now()
-      },
-      ui: {
-        visibility: () => document.visibilityState,
-        activeElement: () => document.activeElement ? {
-          tagName: document.activeElement.tagName
-        } : null
-      },
-      network: {
-        online: () => navigator.onLine,
-        connection: () => navigator.connection ? {
-          effectiveType: navigator.connection.effectiveType
-        } : null
-      }
-    };
-
-    // Mapeo completo de todos los campos disponibles
-    this.allFields = {
-      device: {
-        userAgent: () => navigator.userAgent,
-        language: () => navigator.language,
-        languages: () => navigator.languages,
-        screen: () => ({
-          width: window.screen.width,
-          height: window.screen.height,
-          availWidth: window.screen.availWidth,
-          availHeight: window.screen.availHeight,
-          colorDepth: window.screen.colorDepth,
-          pixelDepth: window.screen.pixelDepth
-        }),
-        timezone: () => Intl.DateTimeFormat().resolvedOptions().timeZone,
-        cookieEnabled: () => navigator.cookieEnabled,
-        doNotTrack: () => navigator.doNotTrack
-      },
-      window: {
-        url: () => window.location.href,
-        pathname: () => window.location.pathname,
-        search: () => window.location.search,
-        hash: () => window.location.hash,
-        referrer: () => document.referrer,
-        title: () => document.title,
-        viewport: () => ({
-          width: window.innerWidth,
-          height: window.innerHeight
-        })
-      },
-      storage: {
-        localStorage: () => {
-          const keys = Object.keys(localStorage);
-          return {
-            keys: keys.length,
-            size: JSON.stringify(localStorage).length,
-            keyNames: keys // Solo nombres, no valores
-          };
-        },
-        sessionStorage: () => {
-          const keys = Object.keys(sessionStorage);
-          return {
-            keys: keys.length,
-            size: JSON.stringify(sessionStorage).length,
-            keyNames: keys // Solo nombres, no valores
-          };
-        }
-      },
-      network: {
-        online: () => navigator.onLine,
-        connection: () => navigator.connection ? {
-          effectiveType: navigator.connection.effectiveType,
-          downlink: navigator.connection.downlink,
-          rtt: navigator.connection.rtt
-        } : null
-      },
-      ui: {
-        focused: () => document.hasFocus(),
-        visibility: () => document.visibilityState,
-        activeElement: () => document.activeElement ? {
-          tagName: document.activeElement.tagName,
-          id: document.activeElement.id,
-          className: document.activeElement.className
-        } : null
-      },
-      performance: {
-        memory: () => window.performance && window.performance.memory ? {
-          used: Math.round(window.performance.memory.usedJSHeapSize / 1048576),
-          total: Math.round(window.performance.memory.totalJSHeapSize / 1048576),
-          limit: Math.round(window.performance.memory.jsHeapSizeLimit / 1048576)
-        } : null,
-        timing: () => window.performance ? {
-          navigationStart: window.performance.timing.navigationStart,
-          loadEventEnd: window.performance.timing.loadEventEnd
-        } : null
-      },
-      session: {
-        sessionId: () => this.generateSessionId(),
-        startTime: () => new Date().toISOString(),
-        pageLoadTime: () => performance.now()
-      }
-    };
-  }
+const Environment = {
+  /**
+     * Returns true if running in a browser context.
+     */
+  isBrowser: () => typeof window !== 'undefined' && typeof document !== 'undefined',
 
   /**
-     * Recolecta contexto según la configuración
-     * @param {Object} contextConfig - Configuración de contexto
-     * @returns {Object} Contexto recolectado
+     * Returns the global browser object, or empty object as safe fallback.
      */
-  collect(contextConfig = {}) {
-    const context = {};
+  getGlobal: () => (typeof window !== 'undefined' ? window : {}),
 
-    Object.entries(contextConfig).forEach(([contextType, config]) => {
-      try {
-        if (config === true) {
-          // Usar set curado por defecto
-          context[contextType] = this.collectDefaultContext(contextType);
-        } else if (Array.isArray(config)) {
-          // Configuración específica: array de campos
-          context[contextType] = this.collectSpecificFields(contextType, config);
-        } else if (config === false) {
-          // Explícitamente deshabilitado
-          // No hacer nada
-        } else {
-          console.warn(`SyntropyFront: Configuración de contexto inválida para ${contextType}:`, config);
-        }
-      } catch (error) {
-        console.warn(`SyntropyFront: Error recolectando contexto ${contextType}:`, error);
-        context[contextType] = { error: 'Failed to collect' };
-      }
-    });
+  /**
+     * Checks availability of a nested global API via dot-notation path.
+     * @param {string} apiPath - e.g. 'navigator.connection' or 'crypto.randomUUID'
+     * @returns {boolean}
+     */
+  hasApi: (apiPath) => {
+    return apiPath.split('.').reduce((current, part) => {
+      if (current === null || current === undefined) return null;
+      return current[part] !== undefined ? current[part] : null;
+    }, Environment.getGlobal()) !== null;
+  },
 
-    return context;
+  /**
+     * Executes a task only if a condition is met; returns fallback otherwise.
+     * @param {string|Function} condition - API path string or boolean-returning function.
+     * @param {Function} task - Operation to execute when condition is met.
+     * @param {any} fallback - Default value when condition is not met.
+     * @returns {any}
+     */
+  runIf: (condition, task, fallback = null) => {
+    const isMet = typeof condition === 'function' ? condition() : Environment.hasApi(condition);
+    return isMet ? task() : fallback;
   }
+};
+
+/**
+ * Functional fragments: DOM detection and labeling utilities.
+ */
+const DOM_UTILS = {
+  /**
+     * Selector exhaustivo de elementos interactivos.
+     */
+  INTERACTIVE_SELECTOR: [
+    'a', 'button', 'input', 'select', 'textarea', 'label', 'summary',
+    '[role="button"]', '[role="link"]', '[role="checkbox"]', '[role="radio"]',
+    '[role="menuitem"]', '[role="option"]', '[role="switch"]', '[role="tab"]',
+    '.interactive', '.btn', '.clickable', // Convention selectors
+    '[onclick]', '[ng-click]', '[v-on:click]', '[@click]' // Selectores de framework
+  ].join(', '),
 
   /**
-     * Recolecta el set curado por defecto
-     * @param {string} contextType - Tipo de contexto
-     * @returns {Object} Contexto por defecto
+     * Checks if an element has cursor:pointer (pure CSS fallback).
      */
-  collectDefaultContext(contextType) {
-    const defaultContext = this.defaultContexts[contextType];
-    if (!defaultContext) {
-      console.warn(`SyntropyFront: No hay set por defecto para ${contextType}`);
-      return {};
+  hasPointerCursor: (el) => {
+    try {
+      return window.getComputedStyle(el).cursor === 'pointer';
+    } catch (e) {
+      return false;
     }
+  },
 
-    const result = {};
-    Object.entries(defaultContext).forEach(([field, getter]) => {
-      try {
-        result[field] = getter();
-      } catch (error) {
-        console.warn(`SyntropyFront: Error recolectando campo ${field} de ${contextType}:`, error);
-        result[field] = null;
-      }
-    });
+  /**
+     * Walks up the DOM tree looking for cursor:pointer (declarative, no while).
+     */
+  findTargetByStyle: (el) => {
+    // Guard: element nodes only
+    if (!el || el.nodeType !== 1) return null;
+    if (DOM_UTILS.hasPointerCursor(el)) return el;
+    if (!el.parentElement || el.parentElement === document.body) return null;
+    return DOM_UTILS.findTargetByStyle(el.parentElement);
+  },
 
-    return result;
-  }
+  /**
+     * Finds the interactive target using closest() with CSS fallback (declarative).
+     */
+  findInteractiveTarget: (el) => {
+    // Guard: valid element
+    if (!el || el === document.body || el.nodeType !== 1) return null;
+
+    // Declarative search via closest()
+    return el.closest(DOM_UTILS.INTERACTIVE_SELECTOR) || DOM_UTILS.findTargetByStyle(el);
+  },
 
   /**
-     * Recolecta campos específicos
-     * @param {string} contextType - Tipo de contexto
-     * @param {Array} fields - Campos específicos a recolectar
-     * @returns {Object} Contexto específico
+     * Generates a readable selector for the element.
      */
-  collectSpecificFields(contextType, fields) {
-    const allFields = this.allFields[contextType];
-    if (!allFields) {
-      console.warn(`SyntropyFront: Tipo de contexto desconocido: ${contextType}`);
-      return {};
-    }
+  generateSelector: (el) => {
+    // Guard: no element
+    if (!el) return 'unknown';
 
-    const result = {};
-    fields.forEach(field => {
-      try {
-        if (allFields[field]) {
-          result[field] = allFields[field]();
-        } else {
-          console.warn(`SyntropyFront: Campo ${field} no disponible en ${contextType}`);
-        }
-      } catch (error) {
-        console.warn(`SyntropyFront: Error recolectando campo ${field} de ${contextType}:`, error);
-        result[field] = null;
-      }
-    });
+    const tag = el.tagName.toLowerCase();
+    const id = el.id ? `#${el.id}` : '';
+    const classes = (typeof el.className === 'string' && el.className)
+      ? `.${el.className.split(' ').filter(Boolean).join('.')}`
+      : '';
 
-    return result;
+    return `${tag}${id}${classes}`;
   }
+};
 
-  /**
-     * Genera un ID de sesión seguro usando crypto.randomUUID() cuando esté disponible
-     * @returns {string} ID de sesión seguro
-     */
-  generateSecureId() {
-    try {
-      // Intentar usar crypto.randomUUID() si está disponible (Node.js 14.17+, browsers modernos)
-      if (typeof crypto !== 'undefined' && crypto.randomUUID) {
-        return crypto.randomUUID();
-      }
-      
-      // Fallback para navegadores más antiguos: usar crypto.getRandomValues()
-      if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
-        const array = new Uint8Array(16);
-        crypto.getRandomValues(array);
-        
-        // Convertir a formato UUID v4
-        const hex = Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
-        return [
-          hex.slice(0, 8),
-          hex.slice(8, 12),
-          hex.slice(12, 16),
-          hex.slice(16, 20),
-          hex.slice(20, 32)
-        ].join('-');
-      }
-      
-      // Fallback final: timestamp + random (menos seguro pero funcional)
-      const timestamp = Date.now().toString(36);
-      const random = Math.random().toString(36).substring(2, 15);
-      return `${timestamp}-${random}`;
-    } catch (error) {
-      console.warn('SyntropyFront: Error generando ID seguro, usando fallback:', error);
-      // Fallback de emergencia
-      return `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-    }
+/**
+ * ClickInterceptor - Interceptor coordinated by functional fragments.
+ * Refactored for maximum purity and removal of imperative logic.
+ */
+class ClickInterceptor {
+  constructor() {
+    this.handler = null;
+    this.lastClickTime = 0;
+    this.THROTTLE_MS = 500;
+  }
+
+  init() {
+    // Guard: browser environment
+    if (!Environment.isBrowser()) return;
+
+    this.handler = (event) => this.processClick(event);
+    document.addEventListener('click', this.handler, true);
   }
 
   /**
-     * Genera un ID de sesión simple
+     * Pipeline de procesamiento de clic (Pureza funcional).
      */
-  generateSessionId() {
-    if (!this._sessionId) {
-      this._sessionId = `session_${this.generateSecureId()}`;
-    }
-    return this._sessionId;
+  processClick(event) {
+    const el = event?.target;
+
+    // Guard: throttling and element existence
+    if (!el || this.isThrottled()) return;
+
+    const target = DOM_UTILS.findInteractiveTarget(el);
+    if (!target) return;
+
+    this.recordBreadcrumb(target);
   }
 
   /**
-     * Obtiene la lista de tipos de contexto disponibles
-     * @returns {Array} Tipos disponibles
+     * Flow control to avoid duplicates.
      */
-  getAvailableTypes() {
-    return Object.keys(this.allFields);
+  isThrottled() {
+    const now = Date.now();
+    const throttled = now - this.lastClickTime < this.THROTTLE_MS;
+    if (!throttled) this.lastClickTime = now;
+    return throttled;
   }
 
   /**
-     * Obtiene la lista de campos disponibles para un tipo de contexto
-     * @param {string} contextType - Tipo de contexto
-     * @returns {Array} Campos disponibles
+     * Records trace in the store.
      */
-  getAvailableFields(contextType) {
-    const fields = this.allFields[contextType];
-    return fields ? Object.keys(fields) : [];
+  recordBreadcrumb(target) {
+    const selector = DOM_UTILS.generateSelector(target);
+
+    breadcrumbStore.add({
+      category: 'ui',
+      message: `User clicked on '${selector}'`,
+      data: {
+        selector,
+        tagName: target.tagName,
+        id: target.id || null,
+        className: target.className || null,
+        text: (target.innerText || target.value || '').substring(0, 30).trim()
+      }
+    });
   }
 
   /**
-     * Obtiene información sobre los sets por defecto
-     * @returns {Object} Información de sets por defecto
+     * Limpieza de recursos.
      */
-  getDefaultContextsInfo() {
-    const info = {};
-    Object.entries(this.defaultContexts).forEach(([type, fields]) => {
-      info[type] = Object.keys(fields);
-    });
-    return info;
+  destroy() {
+    // Guard: browser and handler
+    if (!Environment.isBrowser() || !this.handler) return;
+
+    document.removeEventListener('click', this.handler, true);
+    this.handler = null;
   }
 }
 
-// Instancia singleton
-const contextCollector = new ContextCollector();
-
 /**
  * Copyright 2024 Syntropysoft
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
  */
 
+/**
+ * FunctionWrapper - Utility for standardizing global handler interception.
+ * Provides functional abstractions for safe execution and wrapping.
+ */
 
 /**
- * Interceptors - Observadores que capturan eventos automáticamente
- * Implementa Chaining Pattern para coexistir con otros APMs
+ * Safely executes a function with a given context and arguments.
+ * @param {Function} fn - Function to execute.
+ * @param {Object} context - Execution context (this).
+ * @param {Array} args - Arguments to pass.
+ * @param {string} [label='original handler'] - Diagnostic label for errors.
+ * @returns {any} Result of the function execution or undefined if failed.
  */
-class Interceptors {
-  constructor() {
-    this.isInitialized = false;
-    this.config = {
-      captureClicks: true,
-      captureFetch: true,
-      captureErrors: true,
-      captureUnhandledRejections: true
-    };
-    this.contextTypes = [];
+const safeApply = (fn, context, args, label = 'original handler') => {
+  if (typeof fn !== 'function') return;
+  try {
+    return fn.apply(context, args);
+  } catch (error) {
+    // Log for instrumentation but don't crash the host application
+    console.error(`SyntropyFront: Error in ${label}:`, error);
+    return;
+  }
+};
 
-    // Referencias originales para restaurar en destroy()
-    this.originalHandlers = {
-      fetch: null,
-      onerror: null,
-      onunhandledrejection: null
-    };
+/**
+ * Wraps a property on a target object using a factory.
+ * @param {Object} target - Target object (e.g., window).
+ * @param {string} property - Property name (e.g., 'fetch').
+ * @param {Function} wrapperFactory - Factory receiving (original) and returning (wrapped).
+ * @returns {Object|null} Disposable object with destroy() method.
+ */
+const wrap = (target, property, wrapperFactory) => {
+  // `in` operator accepts null values (e.g. window.onerror === null by default)
+  if (!target || !(property in target)) return null;
+
+  const original = target[property]; // null is a valid initial value
+  const wrapped = wrapperFactory(original);
+
+  // Apply the wrap
+  target[property] = wrapped;
+
+  return {
+    target,
+    property,
+    original,
+    wrapped,
+    destroy: () => {
+      // Only restore if it hasn't been re-wrapped by someone else (best effort)
+      if (target[property] === wrapped) {
+        target[property] = original;
+      }
+    }
+  };
+};
 
-    // Event listeners para limpiar
-    this.eventListeners = new Map();
-  }
+/**
+ * Copyright 2024 Syntropysoft
+ */
 
-  /**
-     * Configura los interceptores
-     * @param {Object} config - Configuración de interceptores
-     */
-  configure(config) {
-    this.config = { ...this.config, ...config };
-    this.contextTypes = config.context || [];
+
+/**
+ * FetchInterceptor - Intercepts network calls using the wrapper (chaining) pattern.
+ * Captures URL and method details to feed into the breadcrumb flow.
+ */
+class FetchInterceptor {
+  constructor() {
+    this.wrapper = null;
   }
 
   /**
-     * Inicializa todos los interceptores
+     * Initializes interception of the global fetch API.
      */
   init() {
-    if (this.isInitialized) {
-      console.warn('SyntropyFront: Interceptors ya están inicializados');
-      return;
-    }
-
-    if (this.config.captureClicks) {
-      this.setupClickInterceptor();
-    }
-
-    if (this.config.captureFetch) {
-      this.setupFetchInterceptor();
-    }
-
-    if (this.config.captureErrors || this.config.captureUnhandledRejections) {
-      this.setupErrorInterceptors();
-    }
+    // Guard: browser and fetch available
+    if (typeof window === 'undefined' || !window.fetch) return;
+
+    this.wrapper = wrap(window, 'fetch', (original) => {
+      return (...args) => {
+        // Functional extraction of URL and method
+        const url = (args[0] instanceof Request) ? args[0].url : (args[0] || 'unknown');
+        const method = (args[0] instanceof Request) ? args[0].method : (args[1]?.method || 'GET');
+
+        breadcrumbStore.add({
+          category: 'network',
+          message: `Request: ${method} ${url}`,
+          data: {
+            url,
+            method,
+            timestamp: Date.now()
+          }
+        });
 
-    this.isInitialized = true;
-    console.log('SyntropyFront: Interceptors inicializados con Chaining Pattern');
+        // Continue with original execution
+        return original.apply(window, args);
+      };
+    });
   }
 
   /**
-     * Intercepta clics de usuario
+     * Restores original fetch behaviour.
      */
-  setupClickInterceptor() {
-    // Solo configurar en el browser
-    if (typeof document === 'undefined') {
-      console.log('SyntropyFront: Click interceptor no disponible (no browser)');
-      return;
-    }
-
-    let lastClickTime = 0;
-    const THROTTLE_MS = 500;
+  destroy() {
+    // Guard: no wrapper
+    if (!this.wrapper) return;
 
-    const clickHandler = (event) => {
-      const el = event.target;
-      if (!el) return;
+    this.wrapper.destroy();
+    this.wrapper = null;
+  }
+}
 
-      // ✅ THROTTLE: Evitar ráfagas de clicks (ej: double clicks accidentales)
-      const now = Date.now();
-      if (now - lastClickTime < THROTTLE_MS) return;
-      lastClickTime = now;
+/**
+ * Pure function: Generates a secure ID using an injected crypto provider.
+ * Accepts a cryptoApi object so all fallback branches are independently testable.
+ * @param {Object|null} cryptoApi - Crypto implementation (e.g. window.crypto or null)
+ * @returns {string} Secure random ID
+ */
+const createSecureId = (cryptoApi = (typeof crypto !== 'undefined' ? crypto : null)) => {
+  if (typeof cryptoApi?.randomUUID === 'function') {
+    return cryptoApi.randomUUID();
+  }
+  if (typeof cryptoApi?.getRandomValues === 'function') {
+    const array = new Uint8Array(16);
+    cryptoApi.getRandomValues(array);
+    return Array.from(array, b => b.toString(16).padStart(2, '0')).join('');
+  }
+  return `${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+};
 
-      // ✅ FILTER: Solo capturar elementos potencialmente interactivos
-      const isInteractive = (element) => {
-        if (!element || element.nodeType !== 1) return false;
-        const interactiveTags = ['a', 'button', 'input', 'select', 'textarea', 'label', 'summary'];
-        const isClickableRole = ['button', 'link', 'checkbox', 'radio', 'menuitem'].includes(element.getAttribute?.('role'));
+/**
+ * Functional fragments: pure context providers.
+ * Uses Environment.runIf for safe access.
+ */
+const CONTEXT_PROVIDERS = {
+  device: {
+    userAgent: () => Environment.runIf('navigator.userAgent', () => navigator.userAgent),
+    language: () => Environment.runIf('navigator.language', () => navigator.language),
+    languages: () => Environment.runIf('navigator.languages', () => navigator.languages),
+    screen: () => Environment.runIf('window.screen', () => ({
+      width: window.screen.width,
+      height: window.screen.height,
+      availWidth: window.screen.availWidth,
+      availHeight: window.screen.availHeight,
+      colorDepth: window.screen.colorDepth,
+      pixelDepth: window.screen.pixelDepth
+    })),
+    timezone: () => Environment.runIf('Intl.DateTimeFormat', () => {
+      try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+      } catch (e) { return null; }
+    }),
+    cookieEnabled: () => Environment.runIf('navigator.cookieEnabled', () => navigator.cookieEnabled),
+    doNotTrack: () => Environment.runIf('navigator.doNotTrack', () => navigator.doNotTrack)
+  },
+  window: {
+    url: () => Environment.runIf('window.location.href', () => window.location.href),
+    pathname: () => Environment.runIf('window.location.pathname', () => window.location.pathname),
+    search: () => Environment.runIf('window.location.search', () => window.location.search),
+    hash: () => Environment.runIf('window.location.hash', () => window.location.hash),
+    referrer: () => Environment.runIf('document.referrer', () => document.referrer),
+    title: () => Environment.runIf('document.title', () => document.title),
+    viewport: () => Environment.runIf('window.innerWidth', () => ({
+      width: window.innerWidth,
+      height: window.innerHeight
+    }))
+  },
+  storage: {
+    localStorage: () => Environment.runIf('localStorage', () => {
+      try {
+        const storage = window.localStorage;
+        return {
+          keys: Object.keys(storage).length,
+          size: JSON.stringify(storage).length,
+          keyNames: Object.keys(storage)
+        };
+      } catch (e) { return null; }
+    }),
+    sessionStorage: () => Environment.runIf('sessionStorage', () => {
+      try {
+        const storage = window.sessionStorage;
+        return {
+          keys: Object.keys(storage).length,
+          size: JSON.stringify(storage).length,
+          keyNames: Object.keys(storage)
+        };
+      } catch (e) { return null; }
+    })
+  },
+  network: {
+    online: () => Environment.runIf('navigator.onLine', () => navigator.onLine),
+    connection: () => Environment.runIf(() => !!(typeof navigator !== 'undefined' && (navigator.connection || navigator.mozConnection || navigator.webkitConnection)), () => {
+      const conn = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+      return {
+        effectiveType: conn.effectiveType,
+        downlink: conn.downlink,
+        rtt: conn.rtt
+      };
+    })
+  },
+  ui: {
+    focused: () => Environment.runIf('document.hasFocus', () => document.hasFocus()),
+    visibility: () => Environment.runIf('document.visibilityState', () => document.visibilityState),
+    activeElement: () => Environment.runIf('document.activeElement', () => ({
+      tagName: document.activeElement.tagName,
+      id: document.activeElement.id,
+      className: document.activeElement.className
+    }))
+  },
+  performance: {
+    memory: () => Environment.runIf('performance.memory', () => ({
+      used: Math.round(performance.memory.usedJSHeapSize / 1048576),
+      total: Math.round(performance.memory.totalJSHeapSize / 1048576),
+      limit: Math.round(performance.memory.jsHeapSizeLimit / 1048576)
+    })),
+    timing: () => Environment.runIf('performance.timing', () => ({
+      navigationStart: performance.timing.navigationStart,
+      loadEventEnd: performance.timing.loadEventEnd
+    }))
+  },
+  session: {
+    sessionId: (collector) => collector.generateSessionId(),
+    startTime: () => new Date().toISOString(),
+    pageLoadTime: () => Environment.runIf('performance.now', () => performance.now())
+  }
+};
 
-        let hasPointerCursor = false;
-        try {
-          hasPointerCursor = window.getComputedStyle?.(element)?.cursor === 'pointer';
-        } catch (e) {
-          // Ignorar errores en entornos donde getComputedStyle falla (ej: JSDOM con mocks incompletos)
-        }
+/**
+ * Default fields for context collection.
+ */
+const DEFAULT_CONTEXT_FIELDS = {
+  device: ['userAgent', 'language', 'screen', 'timezone'],
+  window: ['url', 'viewport', 'title'],
+  session: ['sessionId', 'pageLoadTime'],
+  ui: ['visibility', 'activeElement'],
+  network: ['online', 'connection']
+};
 
-        return interactiveTags.includes(element.tagName.toLowerCase()) || isClickableRole || hasPointerCursor;
-      };
+/**
+ * ContextCollector - Minimal coordinator with no imperative state.
+ */
+class ContextCollector {
+  constructor() {
+    this.sessionId = null;
+    this.providers = new Map(Object.entries(CONTEXT_PROVIDERS));
+  }
 
-      // Si el elemento no es interactivo, buscar hacia arriba en el DOM (bubbling)
-      let target = el;
-      while (target && target !== document.body) {
-        if (isInteractive(target)) break;
-        target = target.parentElement;
-      }
+  /**
+   * Collects context based on a declarative configuration.
+   */
+  collect(contextConfig = {}) {
+    const config = this.normalizeConfig(contextConfig);
 
-      // Si no encontramos un elemento interactivo, ignoramos el click (reduce ruido)
-      if (!target || target === document.body) return;
+    return Object.entries(config).reduce((ctx, [type, options]) => {
+      try {
+        const provider = this.providers.get(type);
+        if (options !== false && !provider) throw new Error(`Provider for '${type}' not found`);
 
-      // Genera un selector CSS simple para identificar el elemento
-      let selector = target.tagName.toLowerCase();
-      if (target.id) {
-        selector += `#${target.id}`;
-      } else if (target.className && typeof target.className === 'string') {
-        selector += `.${target.className.split(' ').filter(Boolean).join('.')}`;
+        const fields = this.resolveFields(type, provider, options);
+        if (fields) {
+          ctx[type] = this.extractFields(provider, fields);
+        }
+      } catch (error) {
+        console.warn(`SyntropyFront: Error collecting context for ${type}:`, error);
+        ctx[type] = { error: 'Collection failed' };
       }
+      return ctx;
+    }, {});
+  }
 
-      breadcrumbStore.add({
-        category: 'ui',
-        message: `Usuario hizo click en '${selector}'`,
-        data: {
-          selector,
-          tagName: target.tagName,
-          id: target.id,
-          className: target.className,
-          text: target.innerText?.substring(0, 30).trim() || target.value?.substring(0, 30)
-        }
-      });
+  /**
+   * Field resolution — declarative strategy map by type.
+   * Contracts:
+   *   boolean true  → default fields for type, or all provider keys
+   *   boolean false → null (skip)
+   *   array         → explicit field list
+   *   plain object  → all provider keys (treated as unstructured custom config)
+   *   other         → null (skip)
+   */
+  resolveFields(type, provider, options) {
+    const allProviderKeys = () => Object.keys(provider || {});
+    const strategies = {
+      boolean: (val) => val ? (DEFAULT_CONTEXT_FIELDS[type] || allProviderKeys()) : null,
+      object: (val) => Array.isArray(val) ? val : allProviderKeys(),
     };
 
-    // Guardar referencia para limpiar después
-    this.eventListeners.set('click', clickHandler);
-    document.addEventListener('click', clickHandler, true);
+    const strategy = strategies[typeof options];
+    return strategy ? strategy(options) : null;
   }
 
   /**
-     * Intercepta llamadas de red (fetch) con Chaining
-     */
-  setupFetchInterceptor() {
-    // Solo configurar en el browser
-    if (typeof window === 'undefined' || !window.fetch) {
-      console.log('SyntropyFront: Fetch interceptor no disponible (no browser/fetch)');
-      return;
+   * Functional normalization of configuration.
+   */
+  normalizeConfig(config) {
+    if (Array.isArray(config)) {
+      return config.reduce((acc, type) => ({ ...acc, [type]: true }), {});
     }
+    return config || {};
+  }
 
-    // Guardar referencia original
-    this.originalHandlers.fetch = window.fetch;
+  /**
+   * Pure field extraction.
+   */
+  extractFields(provider, fieldNames) {
+    return fieldNames.reduce((result, fieldName) => {
+      const getter = provider[fieldName];
+      if (typeof getter !== 'function') return result;
 
-    // Crear nuevo handler que encadena con el original
-    const syntropyFetchHandler = (...args) => {
-      const url = args[0] instanceof Request ? args[0].url : args[0];
-      const method = args[0] instanceof Request ? args[0].method : (args[1]?.method || 'GET');
+      try {
+        result[fieldName] = getter(this);
+      } catch (e) {
+        console.warn(`SyntropyFront: Error collecting field ${fieldName}:`, e);
+        result[fieldName] = null;
+      }
+      return result;
+    }, {});
+  }
 
-      breadcrumbStore.add({
-        category: 'network',
-        message: `Request: ${method} ${url}`,
-        data: {
-          url,
-          method,
-          timestamp: Date.now()
-        }
-      });
+  registerProvider(name, fields) {
+    this.providers.set(name, fields);
+  }
 
-      // ✅ CHAINING: Llamar al handler original
-      return this.originalHandlers.fetch.apply(window, args);
-    };
+  generateSessionId() {
+    this.sessionId = this.sessionId || `session_${this.generateSecureId()}`;
+    return this.sessionId;
+  }
 
-    // Sobrescribir con el nuevo handler
-    window.fetch = syntropyFetchHandler;
+  // Delegates to the pure top-level createSecureId (injectable for testing)
+  generateSecureId(cryptoApi = (typeof crypto !== 'undefined' ? crypto : null)) {
+    return createSecureId(cryptoApi);
   }
 
-  /**
-     * Intercepta errores globales con Chaining
-     */
-  setupErrorInterceptors() {
-    // Solo configurar en el browser
-    if (typeof window === 'undefined') {
-      console.log('SyntropyFront: Error interceptors no disponibles (no browser)');
-      return;
-    }
+  getAvailableTypes() {
+    return Array.from(this.providers.keys());
+  }
 
-    if (this.config.captureErrors) {
-      // Guardar referencia original
-      this.originalHandlers.onerror = window.onerror;
-
-      // Crear nuevo handler que encadena con el original
-      const syntropyErrorHandler = (message, source, lineno, colno, error) => {
-        const errorPayload = {
-          type: 'uncaught_exception',
-          error: {
-            message,
-            source,
-            lineno,
-            colno,
-            stack: error?.stack
-          },
-          breadcrumbs: breadcrumbStore.getAll(),
-          timestamp: new Date().toISOString()
-        };
+  get allFields() {
+    return Array.from(this.providers.entries()).reduce((res, [name, fields]) => {
+      res[name] = fields;
+      return res;
+    }, {});
+  }
 
-        this.handleError(errorPayload);
+  get defaultContexts() {
+    return this.allFields;
+  }
+}
 
-        // ✅ CHAINING: Llamar al handler original si existe
-        if (this.originalHandlers.onerror) {
-          try {
-            return this.originalHandlers.onerror(message, source, lineno, colno, error);
-          } catch (originalError) {
-            console.warn('SyntropyFront: Error en handler original:', originalError);
-            return false;
-          }
-        }
+const contextCollector = new ContextCollector();
 
-        return false; // No prevenir el error por defecto
-      };
+/**
+ * Functional fragments: pure error payload generators.
+ */
+const ERROR_UTILS = {
+  createExceptionPayload: (message, source, lineno, colno, error) => ({
+    type: 'uncaught_exception',
+    error: { message, source, lineno, colno, stack: error?.stack },
+    breadcrumbs: breadcrumbStore.getAll(),
+    timestamp: new Date().toISOString()
+  }),
+
+  createRejectionPayload: (event) => ({
+    type: 'unhandled_rejection',
+    error: {
+      message: event.reason?.message || 'Promise rejection without message',
+      stack: event.reason?.stack,
+    },
+    breadcrumbs: breadcrumbStore.getAll(),
+    timestamp: new Date().toISOString()
+  })
+};
 
-      // Sobrescribir con el nuevo handler
-      window.onerror = syntropyErrorHandler;
-    }
+/**
+ * ErrorInterceptor - Error capture coordinated by functional fragments.
+ * Refactored to remove heavy imperative logic and use FunctionWrapper consistently.
+ */
+class ErrorInterceptor {
+  constructor() {
+    this.errorWrapper = null;
+    this.rejectionWrapper = null;
+    this.config = { captureErrors: true, captureUnhandledRejections: true };
+    this.contextTypes = [];
+    this.onErrorCallback = null;
+  }
 
-    if (this.config.captureUnhandledRejections) {
-      // Guardar referencia original
-      this.originalHandlers.onunhandledrejection = window.onunhandledrejection;
+  /**
+     * Dynamic configuration of the interceptor.
+     */
+  configure(config, contextTypes, onErrorCallback) {
+    this.config = { ...this.config, ...config };
+    this.contextTypes = contextTypes || [];
+    this.onErrorCallback = onErrorCallback;
+  }
 
-      // Crear nuevo handler que encadena con el original
-      const syntropyRejectionHandler = (event) => {
-        const errorPayload = {
-          type: 'unhandled_rejection',
-          error: {
-            message: event.reason?.message || 'Rechazo de promesa sin mensaje',
-            stack: event.reason?.stack,
-          },
-          breadcrumbs: breadcrumbStore.getAll(),
-          timestamp: new Date().toISOString()
-        };
+  /**
+     * Selective initialization.
+     */
+  init() {
+    // Guard: browser environment
+    if (!Environment.isBrowser()) return;
 
-        this.handleError(errorPayload);
+    this.setupExceptionCapture();
+    this.setupRejectionCapture();
+  }
 
-        // ✅ CHAINING: Llamar al handler original si existe
-        if (this.originalHandlers.onunhandledrejection) {
-          try {
-            this.originalHandlers.onunhandledrejection(event);
-          } catch (originalError) {
-            console.warn('SyntropyFront: Error en handler original de rejection:', originalError);
-          }
-        }
-      };
+  /**
+     * Sets up the wrapper for window.onerror (exceptions).
+     */
+  setupExceptionCapture() {
+    // Guard: capture disabled
+    if (!this.config.captureErrors) return;
 
-      // Sobrescribir con el nuevo handler
-      window.onunhandledrejection = syntropyRejectionHandler;
-    }
+    this.errorWrapper = wrap(window, 'onerror', (original) => {
+      return (message, source, lineno, colno, error) => {
+        const payload = ERROR_UTILS.createExceptionPayload(message, source, lineno, colno, error);
+        this.handleError(payload);
+        return safeApply(original, window, [message, source, lineno, colno, error], 'original window.onerror');
+      };
+    });
   }
 
   /**
-     * Maneja los errores capturados
-     * @param {Object} errorPayload - Payload del error
+     * Sets up the wrapper for promise rejections.
      */
-  handleError(errorPayload) {
-    // Recolectar contexto si está configurado
-    const context = this.contextTypes.length > 0 ? contextCollector.collect(this.contextTypes) : null;
+  setupRejectionCapture() {
+    // Guard: capture disabled
+    if (!this.config.captureUnhandledRejections) return;
 
-    // Enviar al agent si está configurado
-    agent.sendError(errorPayload, context);
+    this.rejectionWrapper = wrap(window, 'onunhandledrejection', (original) => {
+      return (event) => {
+        const payload = ERROR_UTILS.createRejectionPayload(event);
+        this.handleError(payload);
+        safeApply(original, window, [event], 'original window.onunhandledrejection');
+      };
+    });
+  }
 
-    // Callback para manejo personalizado de errores
-    if (this.onError) {
-      this.onError(errorPayload);
-    } else {
-      // Comportamiento por defecto: log a consola
-      console.error('SyntropyFront - Error detectado:', errorPayload);
-    }
+  /**
+     * Functional delegation for error handling and send.
+     */
+  handleError(payload) {
+    const context = this.contextTypes.length > 0 ? contextCollector.collect(this.contextTypes) : null;
+    agent.sendError(payload, context);
+    if (this.onErrorCallback) this.onErrorCallback(payload);
   }
 
   /**
-     * Desactiva todos los interceptores y restaura handlers originales
+     * Cleans up wrappers to avoid memory leaks.
      */
   destroy() {
-    if (!this.isInitialized) return;
+    this.errorWrapper?.destroy();
+    this.rejectionWrapper?.destroy();
+    this.errorWrapper = null;
+    this.rejectionWrapper = null;
+  }
+}
 
-    console.log('SyntropyFront: Limpiando interceptores...');
+/**
+ * Copyright 2024 Syntropysoft
+ */
 
-    // ✅ RESTAURAR: Handlers originales
-    if (this.originalHandlers.fetch) {
-      window.fetch = this.originalHandlers.fetch;
-      console.log('SyntropyFront: fetch original restaurado');
-    }
 
-    if (this.originalHandlers.onerror) {
-      window.onerror = this.originalHandlers.onerror;
-      console.log('SyntropyFront: onerror original restaurado');
-    }
+/**
+ * Interceptors - Coordinator for modular interceptors.
+ * Follows SOLID principles by treating interceptors as an extensible collection.
+ * Registry pattern architecture.
+ */
+class Interceptors {
+  constructor() {
+    this.isInitialized = false;
+    this.config = {
+      captureClicks: true,
+      captureFetch: true,
+      captureErrors: true,
+      captureUnhandledRejections: true
+    };
 
-    if (this.originalHandlers.onunhandledrejection) {
-      window.onunhandledrejection = this.originalHandlers.onunhandledrejection;
-      console.log('SyntropyFront: onunhandledrejection original restaurado');
-    }
+    this.registry = new Map();
+    this.initializeRegistry();
+  }
 
-    // ✅ LIMPIAR: Event listeners
-    if (typeof document !== 'undefined') {
-      this.eventListeners.forEach((handler, eventType) => {
-        document.removeEventListener(eventType, handler, true);
-        console.log(`SyntropyFront: Event listener ${eventType} removido`);
-      });
-    }
+  /**
+   * Declarative registration of standard interceptors.
+   */
+  initializeRegistry() {
+    this.registry.set('clicks', new ClickInterceptor());
+    this.registry.set('fetch', new FetchInterceptor());
+    this.registry.set('errors', new ErrorInterceptor());
+  }
 
-    // Limpiar referencias
-    this.originalHandlers = {
-      fetch: null,
-      onerror: null,
-      onunhandledrejection: null
-    };
-    this.eventListeners.clear();
-    this.isInitialized = false;
+  /**
+   * Decoupled configuration.
+   */
+  configure(config = {}) {
+    this.config = { ...this.config, ...config };
+    // Inject config and optional callbacks into interceptors that need them
+    this.registry.get('errors')?.configure?.(this.config, config.context || [], config.onError);
+  }
+
+  /**
+   * Initialization via functional pipeline.
+   */
+  init() {
+    // Guard: already initialized
+    if (this.isInitialized) return;
 
-    console.log('SyntropyFront: Interceptors destruidos y handlers restaurados');
+    this.runLifecycle('init');
+
+    this.isInitialized = true;
+    console.log('SyntropyFront: Interceptors initialized (Refactored architecture)');
   }
 
   /**
-     * Obtiene información sobre los handlers originales
-     * @returns {Object} Información de handlers
-     */
-  getHandlerInfo() {
-    return {
-      isInitialized: this.isInitialized,
-      hasOriginalFetch: !!this.originalHandlers.fetch,
-      hasOriginalOnError: !!this.originalHandlers.onerror,
-      hasOriginalOnUnhandledRejection: !!this.originalHandlers.onunhandledrejection,
-      eventListenersCount: this.eventListeners.size
-    };
+   * Teardown via functional pipeline.
+   */
+  destroy() {
+    // Guard: not initialized
+    if (!this.isInitialized) return;
+
+    this.runLifecycle('destroy');
+
+    this.isInitialized = false;
+    console.log('SyntropyFront: Interceptors destroyed');
   }
+
+  /**
+   * Runs a lifecycle method across the registry based on config.
+   * Functional pipeline: filter -> map -> filter -> forEach.
+   */
+  runLifecycle(method) {
+    const lifecycleMap = [
+      { key: 'clicks', enabled: this.config.captureClicks },
+      { key: 'fetch', enabled: this.config.captureFetch },
+      { key: 'errors', enabled: this.config.captureErrors || this.config.captureUnhandledRejections }
+    ];
+
+    lifecycleMap
+      .filter(item => item.enabled)
+      .map(item => this.registry.get(item.key))
+      .filter(interceptor => interceptor && typeof interceptor[method] === 'function')
+      .forEach(interceptor => interceptor[method]());
+  }
+
+  // Compatibility accessors for tests or controlled direct access
+  get clickInterceptor() { return this.registry.get('clicks'); }
+  get fetchInterceptor() { return this.registry.get('fetch'); }
+  get errorInterceptor() { return this.registry.get('errors'); }
 }
 
-// Instancia singleton
 const interceptors = new Interceptors();
 
 /**
@@ -2729,109 +2944,101 @@ class SyntropyFront {
       captureFetch: true,
       captureErrors: true,
       captureUnhandledRejections: true,
+      samplingRate: 1.0,
       onError: null
     };
 
-    // Auto-inicializar
+    // Auto-initialize
     this.init();
   }
 
   /**
-   * Inicializa la biblioteca y activa los interceptores
+   * Initializes the library and activates interceptors
    */
   init() {
     if (this.isActive) return;
 
-    // Configurar el agent por defecto
-    agent.configure({
-      endpoint: this.config.endpoint,
-      headers: this.config.headers,
-      usePersistentBuffer: this.config.usePersistentBuffer
-    });
-
-    // Inicializar interceptores
-    interceptors.configure({
-      captureClicks: this.config.captureClicks,
-      captureFetch: this.config.captureFetch,
-      captureErrors: this.config.captureErrors,
-      captureUnhandledRejections: this.config.captureUnhandledRejections
-    });
-
-    // Inyectar callback de error si existe
-    if (this.config.onError) {
-      interceptors.onError = this.config.onError;
-    }
-
+    this._applyConfig();
     interceptors.init();
 
-    // Intentar reintentar items fallidos de sesiones previas
+    // Retry failed items from previous sessions
     agent.retryFailedItems().catch(err => {
-      console.warn('SyntropyFront: Error al intentar recuperar items persistentes:', err);
+      console.warn('SyntropyFront: Error attempting to recover persistent items:', err);
     });
 
     this.isActive = true;
-    console.log('🚀 SyntropyFront: Inicializado con arquitectura modular resiliente');
+    console.log('🚀 SyntropyFront: Initialized with modular resilient architecture');
   }
 
   /**
-   * Configura SyntropyFront
-   * @param {Object} config - Configuración
+   * Private: applies current config to agent and interceptors.
    */
-  configure(config = {}) {
-    // Actualizar configuración local
-    this.config = { ...this.config, ...config };
-
-    // Si se pasa 'fetch', extraer endpoint y headers por compatibilidad
-    if (config.fetch) {
-      this.config.endpoint = config.fetch.url;
-      this.config.headers = config.fetch.options?.headers || {};
-    }
-
-    // Re-configurar componentes internos
+  _applyConfig() {
     agent.configure({
       endpoint: this.config.endpoint,
       headers: this.config.headers,
-      usePersistentBuffer: this.config.usePersistentBuffer
+      usePersistentBuffer: this.config.usePersistentBuffer,
+      samplingRate: this.config.samplingRate,
+      batchTimeout: this.config.batchTimeout ?? (this.config.captureClicks || this.config.captureFetch ? 5000 : null)
     });
 
+    breadcrumbStore.onBreadcrumbAdded = (crumb) => {
+      if (agent.isEnabled() && agent.shouldSendBreadcrumbs()) {
+        agent.sendBreadcrumbs([crumb]);
+      }
+    };
+
     interceptors.configure({
       captureClicks: this.config.captureClicks,
       captureFetch: this.config.captureFetch,
       captureErrors: this.config.captureErrors,
-      captureUnhandledRejections: this.config.captureUnhandledRejections
+      captureUnhandledRejections: this.config.captureUnhandledRejections,
+      onError: this.config.onError
     });
+  }
 
-    if (this.config.onError) {
-      interceptors.onError = this.config.onError;
+  /**
+   * Configures SyntropyFront
+   * @param {Object} config - Configuration
+   */
+  configure(config = {}) {
+    this.config = { ...this.config, ...config };
+
+    // If 'fetch' is passed, extract endpoint and headers for compatibility
+    if (config.fetch) {
+      this.config.endpoint = config.fetch.url;
+      this.config.headers = config.fetch.options?.headers || {};
     }
 
+    this._applyConfig();
+
     const mode = this.config.endpoint ? `endpoint: ${this.config.endpoint}` : 'console only';
-    console.log(`✅ SyntropyFront: Configurado - ${mode}`);
+    console.log(`✅ SyntropyFront: Configured - ${mode}`);
   }
 
   /**
-   * Añade un breadcrumb manualmente
+   * Adds a breadcrumb manually
    */
   addBreadcrumb(category, message, data = {}) {
     return breadcrumbStore.add({ category, message, data });
   }
 
   /**
-   * Obtiene todos los breadcrumbs
+   * Gets all breadcrumbs
    */
   getBreadcrumbs() {
     return breadcrumbStore.getAll();
   }
 
   /**
-   * Limpia los breadcrumbs
+   * Clears breadcrumbs
    */
   clearBreadcrumbs() {
     breadcrumbStore.clear();
   }
 
   /**
-   * Envía un error manualmente con contexto
+   * Sends an error manually with context
    */
   sendError(error, context = {}) {
     const errorPayload = {
@@ -2850,14 +3057,14 @@ class SyntropyFront {
   }
 
   /**
-   * Fuerza el envío de datos pendientes
+   * Forces sending pending data
    */
   async flush() {
     await agent.forceFlush();
   }
 
   /**
-   * Obtiene estadísticas de uso
+   * Gets usage statistics
    */
   getStats() {
     return {
@@ -2869,17 +3076,17 @@ class SyntropyFront {
   }
 
   /**
-   * Desactiva la biblioteca y restaura hooks originales
+   * Deactivates the library and restores original hooks
    */
   destroy() {
     interceptors.destroy();
     agent.disable();
     this.isActive = false;
-    console.log('SyntropyFront: Desactivado');
+    console.log('SyntropyFront: Deactivated');
   }
 }
 
-// Instancia única (Singleton)
+// Singleton instance
 const syntropyFront = new SyntropyFront();
 
 export { syntropyFront as default };