wu-framework 1.1.10 → 1.1.12

package/dist/wu-framework.dev.js

@@ -1,15 +1,152 @@
 /*! wu-framework v1.1.8 | MIT License */
+/**
+ * 📝 WU-LOGGER: Sistema de logging inteligente para entornos
+ * Controla los logs automáticamente según el entorno
+ */
+
+class WuLogger {
+  constructor() {
+    // Detectar entorno automáticamente
+    this.isDevelopment = this.detectEnvironment();
+    // En desarrollo: warn (menos ruido), en producción: error
+    this.logLevel = this.isDevelopment ? 'warn' : 'error';
+
+    this.levels = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      silent: 4
+    };
+  }
+
+  /**
+   * Detectar si estamos en desarrollo
+   */
+  detectEnvironment() {
+    // Múltiples formas de detectar desarrollo
+    return (
+      // Vite development
+      window.location.hostname === 'localhost' ||
+      window.location.hostname === '127.0.0.1' ||
+      window.location.port !== '' ||
+      // NODE_ENV si está disponible
+      (typeof process !== 'undefined' && process.env?.NODE_ENV === 'development') ||
+      // URL params para forzar debug
+      new URLSearchParams(window.location.search).has('wu-debug') ||
+      // Manual override
+      window.WU_DEBUG === true
+    );
+  }
+
+  /**
+   * Configurar nivel de logging
+   */
+  setLevel(level) {
+    this.logLevel = level;
+    return this;
+  }
+
+  /**
+   * Habilitar/deshabilitar development mode
+   */
+  setDevelopment(isDev) {
+    this.isDevelopment = isDev;
+    this.logLevel = isDev ? 'debug' : 'error';
+    return this;
+  }
+
+  /**
+   * Verificar si debemos mostrar el log
+   */
+  shouldLog(level) {
+    return this.levels[level] >= this.levels[this.logLevel];
+  }
+
+  /**
+   * Logging methods
+   */
+  debug(...args) {
+    if (this.shouldLog('debug')) {
+      console.log(...args);
+    }
+  }
+
+  info(...args) {
+    if (this.shouldLog('info')) {
+      console.info(...args);
+    }
+  }
+
+  warn(...args) {
+    if (this.shouldLog('warn')) {
+      console.warn(...args);
+    }
+  }
+
+  error(...args) {
+    if (this.shouldLog('error')) {
+      console.error(...args);
+    }
+  }
+
+  /**
+   * Logging con contexto Wu
+   */
+  wu(level, ...args) {
+    if (this.shouldLog(level)) {
+      const method = level === 'debug' ? 'log' : level;
+      console[method]('[Wu]', ...args);
+    }
+  }
+
+  /**
+   * Helper methods específicos para Wu
+   */
+  wuDebug(...args) { this.wu('debug', ...args); }
+  wuInfo(...args) { this.wu('info', ...args); }
+  wuWarn(...args) { this.wu('warn', ...args); }
+  wuError(...args) { this.wu('error', ...args); }
+}
+
+// Singleton instance
+const logger = new WuLogger();
+
+/**
+ * 🔇 Silenciar todos los logs de Wu Framework
+ * Útil en producción para eliminar todo el ruido
+ */
+function silenceAllLogs() {
+  logger.setLevel('silent');
+}
+
+/**
+ * 🔊 Restaurar logs (nivel debug)
+ */
+function enableAllLogs() {
+  logger.setLevel('debug');
+}
+
+var wuLogger = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  WuLogger: WuLogger,
+  enableAllLogs: enableAllLogs,
+  logger: logger,
+  silenceAllLogs: silenceAllLogs
+});
+
 /**
  * 🚀 WU-LOADER: SISTEMA DE CARGA DINÁMICA UNIVERSAL
  * Carga aplicaciones y componentes sin depender del framework
  */
 
