wu-framework 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wu-framework",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "🚀 Universal Microfrontends Framework - Framework agnostic, zero config, Shadow DOM isolation",
   "main": "src/index.js",
   "type": "module",

package/src/core/wu-cache.js

@@ -102,7 +102,11 @@ export class WuCache {
       };
 
       // Verificar si necesitamos hacer espacio
-      this.ensureSpace(entry.size);
+      const hasSpace = this.ensureSpace(entry.size);
+      if (hasSpace === false) {
+        console.warn(`[WuCache] ⚠️ Cannot cache item: ${key} (too large)`);
+        return false;
+      }
 
       // Guardar en memoria
       this.memoryCache.set(key, entry);
@@ -194,9 +198,28 @@ export class WuCache {
   ensureSpace(neededSize) {
     const maxSizeBytes = this.config.maxSize * 1024 * 1024;
 
+    // 🛡️ 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.`);
+      return false;
+    }
+
+    // 🛡️ FIX: Límite de iteraciones para evitar loop infinito
+    const maxIterations = this.config.maxItems + 10;
+    let iterations = 0;
+
     // Verificar si necesitamos limpiar
-    while (this.stats.size + neededSize > maxSizeBytes ||
-           this.memoryCache.size >= this.config.maxItems) {
+    while ((this.stats.size + neededSize > maxSizeBytes ||
+           this.memoryCache.size >= this.config.maxItems) &&
+           iterations < maxIterations) {
+
+      iterations++;
+
+      // 🛡️ 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.');
+        break;
+      }
 
       // Encontrar entrada menos recientemente usada (LRU)
       let oldestKey = null;
@@ -217,6 +240,13 @@ export class WuCache {
         break;
       }
     }
+
+    // 🛡️ FIX: Log si alcanzamos el límite de iteraciones
+    if (iterations >= maxIterations) {
+      console.error(`[WuCache] 🚨 Max eviction iterations reached (${maxIterations}). Possible infinite loop prevented.`);
+    }
+
+    return true;
   }
 
   /**

package/src/core/wu-core.js

@@ -104,56 +104,79 @@ export class WuCore {
   }
 
   /**
-   * 🔍 SMART MUTATION OBSERVER: Real-time DOM monitoring for efficiency
+   * 🔍 SMART MUTATION OBSERVER: Observa SOLO los contenedores de apps montadas
+   * FIX: Ya no observa todo document.body (memory leak)
    */
   initializeMutationObserver() {
-    if (!window.MutationObserver) return; // Fallback for older browsers
+    if (!window.MutationObserver) return;
 
-    this.healthState.mutationObserver = new MutationObserver((mutations) => {
-      let shouldCheckHealth = false;
+    // Map para trackear observers por contenedor (evita memory leak)
+    this.healthState.containerObservers = new Map();
+
+    // Callback compartido para todos los observers
+    this.healthState.mutationCallback = (mutations, observer) => {
+      let affectedAppName = null;
 
       for (const mutation of mutations) {
-        // Only check health if it affects our mounted apps
-        if (mutation.type === 'childList') {
-          const removedNodes = Array.from(mutation.removedNodes);
-          const affectedApps = removedNodes.some(node => {
-            if (node.nodeType === Node.ELEMENT_NODE) {
-              // Check if removed node contains any of our mounted apps
-              for (const [appName, mounted] of this.mounted) {
-                if (node.contains && node.contains(mounted.container)) {
-                  return true;
-                }
-                if (node === mounted.container) {
-                  return true;
-                }
-              }
+        if (mutation.type === 'childList' && mutation.removedNodes.length > 0) {
+          // Encontrar qué app fue afectada
+          for (const [appName, mounted] of this.mounted) {
+            const container = mounted.hostContainer || mounted.container;
+            if (mutation.target === container ||
+                mutation.target.contains?.(container)) {
+              affectedAppName = appName;
+              break;
             }
-            return false;
-          });
-
-          if (affectedApps) {
-            shouldCheckHealth = true;
-            break;
           }
         }
+        if (affectedAppName) break;
       }
 
-      // Debounced health check only when necessary
-      if (shouldCheckHealth) {
+      if (affectedAppName) {
         clearTimeout(this.healthState.mutationCheckTimeout);
         this.healthState.mutationCheckTimeout = setTimeout(() => {
           this.performHealthCheck();
-        }, 1000); // Wait 1 second to batch multiple mutations
+        }, 1000);
       }
-    });
+    };
+
+    logger.wuDebug('🔍 MutationObserver system initialized (lazy per-container)');
+  }
+
+  /**
+   * 🔗 Observar contenedor específico cuando se monta una app
+   */
+  observeContainer(appName, container) {
+    if (!this.healthState.containerObservers || !container) return;
+
+    // No observar si ya existe
+    if (this.healthState.containerObservers.has(appName)) return;
 
-    // Observe the entire document but only care about child changes
-    this.healthState.mutationObserver.observe(document.body, {
+    const observer = new MutationObserver(this.healthState.mutationCallback);
+
+    // Observar solo el contenedor padre directo (no subtree profundo)
+    const parentToObserve = container.parentElement || container;
+    observer.observe(parentToObserve, {
       childList: true,
-      subtree: true
+      subtree: false  // ✅ Solo hijos directos, no todo el árbol
     });
 
-    logger.wuDebug('🔍 MutationObserver initialized for smart DOM monitoring');
+    this.healthState.containerObservers.set(appName, observer);
+    logger.wuDebug(`🔍 Observing container for ${appName}`);
+  }
+
+  /**
+   * 🔓 Dejar de observar contenedor cuando se desmonta
+   */
+  unobserveContainer(appName) {
+    if (!this.healthState.containerObservers) return;
+
+    const observer = this.healthState.containerObservers.get(appName);
+    if (observer) {
+      observer.disconnect();
+      this.healthState.containerObservers.delete(appName);
+      logger.wuDebug(`🔓 Stopped observing container for ${appName}`);
+    }
   }
 
   /**
@@ -606,10 +629,14 @@ export class WuCore {
         poolSandbox,
         lifecycle,
         container: sandbox.container,
+        hostContainer: container,
         timestamp: Date.now(),
         state: 'stable'
       });
 
+      // 🔍 Observar contenedor para health monitoring (sin memory leak)
+      this.observeContainer(appName, container);
+
       // ⚡ End performance measurement
       const mountTime = this.performance.endMeasure('mount', appName);
 
@@ -1017,6 +1044,7 @@ export class WuCore {
   /**
    * 📦 MODULE LOADER: Advanced registration patterns
    * Handles asynchronous registration with timing synchronization
+   * FIX: Verifica que definitions tenga el lifecycle después de cargar
    */
   async moduleLoader(moduleUrl, appName) {
     // ✅ Check if already registered
@@ -1027,16 +1055,37 @@ export class WuCore {
 
     console.log(`[Wu] 📡 Using event-based registration for ${appName}`);
 
-    // 🔔 Use event-based waiting (no polling!)
-    const registrationPromise = this.registry.waitForApp(appName, 10000);
+    // 🚀 Load module first
+    try {
+      await import(/* @vite-ignore */ moduleUrl);
+    } catch (loadError) {
+      console.error(`[Wu] ❌ Failed to import module ${moduleUrl}:`, loadError);
+      throw loadError;
+    }
 
-    // 🚀 Load module asynchronously
-    const moduleLoadPromise = import(/* @vite-ignore */ moduleUrl);
+    // 🛡️ FIX: Esperar a que wu.define() se ejecute con verificación real
+    const maxWaitTime = 10000; // 10 segundos
+    const checkInterval = 50; // Verificar cada 50ms
+    const startTime = Date.now();
+
+    while (!this.definitions.has(appName)) {
+      const elapsed = Date.now() - startTime;
+
+      if (elapsed >= maxWaitTime) {
+        throw new Error(
+          `App '${appName}' module loaded but wu.define() was not called within ${maxWaitTime}ms.\n\n` +
+          `Make sure your module calls:\n` +
+          `  wu.define('${appName}', { mount, unmount })\n\n` +
+          `Or using window.wu:\n` +
+          `  window.wu.define('${appName}', { mount, unmount })`
+        );
+      }
 
-    // 🌌 Wait for both operations to complete
-    await Promise.all([moduleLoadPromise, registrationPromise]);
+      // Esperar un poco antes de verificar de nuevo
+      await new Promise(resolve => setTimeout(resolve, checkInterval));
+    }
 
-    console.log(`[Wu] ✅ App ${appName} loaded and registered via events`);
+    console.log(`[Wu] ✅ App ${appName} loaded and registered (verified in definitions)`);
   }
 
   /**
@@ -1080,6 +1129,9 @@ export class WuCore {
         this.sandboxPool.release(appName);
       }
 
+      // 🔓 Dejar de observar contenedor (evita memory leak)
+      this.unobserveContainer(appName);
+
       // Remover del registro de montadas
       this.mounted.delete(appName);
 
@@ -1243,10 +1295,12 @@ export class WuCore {
         this.healthState.monitor = null;
       }
 
-      // Limpiar MutationObserver
-      if (this.healthState.mutationObserver) {
-        this.healthState.mutationObserver.disconnect();
-        this.healthState.mutationObserver = null;
+      // Limpiar todos los MutationObservers por contenedor
+      if (this.healthState.containerObservers) {
+        for (const [appName, observer] of this.healthState.containerObservers) {
+          observer.disconnect();
+        }
+        this.healthState.containerObservers.clear();
       }
 
       // Limpiar timeouts pendientes

package/src/core/wu-logger.js

@@ -7,7 +7,8 @@ export class WuLogger {
   constructor() {
     // Detectar entorno automáticamente
     this.isDevelopment = this.detectEnvironment();
-    this.logLevel = this.isDevelopment ? 'debug' : 'error';
+    // En desarrollo: warn (menos ruido), en producción: error
+    this.logLevel = this.isDevelopment ? 'warn' : 'error';
 
     this.levels = {
       debug: 0,
@@ -116,4 +117,19 @@ export const wuLog = {
   info: (...args) => logger.wuInfo(...args),
   warn: (...args) => logger.wuWarn(...args),
   error: (...args) => logger.wuError(...args)
-};
+};
+
+/**
+ * 🔇 Silenciar todos los logs de Wu Framework
+ * Útil en producción para eliminar todo el ruido
+ */
+export function silenceAllLogs() {
+  logger.setLevel('silent');
+}
+
+/**
+ * 🔊 Restaurar logs (nivel debug)
+ */
+export function enableAllLogs() {
+  logger.setLevel('debug');
+}

package/src/core/wu-registry.js

@@ -1,52 +1,21 @@
 /**
- * 🔔 WU-REGISTRY: EVENT-BASED APP REGISTRATION SYSTEM
- *
- * Reemplaza el polling con Custom Events para mejor performance
+ * 🔔 WU-REGISTRY: APP REGISTRATION TRACKER
+ * Simplificado - solo trackea apps registradas
  */
 
 export class WuRegistry {
   constructor() {
     this.registeredApps = new Set();
-    this.waitingPromises = new Map();
-
-    // Event listeners para registro
-    this.setupEventListeners();
-
-    console.log('[WuRegistry] 🔔 Event-based registration system initialized');
-  }
-
-  /**
-   * 📡 SETUP EVENT LISTENERS
-   */
-  setupEventListeners() {
-    // Escuchar eventos de registro de apps
-    window.addEventListener('wu:app:ready', (event) => {
-      const { appName } = event.detail;
-      console.log(`[WuRegistry] ✅ App registered via event: ${appName}`);
-
-      this.registeredApps.add(appName);
-
-      // Resolver promesas pendientes
-      if (this.waitingPromises.has(appName)) {
-        const { resolve } = this.waitingPromises.get(appName);
-        resolve();
-        this.waitingPromises.delete(appName);
-      }
-    });
-
-    // API para que apps notifiquen que están listas (se agrega a window.wu cuando exista)
-    // No crear window.wu aquí - eso lo hace index.js con la instancia completa
     this._setupNotifyReady();
   }
 
   /**
-   * 🔔 Setup notifyReady API cuando window.wu esté disponible
+   * 🔔 Setup notifyReady API en window.wu
    */
   _setupNotifyReady() {
     const setupFn = () => {
       if (window.wu && !window.wu.notifyReady) {
         window.wu.notifyReady = (appName) => {
-          console.log(`[WuRegistry] 📢 App ${appName} called notifyReady()`);
           const event = new CustomEvent('wu:app:ready', {
             detail: { appName, timestamp: Date.now() }
           });
@@ -55,89 +24,37 @@ export class WuRegistry {
       }
     };
 
-    // Intentar setup inmediato
     setupFn();
-
-    // Si window.wu no existe aún, esperar un tick
     if (!window.wu) {
       queueMicrotask(setupFn);
     }
   }
 
   /**
-   * ⏳ WAIT FOR APP: Promise-based waiting
-   * @param {string} appName - Nombre de la app
-   * @param {number} timeout - Timeout en ms (default: 10000)
-   * @returns {Promise}
+   * ✅ MARK AS REGISTERED
    */
-  waitForApp(appName, timeout = 10000) {
-    // Si ya está registrada, resolver inmediatamente
-    if (this.registeredApps.has(appName)) {
-      console.log(`[WuRegistry] ⚡ App ${appName} already registered`);
-      return Promise.resolve();
-    }
-
-    console.log(`[WuRegistry] ⏳ Waiting for app ${appName} to register...`);
-
-    return new Promise((resolve, reject) => {
-      // Guardar promesa
-      this.waitingPromises.set(appName, { resolve, reject });
-
-      // Timeout
-      const timeoutId = setTimeout(() => {
-        if (this.waitingPromises.has(appName)) {
-          this.waitingPromises.delete(appName);
-
-          const error = new Error(
-            `App '${appName}' failed to register within ${timeout}ms.\n\n` +
-            `Possible causes:\n` +
-            `  - Module failed to load\n` +
-            `  - wu.define() was not called\n` +
-            `  - Check browser console for import errors\n\n` +
-            `Make sure your app calls:\n` +
-            `  wu.define('${appName}', { mount, unmount })`
-          );
-
-          reject(error);
-        }
-      }, timeout);
-
-      // Limpiar timeout cuando se resuelva
-      this.waitingPromises.get(appName).timeoutId = timeoutId;
-    });
+  markAsRegistered(appName) {
+    this.registeredApps.add(appName);
   }
 
   /**
-   * ✅ MARK AS REGISTERED
-   * @param {string} appName
+   * ❓ IS REGISTERED
    */
-  markAsRegistered(appName) {
-    this.registeredApps.add(appName);
-    console.log(`[WuRegistry] ✅ App ${appName} marked as registered`);
+  isRegistered(appName) {
+    return this.registeredApps.has(appName);
   }
 
   /**
    * ❌ UNREGISTER APP
-   * @param {string} appName
    */
   unregister(appName) {
     this.registeredApps.delete(appName);
-    console.log(`[WuRegistry] ❌ App ${appName} unregistered`);
   }
 
   /**
    * 🧹 CLEANUP
    */
   cleanup() {
-    // Rechazar todas las promesas pendientes
-    for (const [appName, { reject, timeoutId }] of this.waitingPromises) {
-      clearTimeout(timeoutId);
-      reject(new Error(`Registry cleanup: ${appName}`));
-    }
-
-    this.waitingPromises.clear();
     this.registeredApps.clear();
-
-    console.log('[WuRegistry] 🧹 Registry cleaned up');
   }
 }

package/src/index.js

@@ -103,7 +103,7 @@ if (typeof window !== 'undefined') {
 
   // Configurar propiedades si no existen
   if (!wu.version) {
-    wu.version = '1.0.3';
+    wu.version = '1.0.5';
     console.log('🚀 Wu Framework loaded - Universal Microfrontends ready');
     wu.info = {
       name: 'Wu Framework',
@@ -126,6 +126,19 @@ if (typeof window !== 'undefined') {
     wu.once = (eventName, callback) => wu.eventBus.once(eventName, callback);
     wu.off = (eventName, callback) => wu.eventBus.off(eventName, callback);
   }
+
+  // 🔇 Exponer funciones de control de logs
+  // window.wu.silence() para silenciar, window.wu.verbose() para debug
+  if (!wu.silence) {
+    wu.silence = async () => {
+      const { silenceAllLogs } = await import('./core/wu-logger.js');
+      silenceAllLogs();
+    };
+    wu.verbose = async () => {
+      const { enableAllLogs } = await import('./core/wu-logger.js');
+      enableAllLogs();
+    };
+  }
 }
 
 // Exportar API principal
@@ -167,6 +180,7 @@ export {
 } from './core/wu-hooks.js';
 export { WuSandboxPool } from './core/wu-sandbox-pool.js';
 export { WuRegistry } from './core/wu-registry.js';
+export { silenceAllLogs, enableAllLogs } from './core/wu-logger.js';
 
 /**
  * Utilidades de conveniencia para uso común

package/src/api/wu-simple.js

@@ -1,316 +0,0 @@
-/**
- * 🚀 WU-FRAMEWORK SIMPLIFIED API
- * Developer-friendly interface for universal microfrontends
- */
-
-import { wu as wuCore } from '../index.js'
-import { logger } from '../core/wu-logger.js'
-
-class WuSimpleAPI {
-  constructor() {
-    this.core = wuCore
-    this.autoInitialized = false
-    this.defaultConfig = {
-      container: '#app',
-      mode: 'auto', // auto, spa, microfrontend
-      debug: false,
-      timeout: 30000,
-      retries: 3
-    }
-  }
-
-  /**
-   * 🌟 SMART MOUNT: Intelligent mounting with auto-discovery
-   * wu.mount('dashboard').into('#container')
-   * wu.mount('http://localhost:3001/dashboard')
-   */
-  mount(appNameOrUrl) {
-    const mountAPI = {
-      into: async (containerSelector = this.defaultConfig.container) => {
-        await this._ensureInitialized()
-
-        // 🔍 Detect if it's a URL or app name
-        if (this._isUrl(appNameOrUrl)) {
-          return await this._mountFromUrl(appNameOrUrl, containerSelector)
-        } else {
-          return await this._mountFromName(appNameOrUrl, containerSelector)
-        }
-      }
-    }
-
-    // Support direct call: wu.mount('dashboard', '#container')
-    if (typeof arguments[1] === 'string') {
-      return mountAPI.into(arguments[1])
-    }
-
-    return mountAPI
-  }
-
-  /**
-   * 🚀 QUICK LOAD: One-liner for loading remote microfrontends
-   * wu.load('http://localhost:3001/dashboard')
-   * wu.load('http://localhost:3001', { name: 'dashboard' })
-   */
-  async load(url, options = {}) {
-    await this._ensureInitialized()
-
-    const appName = options.name || this._extractAppName(url)
-    const container = options.container || this.defaultConfig.container
-
-    // Auto-register and mount
-    await this._registerFromUrl(url, appName)
-    return await this.mount(appName).into(container)
-  }
-
-  /**
-   * 🎯 BATCH OPERATIONS: Load multiple apps at once
-   * wu.loadMany([
-   *   { name: 'dashboard', url: 'http://localhost:3001' },
-   *   { name: 'sidebar', url: 'http://localhost:3002' }
-   * ])
-   */
-  async loadMany(apps) {
-    await this._ensureInitialized()
-
-    const results = []
-    for (const app of apps) {
-      try {
-        await this._registerFromUrl(app.url, app.name)
-        results.push({ name: app.name, status: 'registered' })
-      } catch (error) {
-        results.push({ name: app.name, status: 'failed', error: error.message })
-      }
-    }
-
-    return results
-  }
-
-  /**
-   * 🔧 CONFIGURATION: Flexible configuration methods
-   * wu.config({ debug: true, timeout: 60000 })
-   * wu.debug(true)
-   * wu.timeout(30000)
-   */
-  config(options = {}) {
-    Object.assign(this.defaultConfig, options)
-
-    if (options.debug) {
-      logger.wuDebug('🔧 Configuration updated:', this.defaultConfig)
-    }
-
-    return this
-  }
-
-  /**
-   * 🐛 DEBUG MODE: Quick debug toggle
-   * wu.debug(true)
-   * wu.debug() // toggle
-   */
-  debug(enabled) {
-    if (enabled === undefined) {
-      this.defaultConfig.debug = !this.defaultConfig.debug
-    } else {
-      this.defaultConfig.debug = !!enabled
-    }
-
-    logger.wuInfo(`🐛 Debug mode: ${this.defaultConfig.debug ? 'ON' : 'OFF'}`)
-    return this
-  }
-
-  /**
-   * ⏱️ TIMEOUT: Set operation timeout
-   * wu.timeout(60000) // 60 seconds
-   */
-  timeout(ms) {
-    this.defaultConfig.timeout = ms
-    logger.wuDebug(`⏱️ Timeout set to ${ms}ms`)
-    return this
-  }
-
-  /**
-   * 🔄 RETRIES: Set retry attempts
-   * wu.retries(5)
-   */
-  retries(count) {
-    this.defaultConfig.retries = count
-    logger.wuDebug(`🔄 Retries set to ${count}`)
-    return this
-  }
-
-  /**
-   * 🎯 DEFAULT CONTAINER: Set default mounting container
-   * wu.container('#main-app')
-   */
-  container(selector) {
-    this.defaultConfig.container = selector
-    logger.wuDebug(`🎯 Default container set to ${selector}`)
-    return this
-  }
-
-  /**
-   * 🌐 GLOBAL SETTINGS: Environment-based configuration
-   * wu.development() // Sets debug: true, retries: 1
-   * wu.production()  // Sets debug: false, retries: 3
-   */
-  development() {
-    return this.config({
-      debug: true,
-      retries: 1,
-      timeout: 60000
-    })
-  }
-
-  production() {
-    return this.config({
-      debug: false,
-      retries: 3,
-      timeout: 30000
-    })
-  }
-
-  /**
-   * 🚀 QUICK SETUP: Common configurations
-   * wu.spa() // Single Page App mode
-   * wu.micro() // Microfrontend mode
-   */
-  spa() {
-    return this.config({
-      mode: 'spa',
-      container: '#app',
-      debug: false
-    })
-  }
-
-  micro() {
-    return this.config({
-      mode: 'microfrontend',
-      debug: true,
-      retries: 5
-    })
-  }
-
-  /**
-   * 📊 STATUS: Get framework and apps status
-   * wu.status()
-   */
-  status() {
-    const stats = this.core.getStats?.() || {}
-
-    return {
-      initialized: this.autoInitialized,
-      apps: {
-        registered: stats.registered || 0,
-        mounted: stats.mounted || 0,
-        available: stats.apps || []
-      },
-      health: this.core.quantumState?.dimensionalStability || 'unknown',
-      config: this.defaultConfig
-    }
-  }
-
-  /**
-   * 🧹 CLEANUP: Clean shutdown
-   * wu.destroy()
-   */
-  async destroy() {
-    if (this.core.destroy) {
-      await this.core.destroy()
-    }
-    this.autoInitialized = false
-    logger.wuInfo('🧹 Framework destroyed')
-  }
-
-
-  // 🔒 PRIVATE METHODS
-
-  async _ensureInitialized() {
-    if (!this.autoInitialized) {
-      await this._autoInitialize()
-    }
-  }
-
-  async _autoInitialize() {
-    if (this.defaultConfig.debug) {
-      logger.wuDebug('🚀 Auto-initializing Wu Framework...')
-    }
-
-    // Smart initialization with minimal config
-    await this.core.init({ apps: [] })
-    this.autoInitialized = true
-
-    if (this.defaultConfig.debug) {
-      logger.wuDebug('✅ Wu Framework auto-initialized')
-    }
-  }
-
-  _isUrl(str) {
-    try {
-      new URL(str)
-      return true
-    } catch {
-      return str.includes('://') || str.startsWith('http')
-    }
-  }
-
-  _extractAppName(url) {
-    try {
-      const urlObj = new URL(url)
-      const pathSegments = urlObj.pathname.split('/').filter(Boolean)
-      return pathSegments[pathSegments.length - 1] || urlObj.hostname.split('.')[0]
-    } catch {
-      return 'app-' + Date.now()
-    }
-  }
-
-  async _registerFromUrl(url, appName) {
-    const baseUrl = this._getBaseUrl(url)
-
-    await this.core.registerApp({
-      name: appName,
-      url: baseUrl
-    })
-  }
-
-  _getBaseUrl(url) {
-    try {
-      const urlObj = new URL(url)
-      return `${urlObj.protocol}//${urlObj.host}`
-    } catch {
-      return url
-    }
-  }
-
-  async _mountFromUrl(url, containerSelector) {
-    const appName = this._extractAppName(url)
-    await this._registerFromUrl(url, appName)
-    return await this._mountFromName(appName, containerSelector)
-  }
-
-  async _mountFromName(appName, containerSelector) {
-    try {
-      await this.core.mount(appName, containerSelector)
-
-      if (this.defaultConfig.debug) {
-        logger.wuDebug(`✅ ${appName} mounted successfully in ${containerSelector}`)
-      }
-
-      return {
-        app: appName,
-        container: containerSelector,
-        status: 'mounted',
-        unmount: () => this.core.unmount(appName)
-      }
-
-    } catch (error) {
-      console.error(`[Wu] ❌ Failed to mount ${appName}:`, error.message)
-      throw new Error(`Failed to mount ${appName}: ${error.message}`)
-    }
-  }
-}
-
-// 🌟 Create singleton instance
-const wuSimple = new WuSimpleAPI()
-
-// 🎯 Export simple API
-export { wuSimple as wu }
-export default wuSimple