+
 class WuLoader {
   constructor() {
     this.cache = new Map();
     this.loadingPromises = new Map();
 
-    console.log('[WuLoader] 📦 Dynamic loader initialized');
+    logger.debug('[WuLoader] 📦 Dynamic loader initialized');
   }
 
   /**
@@ -22,18 +159,18 @@ class WuLoader {
     const entryFile = manifest?.entry || 'index.js';
     const fullUrl = `${appUrl}/${entryFile}`;
 
-    console.log(`[WuLoader] 📥 Loading app from: ${fullUrl}`);
+    logger.debug(`[WuLoader] 📥 Loading app from: ${fullUrl}`);
 
     try {
       // Verificar cache
       if (this.cache.has(fullUrl)) {
-        console.log(`[WuLoader] ⚡ Cache hit for: ${fullUrl}`);
+        logger.debug(`[WuLoader] ⚡ Cache hit for: ${fullUrl}`);
         return this.cache.get(fullUrl);
       }
 
       // Verificar si ya está cargando
       if (this.loadingPromises.has(fullUrl)) {
-        console.log(`[WuLoader] ⏳ Loading in progress for: ${fullUrl}`);
+        logger.debug(`[WuLoader] ⏳ Loading in progress for: ${fullUrl}`);
         return await this.loadingPromises.get(fullUrl);
       }
 
@@ -47,7 +184,7 @@ class WuLoader {
       this.loadingPromises.delete(fullUrl);
       this.cache.set(fullUrl, code);
 
-      console.log(`[WuLoader] ✅ App loaded successfully: ${fullUrl}`);
+      logger.debug(`[WuLoader] ✅ App loaded successfully: ${fullUrl}`);
       return code;
 
     } catch (error) {
@@ -75,7 +212,7 @@ class WuLoader {
 
     const fullUrl = `${appUrl}/${normalizedPath}`;
 
-    console.log(`[WuLoader] 🧩 Loading component from: ${fullUrl}`);
+    logger.debug(`[WuLoader] 🧩 Loading component from: ${fullUrl}`);
 
     try {
       // Cargar código del componente
@@ -92,13 +229,13 @@ class WuLoader {
       // Ejecutar y obtener el componente
       const fakeModule = { exports: {} };
       const fakeRequire = (name) => {
-        console.warn(`[WuLoader] Component ${componentPath} requires ${name} - not supported yet`);
+        logger.warn(`[WuLoader] Component ${componentPath} requires ${name} - not supported yet`);
         return {};
       };
 
       const component = componentFunction(fakeRequire, fakeModule, fakeModule.exports);
 
-      console.log(`[WuLoader] ✅ Component loaded: ${componentPath}`);
+      logger.debug(`[WuLoader] ✅ Component loaded: ${componentPath}`);
       return component;
 
     } catch (error) {
@@ -169,19 +306,19 @@ class WuLoader {
    * @param {Array} appConfigs - Configuraciones de aplicaciones
    */
   async preload(appConfigs) {
-    console.log(`[WuLoader] 🚀 Preloading ${appConfigs.length} apps...`);
+    logger.debug(`[WuLoader] 🚀 Preloading ${appConfigs.length} apps...`);
 
     const preloadPromises = appConfigs.map(async (config) => {
       try {
         await this.loadApp(config.url, config.manifest);
-        console.log(`[WuLoader] ✅ Preloaded: ${config.name}`);
+        logger.debug(`[WuLoader] ✅ Preloaded: ${config.name}`);
       } catch (error) {
-        console.warn(`[WuLoader] ⚠️ Failed to preload ${config.name}:`, error.message);
+        logger.warn(`[WuLoader] ⚠️ Failed to preload ${config.name}:`, error.message);
       }
     });
 
     await Promise.allSettled(preloadPromises);
-    console.log(`[WuLoader] 🎉 Preload completed`);
+    logger.debug(`[WuLoader] 🎉 Preload completed`);
   }
 
   /**
@@ -210,13 +347,13 @@ class WuLoader {
       const [appName, componentName] = importPath.split('.');
 
       if (!appName || !componentName) {
-        console.warn(`[WuLoader] Invalid import format: ${importPath}`);
+        logger.warn(`[WuLoader] Invalid import format: ${importPath}`);
         continue;
       }
 
       const app = availableApps.get(appName);
       if (!app) {
-        console.warn(`[WuLoader] Import app not found: ${appName}`);
+        logger.warn(`[WuLoader] Import app not found: ${appName}`);
         continue;
       }
 
@@ -224,14 +361,14 @@ class WuLoader {
       const exportPath = manifest?.wu?.exports?.[componentName];
 
       if (!exportPath) {
-        console.warn(`[WuLoader] Export not found: ${importPath}`);
+        logger.warn(`[WuLoader] Export not found: ${importPath}`);
         continue;
       }
 
       try {
         const component = await this.loadComponent(app.url, exportPath);
         resolved.set(importPath, component);
-        console.log(`[WuLoader] ✅ Resolved dependency: ${importPath}`);
+        logger.debug(`[WuLoader] ✅ Resolved dependency: ${importPath}`);
       } catch (error) {
         console.error(`[WuLoader] ❌ Failed to resolve: ${importPath}`, error);
       }
@@ -250,12 +387,12 @@ class WuLoader {
       for (const [url] of this.cache) {
         if (regex.test(url)) {
           this.cache.delete(url);
-          console.log(`[WuLoader] 🗑️ Cleared cache for: ${url}`);
+          logger.debug(`[WuLoader] 🗑️ Cleared cache for: ${url}`);
         }
       }
     } else {
       this.cache.clear();
-      console.log(`[WuLoader] 🗑️ Cache cleared completely`);
+      logger.debug(`[WuLoader] 🗑️ Cache cleared completely`);
     }
   }
 
@@ -271,142 +408,6 @@ class WuLoader {
   }
 }
 
-/**
- * 📝 WU-LOGGER: Sistema de logging inteligente para entornos
- * Controla los logs automáticamente según el entorno
- */
-
-class WuLogger {
-  constructor() {
-    // Detectar entorno automáticamente
-    this.isDevelopment = this.detectEnvironment();
-    // En desarrollo: warn (menos ruido), en producción: error
-    this.logLevel = this.isDevelopment ? 'warn' : 'error';
-
-    this.levels = {
-      debug: 0,
-      info: 1,
-      warn: 2,
-      error: 3,
-      silent: 4
-    };
-  }
-
-  /**
-   * Detectar si estamos en desarrollo
-   */
-  detectEnvironment() {
-    // Múltiples formas de detectar desarrollo
-    return (
-      // Vite development
-      window.location.hostname === 'localhost' ||
-      window.location.hostname === '127.0.0.1' ||
-      window.location.port !== '' ||
-      // NODE_ENV si está disponible
-      (typeof process !== 'undefined' && process.env?.NODE_ENV === 'development') ||
-      // URL params para forzar debug
-      new URLSearchParams(window.location.search).has('wu-debug') ||
-      // Manual override
-      window.WU_DEBUG === true
-    );
-  }
-
-  /**
-   * Configurar nivel de logging
-   */
-  setLevel(level) {
-    this.logLevel = level;
-    return this;
-  }
-
-  /**
-   * Habilitar/deshabilitar development mode
-   */
-  setDevelopment(isDev) {
-    this.isDevelopment = isDev;
-    this.logLevel = isDev ? 'debug' : 'error';
-    return this;
-  }
-
-  /**
-   * Verificar si debemos mostrar el log
-   */
-  shouldLog(level) {
-    return this.levels[level] >= this.levels[this.logLevel];
-  }
-
-  /**
-   * Logging methods
-   */
-  debug(...args) {
-    if (this.shouldLog('debug')) {
-      console.log(...args);
-    }
-  }
-
-  info(...args) {
-    if (this.shouldLog('info')) {
-      console.info(...args);
-    }
-  }
-
-  warn(...args) {
-    if (this.shouldLog('warn')) {
-      console.warn(...args);
-    }
-  }
-
-  error(...args) {
-    if (this.shouldLog('error')) {
-      console.error(...args);
-    }
-  }
-
-  /**
-   * Logging con contexto Wu
-   */
-  wu(level, ...args) {
-    if (this.shouldLog(level)) {
-      const method = level === 'debug' ? 'log' : level;
-      console[method]('[Wu]', ...args);
-    }
-  }
-
-  /**
-   * Helper methods específicos para Wu
-   */
-  wuDebug(...args) { this.wu('debug', ...args); }
-  wuInfo(...args) { this.wu('info', ...args); }
-  wuWarn(...args) { this.wu('warn', ...args); }
-  wuError(...args) { this.wu('error', ...args); }
-}
-
-// Singleton instance
-const logger = new WuLogger();
-
-/**
- * 🔇 Silenciar todos los logs de Wu Framework
- * Útil en producción para eliminar todo el ruido
- */
-function silenceAllLogs() {
-  logger.setLevel('silent');
-}
-
-/**
- * 🔊 Restaurar logs (nivel debug)
- */
-function enableAllLogs() {
-  logger.setLevel('debug');
-}
-
-var wuLogger = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  WuLogger: WuLogger,
-  enableAllLogs: enableAllLogs,
-  logger: logger,
-  silenceAllLogs: silenceAllLogs
-});
-
 /**
  * 🎨 WU-STYLE-BRIDGE: SHADOW DOM STYLE SHARING SYSTEM
  *
@@ -2368,6 +2369,7 @@ class WuSandbox {
  * Validación estricta de wu.json para seguridad
  */
 
+
 class WuManifest {
   constructor() {
     this.cache = new Map();
@@ -2427,12 +2429,12 @@ class WuManifest {
   async load(appUrl) {
     const manifestUrl = `${appUrl}/wu.json`;
 
-    console.log(`[WuManifest] 📥 Loading manifest: ${manifestUrl}`);
+    logger.debug(`[WuManifest] 📥 Loading manifest: ${manifestUrl}`);
 
     try {
       // Verificar cache
       if (this.cache.has(manifestUrl)) {
-        console.log(`[WuManifest] ⚡ Cache hit: ${manifestUrl}`);
+        logger.debug(`[WuManifest] ⚡ Cache hit: ${manifestUrl}`);
         return this.cache.get(manifestUrl);
       }
 
@@ -2447,7 +2449,7 @@ class WuManifest {
       if (!response.ok) {
         // Si no hay manifest, crear uno básico
         if (response.status === 404) {
-          console.log(`[WuManifest] 📄 No manifest found, creating default for: ${appUrl}`);
+          logger.debug(`[WuManifest] 📄 No manifest found, creating default for: ${appUrl}`);
           return this.createDefaultManifest(appUrl);
         }
 
@@ -2475,7 +2477,7 @@ class WuManifest {
       // Cachear resultado
       this.cache.set(manifestUrl, validatedManifest);
 
-      console.log(`[WuManifest] ✅ Manifest loaded: ${manifest.name}`);
+      logger.debug(`[WuManifest] ✅ Manifest loaded: ${manifest.name}`);
       return validatedManifest;
 
     } catch (error) {
@@ -2510,7 +2512,7 @@ class WuManifest {
       }
     };
 
-    console.log(`[WuManifest] 🔧 Created default manifest for: ${appName}`);
+    logger.debug(`[WuManifest] 🔧 Created default manifest for: ${appName}`);
     return defaultManifest;
   }
 
@@ -2709,7 +2711,7 @@ class WuManifest {
     // Validar imports
     normalized.wu.imports = normalized.wu.imports.filter(imp => {
       if (typeof imp !== 'string' || !imp.includes('.')) {
-        console.warn(`[WuManifest] Invalid import format: ${imp}`);
+        logger.warn(`[WuManifest] Invalid import format: ${imp}`);
         return false;
       }
       return true;
@@ -2851,12 +2853,12 @@ class WuManifest {
       for (const [url] of this.cache) {
         if (regex.test(url)) {
           this.cache.delete(url);
-          console.log(`[WuManifest] 🗑️ Cleared cache for: ${url}`);
+          logger.debug(`[WuManifest] 🗑️ Cleared cache for: ${url}`);
         }
       }
     } else {
       this.cache.clear();
-      console.log(`[WuManifest] 🗑️ Manifest cache cleared completely`);
+      logger.debug(`[WuManifest] 🗑️ Manifest cache cleared completely`);
     }
   }
 
@@ -3174,6 +3176,7 @@ const store = new WuStore();
  * Mantiene todo el core de wu-framework pero simplifica el uso
  */
 
+
 class WuApp {
   /**
    * @param {string} name - Nombre de la app
@@ -3209,7 +3212,7 @@ class WuApp {
         keepAlive: this.keepAlive,
         status: 'registered'
       });
-      console.log(`📦 App registered: ${this.name} at ${this.url}`);
+      logger.debug(`📦 App registered: ${this.name} at ${this.url}`);
     }
   }
 
@@ -3248,7 +3251,7 @@ class WuApp {
    */
   async unmount(options = {}) {
     if (!this._mounted && !this._wu.isHidden(this.name)) {
-      console.warn(`⚠️ App ${this.name} is not mounted`);
+      logger.warn(`⚠️ App ${this.name} is not mounted`);
       return this
     }
 
@@ -3264,7 +3267,7 @@ class WuApp {
    */
   async hide() {
     if (!this._mounted) {
-      console.warn(`⚠️ App ${this.name} is not mounted`);
+      logger.warn(`⚠️ App ${this.name} is not mounted`);
       return this
     }
 
@@ -3279,7 +3282,7 @@ class WuApp {
    */
   async show() {
     if (!this._wu.isHidden(this.name)) {
-      console.warn(`⚠️ App ${this.name} is not in keep-alive state`);
+      logger.warn(`⚠️ App ${this.name} is not in keep-alive state`);
       return this
     }
 
@@ -3334,7 +3337,7 @@ class WuApp {
    * @returns {Promise<void>}
    */
   async reload() {
-    console.log(`🔄 Reloading app: ${this.name}`);
+    logger.debug(`🔄 Reloading app: ${this.name}`);
 
     await this.unmount();
 
@@ -3347,7 +3350,7 @@ class WuApp {
     }
 
     await this.mount();
-    console.log(`✅ App reloaded: ${this.name}`);
+    logger.debug(`✅ App reloaded: ${this.name}`);
 
     return this
   }
@@ -3398,7 +3401,7 @@ class WuApp {
     await this.unmount({ force: true });
     this._wu.apps.delete(this.name);
     this._mounted = false;
-    console.log(`🗑️ App destroyed: ${this.name}`);
+    logger.debug(`🗑️ App destroyed: ${this.name}`);
   }
 }
 
@@ -3413,6 +3416,7 @@ class WuApp {
  * ⚠️ USO INTERNO: No exponer en API pública
  */
 
+
 class WuCache {
   constructor(options = {}) {
     this.config = {
@@ -3483,7 +3487,7 @@ class WuCache {
       this.rateLimiting.inCooldown = true;
       this.rateLimiting.cooldownUntil = now + this.rateLimiting.cooldownMs;
       this.stats.rateLimited++;
-      console.warn(`[WuCache] 🚫 Rate limit exceeded. Cooldown for ${this.rateLimiting.cooldownMs}ms`);
+      logger.warn(`[WuCache] 🚫 Rate limit exceeded. Cooldown for ${this.rateLimiting.cooldownMs}ms`);
       return false;
     }
 
@@ -3579,7 +3583,7 @@ class WuCache {
       // Verificar si necesitamos hacer espacio
       const hasSpace = this.ensureSpace(entry.size);
       if (hasSpace === false) {
-        console.warn(`[WuCache] ⚠️ Cannot cache item: ${key} (too large)`);
+        logger.warn(`[WuCache] ⚠️ Cannot cache item: ${key} (too large)`);
         return false;
       }
 
@@ -3597,7 +3601,7 @@ class WuCache {
 
       return true;
     } catch (error) {
-      console.warn('[WuCache] ⚠️ Failed to set cache:', error);
+      logger.warn('[WuCache] ⚠️ Failed to set cache:', error);
       return false;
     }
   }
@@ -3632,7 +3636,7 @@ class WuCache {
       this.clearStorage();
     }
 
-    console.log('[WuCache] 🧹 Cache cleared');
+    logger.debug('[WuCache] 🧹 Cache cleared');
   }
 
   /**
@@ -3675,7 +3679,7 @@ class WuCache {
 
     // 🛡️ FIX: Validar que el item no sea más grande que el máximo permitido
     if (neededSize > maxSizeBytes) {
-      console.warn(`[WuCache] ⚠️ Item size (${neededSize}) exceeds max cache size (${maxSizeBytes}). Skipping.`);
+      logger.warn(`[WuCache] ⚠️ Item size (${neededSize}) exceeds max cache size (${maxSizeBytes}). Skipping.`);
       return false;
     }
 
@@ -3692,7 +3696,7 @@ class WuCache {
 
       // 🛡️ FIX: Si el cache está vacío pero aún no hay espacio, salir
       if (this.memoryCache.size === 0) {
-        console.warn('[WuCache] ⚠️ Cache empty but still no space. Breaking loop.');
+        logger.warn('[WuCache] ⚠️ Cache empty but still no space. Breaking loop.');
         break;
       }
 
@@ -3708,7 +3712,7 @@ class WuCache {
       }
 
       if (oldestKey) {
-        console.log(`[WuCache] 🗑️ Evicting LRU entry: ${oldestKey}`);
+        logger.debug(`[WuCache] 🗑️ Evicting LRU entry: ${oldestKey}`);
         this.delete(oldestKey);
         this.stats.evictions++;
       } else {
@@ -3738,7 +3742,7 @@ class WuCache {
         return JSON.parse(stored);
       }
     } catch (error) {
-      console.warn('[WuCache] ⚠️ Failed to get from storage:', error);
+      logger.warn('[WuCache] ⚠️ Failed to get from storage:', error);
     }
     return null;
   }
@@ -3754,13 +3758,13 @@ class WuCache {
       storage.setItem(`wu_cache_${key}`, JSON.stringify(entry));
     } catch (error) {
       // Storage lleno, limpiar entradas antiguas
-      console.warn('[WuCache] ⚠️ Storage full, cleaning old entries');
+      logger.warn('[WuCache] ⚠️ Storage full, cleaning old entries');
       this.cleanOldStorageEntries();
 
       try {
         storage.setItem(`wu_cache_${key}`, JSON.stringify(entry));
       } catch {
-        console.warn('[WuCache] ⚠️ Failed to save to storage after cleanup');
+        logger.warn('[WuCache] ⚠️ Failed to save to storage after cleanup');
       }
     }
   }
@@ -3774,7 +3778,7 @@ class WuCache {
       const storage = this.getStorage();
       storage.removeItem(`wu_cache_${key}`);
     } catch (error) {
-      console.warn('[WuCache] ⚠️ Failed to delete from storage:', error);
+      logger.warn('[WuCache] ⚠️ Failed to delete from storage:', error);
     }
   }
 
@@ -3792,7 +3796,7 @@ class WuCache {
         }
       });
     } catch (error) {
-      console.warn('[WuCache] ⚠️ Failed to clear storage:', error);
+      logger.warn('[WuCache] ⚠️ Failed to clear storage:', error);
     }
   }
 
@@ -3824,9 +3828,9 @@ class WuCache {
         storage.removeItem(entries[i].key);
       }
 
-      console.log(`[WuCache] 🧹 Cleaned ${toRemove} old storage entries`);
+      logger.debug(`[WuCache] 🧹 Cleaned ${toRemove} old storage entries`);
     } catch (error) {
-      console.warn('[WuCache] ⚠️ Failed to clean old storage entries:', error);
+      logger.warn('[WuCache] ⚠️ Failed to clean old storage entries:', error);
     }
   }
 
@@ -3889,6 +3893,7 @@ class WuCache {
  * - Verificación de apps autorizadas
  */
 
+
 class WuEventBus {
   constructor() {
     this.listeners = new Map();
@@ -4018,7 +4023,7 @@ class WuEventBus {
     if (this.config.validateOrigin && this.config.strictMode) {
       if (!this._validateOrigin(eventName, appName, options.token)) {
         this.stats.rejected++;
-        console.warn(`[WuEventBus] 🚫 Event rejected: ${eventName} from ${appName} (unauthorized)`);
+        logger.warn(`[WuEventBus] 🚫 Event rejected: ${eventName} from ${appName} (unauthorized)`);
         return false;
       }
     }
@@ -4040,7 +4045,7 @@ class WuEventBus {
 
     // Log si está habilitado
     if (this.config.logEvents) {
-      console.log(`[WuEventBus] 📢 ${eventName}`, data);
+      logger.debug(`[WuEventBus] 📢 ${eventName}`, data);
     }
 
     // Notificar listeners exactos
@@ -4234,6 +4239,7 @@ class WuEventBus {
  * - Estadísticas por app
  */
 
+
 class WuPerformance {
   constructor() {
     this.metrics = new Map(); // appName -> metrics
@@ -4251,7 +4257,7 @@ class WuPerformance {
       load: 5000 // ms
     };
 
-    console.log('[WuPerformance] ⚡ Framework performance monitoring initialized');
+    logger.debug('[WuPerformance] ⚡ Framework performance monitoring initialized');
   }
 
   /**
@@ -4263,7 +4269,7 @@ class WuPerformance {
     const markName = `${appName}:${name}:start`;
     this.marks.set(markName, performance.now());
 
-    console.log(`[WuPerformance] 📊 Measure started: ${markName}`);
+    logger.debug(`[WuPerformance] 📊 Measure started: ${markName}`);
   }
 
   /**
@@ -4277,7 +4283,7 @@ class WuPerformance {
     const startTime = this.marks.get(markName);
 
     if (!startTime) {
-      console.warn(`[WuPerformance] ⚠️ No start mark found for: ${markName}`);
+      // Puede ocurrir en React StrictMode (doble mount) — no es un error
       return 0;
     }
 
@@ -4295,10 +4301,10 @@ class WuPerformance {
 
     // Verificar threshold
     if (this.checkThreshold(name, duration)) {
-      console.warn(`[WuPerformance] ⚠️ Threshold exceeded for ${name}: ${duration.toFixed(2)}ms`);
+      logger.warn(`[WuPerformance] ⚠️ Threshold exceeded for ${name}: ${duration.toFixed(2)}ms`);
     }
 
-    console.log(`[WuPerformance] ⏹️ Measure ended: ${markName} (${duration.toFixed(2)}ms)`);
+    logger.debug(`[WuPerformance] ⏹️ Measure ended: ${markName} (${duration.toFixed(2)}ms)`);
     return duration;
   }
 
@@ -4430,7 +4436,7 @@ class WuPerformance {
       this.measurements = [];
     }
 
-    console.log(`[WuPerformance] 🧹 Metrics cleared${appName ? ` for ${appName}` : ''}`);
+    logger.debug(`[WuPerformance] 🧹 Metrics cleared${appName ? ` for ${appName}` : ''}`);
   }
 
   /**
@@ -4462,6 +4468,7 @@ class WuPerformance {
  * - Timeout protection
  */
 
+
 class WuPluginSystem {
   constructor(core) {
     this._core = core; // Privado - no expuesto a plugins
@@ -4555,7 +4562,7 @@ class WuPluginSystem {
     // 🚨 Acceso completo solo con permiso 'unsafe'
     if (permissions.includes('unsafe')) {
       api._unsafeCore = this._core;
-      console.warn('[WuPlugin] ⚠️ Plugin has unsafe access to core!');
+      logger.warn('[WuPlugin] ⚠️ Plugin has unsafe access to core!');
     }
 
     // Congelar API para evitar modificaciones
@@ -4620,7 +4627,7 @@ class WuPluginSystem {
 
     // Verificar si ya está instalado
     if (this.plugins.has(plugin.name)) {
-      console.warn(`[WuPlugin] Plugin "${plugin.name}" already installed`);
+      logger.warn(`[WuPlugin] Plugin "${plugin.name}" already installed`);
       return;
     }
 
@@ -4658,7 +4665,7 @@ class WuPluginSystem {
       installedAt: Date.now()
     });
 
-    console.log(`[WuPlugin] ✅ Plugin "${plugin.name}" installed (permissions: ${permissions.join(', ')})`);
+    logger.debug(`[WuPlugin] ✅ Plugin "${plugin.name}" installed (permissions: ${permissions.join(', ')})`);
   }
 
   /**
@@ -4691,7 +4698,7 @@ class WuPluginSystem {
    */
   registerHook(hookName, callback) {
     if (!this.hooks.has(hookName)) {
-      console.warn(`[WuPlugin] Unknown hook: ${hookName}`);
+      logger.warn(`[WuPlugin] Unknown hook: ${hookName}`);
       return;
     }
     this.hooks.get(hookName).push(callback);
@@ -4723,7 +4730,7 @@ class WuPluginSystem {
   uninstall(pluginName) {
     const pluginData = this.plugins.get(pluginName);
     if (!pluginData) {
-      console.warn(`[WuPlugin] Plugin "${pluginName}" not found`);
+      logger.warn(`[WuPlugin] Plugin "${pluginName}" not found`);
       return;
     }
 
@@ -4738,7 +4745,7 @@ class WuPluginSystem {
     }
 
     this.plugins.delete(pluginName);
-    console.log(`[WuPlugin] ✅ Plugin "${pluginName}" uninstalled`);
+    logger.debug(`[WuPlugin] ✅ Plugin "${pluginName}" uninstalled`);
   }
 
   /**
@@ -4809,6 +4816,7 @@ const createPlugin = (config) => {
  * - Idle: Carga cuando el navegador está idle
  */
 
+
 class WuLoadingStrategy {
   constructor(core) {
     this.core = core;
@@ -4819,7 +4827,7 @@ class WuLoadingStrategy {
     this.registerDefaultStrategies();
     this.setupIdleCallback();
 
-    console.log('[WuStrategies] 🎯 Loading strategies initialized');
+    logger.debug('[WuStrategies] 🎯 Loading strategies initialized');
   }
 
   /**
@@ -4830,7 +4838,7 @@ class WuLoadingStrategy {
     this.register('lazy', {
       shouldPreload: false,
       load: async (appName, config) => {
-        console.log(`[Strategy:Lazy] Loading ${appName} on demand (no preload)`);
+        logger.debug(`[Strategy:Lazy] Loading ${appName} on demand (no preload)`);
         // No hace nada, la app se carga cuando se monta
         return;
       }
@@ -4841,14 +4849,14 @@ class WuLoadingStrategy {
       shouldPreload: true,
       priority: 'high',
       load: async (appName, config) => {
-        console.log(`[Strategy:Eager] Preloading ${appName} immediately`);
+        logger.debug(`[Strategy:Eager] Preloading ${appName} immediately`);
 
         // Cargar el módulo de la app
         const app = this.core.apps.get(appName);
         if (app) {
           const moduleUrl = await this.core.resolveModulePath(app);
           await import(/* @vite-ignore */ moduleUrl);
-          console.log(`[Strategy:Eager] ✅ ${appName} preloaded`);
+          logger.debug(`[Strategy:Eager] ✅ ${appName} preloaded`);
         }
       }
     });
@@ -4858,7 +4866,7 @@ class WuLoadingStrategy {
       shouldPreload: true,
       priority: 'medium',
       load: async (appName, config) => {
-        console.log(`[Strategy:Preload] Using resource hints for ${appName}`);
+        logger.debug(`[Strategy:Preload] Using resource hints for ${appName}`);
 
         // Crear <link rel="prefetch">
         const app = this.core.apps.get(appName);
@@ -4871,7 +4879,7 @@ class WuLoadingStrategy {
           link.as = 'script';
           document.head.appendChild(link);
 
-          console.log(`[Strategy:Preload] ✅ Resource hint added for ${appName}`);
+          logger.debug(`[Strategy:Preload] ✅ Resource hint added for ${appName}`);
         }
       }
     });
@@ -4893,7 +4901,7 @@ class WuLoadingStrategy {
     this.register('idle', {
       shouldPreload: false,
       load: async (appName, config) => {
-        console.log(`[Strategy:Idle] Queueing ${appName} for idle loading`);
+        logger.debug(`[Strategy:Idle] Queueing ${appName} for idle loading`);
 
         return new Promise((resolve) => {
           this.loadingQueue.push({
@@ -4928,7 +4936,7 @@ class WuLoadingStrategy {
       load: strategy.load
     });
 
-    console.log(`[WuStrategies] Strategy "${name}" registered`);
+    logger.debug(`[WuStrategies] Strategy "${name}" registered`);
   }
 
   /**
@@ -4942,7 +4950,7 @@ class WuLoadingStrategy {
     const strategy = this.strategies.get(strategyName);
 
     if (!strategy) {
-      console.warn(`[WuStrategies] Strategy "${strategyName}" not found, using lazy`);
+      logger.warn(`[WuStrategies] Strategy "${strategyName}" not found, using lazy`);
       return await this.strategies.get('lazy').load(appName, config);
     }
 
@@ -4967,7 +4975,7 @@ class WuLoadingStrategy {
       return priorityOrder[aPriority] - priorityOrder[bPriority];
     });
 
-    console.log(`[WuStrategies] Preloading ${toPreload.length} apps`);
+    logger.debug(`[WuStrategies] Preloading ${toPreload.length} apps`);
 
     // Precargar en orden
     for (const app of toPreload) {
@@ -5020,7 +5028,7 @@ class WuLoadingStrategy {
         if (app) {
           const moduleUrl = await this.core.resolveModulePath(app);
           await import(/* @vite-ignore */ moduleUrl);
-          console.log(`[Strategy:Idle] ✅ ${item.appName} loaded during idle time`);
+          logger.debug(`[Strategy:Idle] ✅ ${item.appName} loaded during idle time`);
           item.resolve(true);
         } else {
           item.resolve(null);
@@ -5050,7 +5058,7 @@ class WuLoadingStrategy {
    */
   cleanup() {
     this.loadingQueue = [];
-    console.log('[WuStrategies] 🧹 Strategies cleaned up');
+    logger.debug('[WuStrategies] 🧹 Strategies cleaned up');
   }
 }
 
@@ -5064,6 +5072,7 @@ class WuLoadingStrategy {
  * - Fallback rendering
  */
 
+
 class WuErrorBoundary {
   constructor(core) {
     this.core = core;
@@ -5079,7 +5088,7 @@ class WuErrorBoundary {
 
     this.registerDefaultHandlers();
 
-    console.log('[WuErrorBoundary] 🛡️ Error boundary initialized');
+    logger.debug('[WuErrorBoundary] 🛡️ Error boundary initialized');
   }
 
   /**
@@ -5094,12 +5103,12 @@ class WuErrorBoundary {
                (error.message.includes('fetch') || error.message.includes('network'));
       },
       handle: async (error, context) => {
-        console.log('[ErrorHandler:Network] Handling network error');
+        logger.debug('[ErrorHandler:Network] Handling network error');
 
         // Retry con backoff
         if (context.retryCount < this.config.maxRetries) {
           const delay = this.config.retryDelay * Math.pow(2, context.retryCount);
-          console.log(`[ErrorHandler:Network] Retrying in ${delay}ms...`);
+          logger.debug(`[ErrorHandler:Network] Retrying in ${delay}ms...`);
 
         await new Promise(resolve => setTimeout(resolve, delay));
 
@@ -5127,11 +5136,11 @@ class WuErrorBoundary {
                 error.message.includes('Failed to fetch'));
       },
       handle: async (error, context) => {
-        console.log('[ErrorHandler:ScriptLoad] Handling script load error');
+        logger.debug('[ErrorHandler:ScriptLoad] Handling script load error');
 
         // Intentar URL alternativa si existe
         if (context.fallbackUrl) {
-          console.log('[ErrorHandler:ScriptLoad] Trying fallback URL');
+          logger.debug('[ErrorHandler:ScriptLoad] Trying fallback URL');
           return {
             recovered: true,
             action: 'use-fallback-url',
@@ -5154,17 +5163,17 @@ class WuErrorBoundary {
         return error.message && error.message.includes('mount');
       },
       handle: async (error, context) => {
-        console.log('[ErrorHandler:Mount] Handling mount error');
+        logger.debug('[ErrorHandler:Mount] Handling mount error');
 
         // Limpiar y reintentar
         if (context.retryCount < 2) {
-          console.log('[ErrorHandler:Mount] Cleaning up and retrying...');
+          logger.debug('[ErrorHandler:Mount] Cleaning up and retrying...');
 
           // Cleanup
           try {
             await this.core.unmount(context.appName);
           } catch (cleanupError) {
-            console.warn('[ErrorHandler:Mount] Cleanup failed:', cleanupError);
+            logger.warn('[ErrorHandler:Mount] Cleanup failed:', cleanupError);
           }
 
           await new Promise(resolve => setTimeout(resolve, 500));
@@ -5192,7 +5201,7 @@ class WuErrorBoundary {
                error.message.includes('timeout');
       },
       handle: async (error, context) => {
-        console.log('[ErrorHandler:Timeout] Handling timeout error');
+        logger.debug('[ErrorHandler:Timeout] Handling timeout error');
 
         // Aumentar timeout y reintentar
         if (context.retryCount < 2) {
@@ -5217,7 +5226,7 @@ class WuErrorBoundary {
       name: 'generic',
       canHandle: () => true, // Maneja todo
       handle: async (error, context) => {
-        console.log('[ErrorHandler:Generic] Handling generic error');
+        logger.debug('[ErrorHandler:Generic] Handling generic error');
 
         return {
           recovered: false,
@@ -5238,7 +5247,7 @@ class WuErrorBoundary {
     }
 
     this.handlers.push(handler);
-    console.log(`[WuErrorBoundary] Handler "${handler.name}" registered`);
+    logger.debug(`[WuErrorBoundary] Handler "${handler.name}" registered`);
   }
 
   /**
@@ -5262,12 +5271,12 @@ class WuErrorBoundary {
     for (const handler of this.handlers) {
       try {
         if (handler.canHandle(error, context)) {
-          console.log(`[WuErrorBoundary] Using handler: ${handler.name}`);
+          logger.debug(`[WuErrorBoundary] Using handler: ${handler.name}`);
 
           const result = await handler.handle(error, context);
 
           if (result.recovered) {
-            console.log(`[WuErrorBoundary] ✅ Error recovered by ${handler.name}`);
+            logger.debug(`[WuErrorBoundary] ✅ Error recovered by ${handler.name}`);
             return result;
           }
 
@@ -5300,7 +5309,7 @@ class WuErrorBoundary {
    */
   renderFallback(context, result) {
     if (!context.container) {
-      console.warn('[WuErrorBoundary] No container to render fallback');
+      logger.warn('[WuErrorBoundary] No container to render fallback');
       return;
     }
 
@@ -5431,7 +5440,7 @@ class WuErrorBoundary {
    */
   cleanup() {
     this.errorLog = [];
-    console.log('[WuErrorBoundary] 🧹 Error boundary cleaned up');
+    logger.debug('[WuErrorBoundary] 🧹 Error boundary cleaned up');
   }
 }
 
@@ -5446,6 +5455,7 @@ class WuErrorBoundary {
  * - Async/await support
  */
 
+
 class WuLifecycleHooks {
   constructor(core) {
     this.core = core;
@@ -5472,7 +5482,7 @@ class WuLifecycleHooks {
       this.hooks.set(phase, []);
     });
 
-    console.log('[WuHooks] 🪝 Lifecycle hooks initialized');
+    logger.debug('[WuHooks] 🪝 Lifecycle hooks initialized');
   }
 
   /**
@@ -5503,7 +5513,7 @@ class WuLifecycleHooks {
     // Ordenar por prioridad (mayor primero)
     hooks.sort((a, b) => b.priority - a.priority);
 
-    console.log(`[WuHooks] Hook "${hook.name}" registered for ${phase} (priority: ${hook.priority})`);
+    logger.debug(`[WuHooks] Hook "${hook.name}" registered for ${phase} (priority: ${hook.priority})`);
 
     // Retornar función para desregistrar
     return () => this.remove(phase, hook.name);
@@ -5522,7 +5532,7 @@ class WuLifecycleHooks {
 
     if (index > -1) {
       hooks.splice(index, 1);
-      console.log(`[WuHooks] Hook "${name}" removed from ${phase}`);
+      logger.debug(`[WuHooks] Hook "${name}" removed from ${phase}`);
     }
   }
 
@@ -5539,7 +5549,7 @@ class WuLifecycleHooks {
       return context;
     }
 
-    console.log(`[WuHooks] Executing ${hooks.length} hooks for ${phase}`);
+    logger.debug(`[WuHooks] Executing ${hooks.length} hooks for ${phase}`);
 
     // Log para debugging
     const executionEntry = {
@@ -5583,13 +5593,13 @@ class WuLifecycleHooks {
 
         // Si no se llamó next(), la operación fue cancelada
         if (!nextCalled) {
-          console.log(`[WuHooks] Hook "${hook.name}" cancelled execution`);
+          logger.debug(`[WuHooks] Hook "${hook.name}" cancelled execution`);
           cancelled = true;
           return { cancelled: true };
         }
 
         const duration = Date.now() - startTime;
-        console.log(`[WuHooks] Hook "${hook.name}" executed in ${duration}ms`);
+        logger.debug(`[WuHooks] Hook "${hook.name}" executed in ${duration}ms`);
 
       } catch (error) {
         console.error(`[WuHooks] Error in hook "${hook.name}":`, error);
@@ -5694,13 +5704,13 @@ class WuLifecycleHooks {
   cleanup(phase) {
     if (phase) {
       this.hooks.set(phase, []);
-      console.log(`[WuHooks] Hooks cleaned for ${phase}`);
+      logger.debug(`[WuHooks] Hooks cleaned for ${phase}`);
     } else {
       this.lifecyclePhases.forEach(p => {
         this.hooks.set(p, []);
       });
       this.executionLog = [];
-      console.log('[WuHooks] 🧹 All hooks cleaned');
+      logger.debug('[WuHooks] 🧹 All hooks cleaned');
     }
   }
 }
@@ -14908,7 +14918,7 @@ function createMcpBridge(wu) {
 
   function connect(url = 'ws://localhost:19100', options = {}) {
     if (ws && ws.readyState <= 1) {
-      console.warn('[wu-mcp-bridge] Already connected or connecting');
+      logger.warn('[wu-mcp-bridge] Already connected or connecting');
       return;
     }
 
@@ -14919,7 +14929,7 @@ function createMcpBridge(wu) {
       ws = new WebSocket(url);
 
       ws.onopen = () => {
-        console.log('[wu-mcp-bridge] Connected to wu-mcp-server');
+        logger.debug('[wu-mcp-bridge] Connected to wu-mcp-server');
         reconnectAttempts = 0;
 
         // Send auth handshake if token provided
@@ -14942,7 +14952,7 @@ function createMcpBridge(wu) {
               console.error('[wu-mcp-bridge] Authentication failed:', msg.reason || 'Invalid token');
               disconnect();
             } else {
-              console.log('[wu-mcp-bridge] Authenticated successfully');
+              logger.debug('[wu-mcp-bridge] Authenticated successfully');
             }
             return;
           }
@@ -14958,7 +14968,7 @@ function createMcpBridge(wu) {
           const { id, command, params } = msg;
 
           if (!id || !command) {
-            console.warn('[wu-mcp-bridge] Invalid message:', msg);
+            logger.warn('[wu-mcp-bridge] Invalid message:', msg);
             return;
           }
 
@@ -14980,7 +14990,7 @@ function createMcpBridge(wu) {
       };
 
       ws.onclose = () => {
-        console.log('[wu-mcp-bridge] Disconnected');
+        logger.debug('[wu-mcp-bridge] Disconnected');
         ws = null;
         authenticated = false;
         _scheduleReconnect(url, options);