wu-framework 2.1.2 → 2.5.0

package/dist/wu-framework.dev.js

@@ -1,150 +1,8 @@
-/*! wu-framework v2.1.1 | MIT License */
+/*! wu-framework v2.5.0 | MIT License */
+import { logger } from './core/wu-logger.js';
+export { enableAllLogs, silenceAllLogs } from './core/wu-logger.js';
 export { WuLoader } from './core/wu-loader.js';
 
-/**
- * 📝 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() {
-    // 1. Explicit flag takes priority
-    if (typeof window !== 'undefined' && window.WU_DEBUG === true) return true;
-    if (typeof window !== 'undefined' && window.WU_DEBUG === false) return false;
-
-    // 2. NODE_ENV check (works in bundlers and Node)
-    if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production') return false;
-    if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'development') return true;
-
-    // 3. Browser heuristics (only if window exists)
-    if (typeof window !== 'undefined' && window.location) {
-      const hostname = window.location.hostname;
-      if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]') return true;
-
-      // URL param override
-      try {
-        if (new URLSearchParams(window.location.search).has('wu-debug')) return true;
-      } catch {}
-    }
-
-    // 4. Default: assume production
-    return false;
-  }
-
-  /**
-   * 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
  *
@@ -509,12 +367,20 @@ class WuStyleBridge {
   injectInlineStyle(shadowRoot, style) {
     // Verificar si ya existe
     const viteId = style.viteId;
+    const contentHash = viteId ? null : this._hashStyleContent(style.content);
     if (viteId) {
       const existing = shadowRoot.querySelector(`style[data-wu-vite-id="${viteId}"]`);
       if (existing) {
         logger.debug(`[WuStyleBridge] ⏭️ Inline style already exists: ${viteId}`);
         return;
       }
+    } else {
+      // Sin viteId (ej. CSS-in-JS runtime): dedup por hash de contenido
+      const existing = shadowRoot.querySelector(`style[data-wu-content-hash="${contentHash}"]`);
+      if (existing) {
+        logger.debug(`[WuStyleBridge] ⏭️ Inline style already exists (content hash: ${contentHash})`);
+        return;
+      }
     }
 
     // Crear nuevo style tag
@@ -524,6 +390,8 @@ class WuStyleBridge {
     styleTag.setAttribute('data-wu-library', style.library || 'unknown');
     if (viteId) {
       styleTag.setAttribute('data-wu-vite-id', viteId);
+    } else {
+      styleTag.setAttribute('data-wu-content-hash', contentHash);
     }
 
     // Insertar al principio del shadow root
@@ -532,6 +400,19 @@ class WuStyleBridge {
     logger.debug(`[WuStyleBridge] 📝 Injected inline style: ${style.library || viteId}`);
   }
 
+  /**
+   * #️⃣ HASH DE CONTENIDO: Hash rápido (djb2) para dedup de estilos inline sin viteId
+   * @param {string} content
+   * @returns {string}
+   */
+  _hashStyleContent(content) {
+    let hash = 5381;
+    for (let i = 0; i < content.length; i++) {
+      hash = ((hash << 5) + hash + content.charCodeAt(i)) | 0;
+    }
+    return `${content.length}_${(hash >>> 0).toString(36)}`;
+  }
+
   /**
    * 📋 INYECTAR ADOPTED STYLESHEET: Comparte stylesheet constructable
    * @param {ShadowRoot} shadowRoot
@@ -2524,6 +2405,10 @@ class WuStore {
     // Pattern listeners for wildcards
     this.patternListeners = new Map();
 
+    // Low-level write taps (WuTimeline journaling). Lazily allocated — null
+    // until something taps in, so the common path pays zero overhead.
+    this._taps = null;
+
     // Performance metrics
     this.metrics = {
       reads: 0,
@@ -2594,6 +2479,15 @@ class WuStore {
     // Update state synchronously
     this.updateState(path, value);
 
+    // Synchronous low-level taps (journaling). Fired with the real sequence
+    // number so WuTimeline's entries align with the ring-buffer order.
+    if (this._taps && this._taps.size) {
+      for (const tap of this._taps) {
+        try { tap(sequence, path, value); }
+        catch (error) { console.error('[WuStore] Tap error:', error); }
+      }
+    }
+
     // Schedule async notifications (non-blocking)
     queueMicrotask(() => {
       this.notify(path, value);
@@ -2603,6 +2497,40 @@ class WuStore {
     return sequence;
   }
 
+  /**
+   * Register a low-level write tap. Unlike on(), taps fire synchronously
+   * inside set() for EVERY write with the ring-buffer sequence number — the
+   * substrate WuTimeline journals from. Returns an unsubscribe function.
+   * @param {(sequence: number, path: string, value: *) => void} fn
+   * @returns {Function} unsubscribe
+   */
+  tap(fn) {
+    if (typeof fn !== 'function') return () => {};
+    if (!this._taps) this._taps = new Set();
+    this._taps.add(fn);
+    return () => { this._taps?.delete(fn); };
+  }
+
+  /**
+   * Replace the whole state and re-notify listeners — the seek primitive for
+   * WuTimeline. Does NOT touch the ring buffer, cursor, or taps, so a rewind
+   * is invisible to journaling (no feedback loop). Notification is synchronous
+   * (an explicit seek should reflect immediately), guarded per-listener.
+   *
+   * @param {Object} newState - The state to install
+   * @param {Object} [opts]
+   * @param {string[]} [opts.notifyPaths] - Paths to re-notify (default: top-level keys)
+   */
+  hydrate(newState, { notifyPaths } = {}) {
+    this.state = (newState && typeof newState === 'object') ? newState : {};
+    const paths = notifyPaths || Object.keys(this.state);
+    for (const path of paths) {
+      const value = this.get(path);
+      this.notify(path, value);
+      this.notifyPatterns(path, value);
+    }
+  }
+
   /**
    * Subscribe to state changes
    * @param {string} pattern - Path or pattern (supports * wildcard)
@@ -2791,6 +2719,87 @@ class WuStore {
     return regex.test(path);
   }
 
+  /**
+   * Start real-time collaborative sync of this store across replicas — tabs
+   * (BroadcastChannel), workers, or clients (WebSocket) — conflict-free via a
+   * per-path Last-Writer-Wins CRDT. Writes made after sync() propagate to
+   * peers; remote writes merge in and notify subscribers. Lazy-loads the sync
+   * chunk (zero cost until called). See ROADMAP.md (#2).
+   *
+   * @param {Object} [opts]
+   * @param {'broadcast'|WebSocket|string|{send,onMessage,close}} [opts.transport='broadcast']
+   * @param {string} [opts.room='default'] - Channel name for the broadcast transport
+   * @returns {{ stop: Function, status: Function, ready: Function, connected: boolean, instance: any }}
+   *
+   * @example
+   * wu.store.sync({ transport: 'broadcast', room: 'cart' });  // cross-tab
+   * wu.store.sync({ transport: 'wss://sync.example/doc-42' }); // cross-client
+   */
+  sync(opts = {}) {
+    // One active sync per store. A second call returns the existing handle
+    // (different opts are ignored — stop() first to reconfigure).
+    if (this._syncHandle && !this._syncHandle._stopped) {
+      console.warn('[WuStore] sync() already active — returning the existing handle. stop() it first to reconfigure.');
+      return this._syncHandle;
+    }
+
+    const store = this;
+    let inst = null;
+    let loading = null;
+    let stopped = false;
+    let error = null;
+
+    const ensure = () => {
+      if (inst) return Promise.resolve(inst);
+      if (!loading) {
+        loading = import('./core/wu-store-sync.js')
+          .then(({ WuStoreSync }) => {
+            if (stopped) return null;          // stop() raced ahead of the load
+            const s = new WuStoreSync(store);
+            s.connect(opts);                   // may throw (resolveTransport)
+            inst = s;                          // assign ONLY after connect succeeds
+            return inst;
+          })
+          .catch((err) => {
+            // A failed connect must not wedge the one-sync-per-store guard.
+            // Clear it so a later sync() can retry; resolve to null (honest
+            // no-op) rather than rejecting (no unhandled-rejection surprise).
+            error = err;
+            if (store._syncHandle === handle) store._syncHandle = null;
+            console.warn('[WuStore] sync() failed to connect:', err?.message || err);
+            return null;
+          });
+      }
+      return loading;
+    };
+
+    const handle = {
+      stop() {
+        stopped = true; this._stopped = true;
+        if (store._syncHandle === handle) store._syncHandle = null;
+        if (inst) inst.stop();
+      },
+      status() {
+        if (inst) return inst.status();
+        // Stable shape across the load boundary (mirrors the loaded status()).
+        return {
+          connected: false, site: null, lamport: 0, peers: 0, tracked: 0,
+          sent: 0, received: 0, applied: 0, ignored: 0, dropped: 0,
+          loading: !stopped && !error, stopped,
+          error: error ? String(error.message || error) : null,
+        };
+      },
+      ready() { return ensure(); },           // await to guarantee the connection
+      get connected() { return inst ? inst.status().connected : false; },
+      get instance() { return inst; },
+      _stopped: false,
+    };
+
+    this._syncHandle = handle;
+    ensure();
+    return handle;
+  }
+
   /**
    * Clear all state and listeners
    */
@@ -2900,6 +2909,13 @@ class WuApp {
       await this._wu.init({
         apps: [{ name: this.name, url: this.url }]
       });
+    } else if (!this._wu.apps.get(this.name)?.manifest) {
+      // wu ya estaba inicializado: cargar el manifest de esta app
+      await this._wu.registerApp({
+        name: this.name,
+        url: this.url,
+        keepAlive: this.keepAlive
+      });
     }
 
     // Montar usando wu-framework core
@@ -2923,7 +2939,7 @@ class WuApp {
     }
 
     await this._wu.unmount(this.name, options);
-    this._mounted = !this._wu.isHidden(this.name);
+    this._mounted = false;
 
     return this
   }
@@ -3261,9 +3277,20 @@ class WuCache {
     if (this.config.persistent) {
       const stored = this.getFromStorage(key);
       if (stored) {
-        // Restaurar a memoria
-        this.memoryCache.set(key, stored);
-        this.accessOrder.set(key, Date.now());
+        // Verificar TTL
+        if (this.isExpired(stored)) {
+          this.delete(key);
+          this.stats.misses++;
+          return null;
+        }
+
+        // Restaurar a memoria (evicción solo en memoria: una lectura no
+        // debe borrar copias persistentes de otras claves)
+        if (this.ensureSpace(stored.size || 0, { demoteOnly: true }) !== false) {
+          this.memoryCache.set(key, stored);
+          this.accessOrder.set(key, Date.now());
+          this.stats.size += stored.size || 0;
+        }
         this.stats.hits++;
         return stored.value;
       }
@@ -3303,7 +3330,11 @@ class WuCache {
         return false;
       }
 
-      // Guardar en memoria
+      // Guardar en memoria (descontar la entrada previa si se sobreescribe)
+      const existing = this.memoryCache.get(key);
+      if (existing) {
+        this.stats.size -= existing.size;
+      }
       this.memoryCache.set(key, entry);
       this.accessOrder.set(key, Date.now());
 
@@ -3390,7 +3421,7 @@ class WuCache {
    * 🎯 ENSURE SPACE: Asegurar espacio en cache (LRU eviction)
    * @param {number} neededSize - Tamaño necesario
    */
-  ensureSpace(neededSize) {
+  ensureSpace(neededSize, { demoteOnly = false } = {}) {
     const maxSizeBytes = this.config.maxSize * 1024 * 1024;
 
     // 🛡️ FIX: Validar que el item no sea más grande que el máximo permitido
@@ -3429,7 +3460,16 @@ class WuCache {
 
       if (oldestKey) {
         logger.debug(`[WuCache] 🗑️ Evicting LRU entry: ${oldestKey}`);
-        this.delete(oldestKey);
+        if (demoteOnly) {
+          // Memory-only eviction: keep the persistent copy so the evicted
+          // entry stays restorable (a read must never destroy other keys)
+          const evicted = this.memoryCache.get(oldestKey);
+          if (evicted) this.stats.size -= evicted.size;
+          this.memoryCache.delete(oldestKey);
+          this.accessOrder.delete(oldestKey);
+        } else {
+          this.delete(oldestKey);
+        }
         this.stats.evictions++;
       } else {
         break;
@@ -3634,6 +3674,12 @@ class WuEventBus {
     this.listeners = new Map();
     this.history = [];
 
+    // Low-level emit taps (WuTimeline journaling). Lazily allocated — null
+    // until something taps in. Unlike on('*'), taps fire after history is
+    // recorded and bypass wildcard-regex matching, so journaling is cheap and
+    // never affected by an app's authorization scope.
+    this._taps = null;
+
     // Cache of compiled wildcard patterns. Avoids `new RegExp()` per emit per listener.
     this._wildcardCache = new Map();
 
@@ -3857,11 +3903,23 @@ class WuEventBus {
       verified: this.authorizedApps.has(appName)
     };
 
-    // Agregar a historial
-    if (this.config.enableReplay) {
+    // Agregar a historial. `options.history === false` skips it — for
+    // internal firehose events (e.g. WuTimeline's timeline:* lifecycle) that
+    // would otherwise flood the bounded history and evict real app events from
+    // it and from wu.inspect().events.recent. Listeners still receive them.
+    if (this.config.enableReplay && options.history !== false) {
       this.addToHistory(event);
     }
 
+    // Low-level taps (journaling) fire before listener dispatch, so a throwing
+    // listener can't stop an event from being recorded.
+    if (this._taps && this._taps.size) {
+      for (const tap of this._taps) {
+        try { tap(event); }
+        catch (error) { console.error('[WuEventBus] Tap error:', error); }
+      }
+    }
+
     // Log si está habilitado
     if (this.config.logEvents) {
       logger.debug(`[WuEventBus] 📢 ${eventName}`, data);
@@ -3888,6 +3946,21 @@ class WuEventBus {
     return true;
   }
 
+  /**
+   * 📼 TAP: Register a low-level emit tap. Fires for EVERY emitted event
+   * (after history, before listeners), receiving the full event object.
+   * Bypasses wildcard matching and authorization — it's a framework-internal
+   * firehose for WuTimeline journaling. Returns an unsubscribe function.
+   * @param {(event: WuEvent) => void} fn
+   * @returns {Function} unsubscribe
+   */
+  tap(fn) {
+    if (typeof fn !== 'function') return () => {};
+    if (!this._taps) this._taps = new Set();
+    this._taps.add(fn);
+    return () => { this._taps?.delete(fn); };
+  }
+
   /**
    * 👂 ON: Suscribirse a evento
    */
@@ -3921,8 +3994,8 @@ class WuEventBus {
    */
   once(eventName, callback) {
     const wrappedCallback = (event) => {
-      callback(event);
       this.off(eventName, wrappedCallback);
+      callback(event);
     };
     return this.on(eventName, wrappedCallback);
   }
@@ -4222,6 +4295,11 @@ class WuPerformance {
     const appMetrics = this.metrics.get(measurement.appName);
     appMetrics.measurements.push(measurement);
 
+    // Mantener tamaño máximo por app
+    if (appMetrics.measurements.length > this.config.maxMeasurements) {
+      appMetrics.measurements.shift();
+    }
+
     // Calcular estadísticas
     this.calculateStats(measurement.appName);
   }
@@ -4699,11 +4777,13 @@ class WuPluginSystem {
     }
 
     // Registrar hooks del plugin con protección
+    const registeredHooks = [];
     this.availableHooks.forEach(hookName => {
       if (typeof plugin[hookName] === 'function') {
         // Wrap el hook con timeout y try-catch
         const wrappedHook = this._wrapHook(plugin[hookName].bind(plugin), plugin.name, hookName);
         this.registerHook(hookName, wrappedHook);
+        registeredHooks.push({ hookName, callback: wrappedHook });
       }
     });
 
@@ -4713,6 +4793,7 @@ class WuPluginSystem {
       options,
       permissions,
       sandboxedApi,
+      registeredHooks,
       installedAt: Date.now()
     });
 
@@ -4759,7 +4840,9 @@ class WuPluginSystem {
    * 🎯 CALL HOOK
    */
   async callHook(hookName, context) {
-    const callbacks = this.hooks.get(hookName) || [];
+    // Snapshot: uninstall() splices these arrays and would shift the
+    // iterator past the next plugin's hook mid-dispatch
+    const callbacks = [...(this.hooks.get(hookName) || [])];
 
     for (const callback of callbacks) {
       try {
@@ -4785,7 +4868,7 @@ class WuPluginSystem {
       return;
     }
 
-    const { plugin, sandboxedApi } = pluginData;
+    const { plugin, sandboxedApi, registeredHooks } = pluginData;
 
     if (plugin.uninstall) {
       try {
@@ -4795,6 +4878,17 @@ class WuPluginSystem {
       }
     }
 
+    // Remover los hooks registrados por el plugin
+    if (registeredHooks) {
+      for (const { hookName, callback } of registeredHooks) {
+        const callbacks = this.hooks.get(hookName);
+        if (callbacks) {
+          const index = callbacks.indexOf(callback);
+          if (index > -1) callbacks.splice(index, 1);
+        }
+      }
+    }
+
     this.plugins.delete(pluginName);
     logger.debug(`[WuPlugin] ✅ Plugin "${pluginName}" uninstalled`);
   }
@@ -5018,6 +5112,10 @@ class WuLoadingStrategy {
   async preload(apps) {
     const toPreload = apps.filter(app => {
       const strategy = this.strategies.get(app.strategy || 'lazy');
+      if (!strategy) {
+        logger.warn(`[WuStrategies] Strategy "${app.strategy}" not found, using lazy`);
+        return false;
+      }
       return strategy.shouldPreload;
     });
 
@@ -5561,6 +5659,8 @@ class WuLifecycleHooks {
       'afterLoad',       // Después de cargar
       'beforeMount',     // Antes de montar
       'afterMount',      // Después de montar
+      'beforeUpdate',    // Antes de empujar props vivas (wu.update)
+      'afterUpdate',     // Después de empujar props vivas
       'beforeUnmount',   // Antes de desmontar
       'afterUnmount',    // Después de desmontar
       'beforeDestroy',   // Antes de destruir framework
@@ -5661,10 +5761,9 @@ class WuLifecycleHooks {
 
       const hook = hooks[index];
       const startTime = Date.now();
+      let nextCalled = false;
 
       try {
-        let nextCalled = false;
-
         // Función next
         const next = async (modifiedContext) => {
           nextCalled = true;
@@ -5694,8 +5793,16 @@ class WuLifecycleHooks {
       } catch (error) {
         console.error(`[WuHooks] Error in hook "${hook.name}":`, error);
 
-        // Si hay error, pasar al siguiente hook
-        return await executeChain(index + 1);
+        // Si hay error antes de llamar next(), pasar al siguiente hook.
+        // Si next() ya se llamó, los hooks siguientes ya se ejecutaron.
+        if (!nextCalled) {
+          return await executeChain(index + 1);
+        }
+      }
+
+      // Propagar cancelación de hooks posteriores en la cadena
+      if (cancelled) {
+        return { cancelled: true };
       }
 
       return currentContext;
@@ -5996,15 +6103,16 @@ class WuPrefetch {
     const urls = await this._resolveAppUrls(appNames);
     if (urls.length === 0) return;
 
-    // Mark all as prefetched by name (prevents duplicate resolution)
-    urls.forEach(({ name }) => this.prefetched.add(name));
-
     // Strategy 1: Speculation Rules API (Chrome 121+)
+    // (_addSpeculationRules marks the names as prefetched itself)
     if (this.supportsSpeculationRules) {
       this._addSpeculationRules(urls, options.eagerness || 'moderate');
       return;
     }
 
+    // Mark all as prefetched by name (prevents duplicate resolution)
+    urls.forEach(({ name }) => this.prefetched.add(name));
+
     // Strategy 2: <link rel="modulepreload"> for ES modules
     if (this.supportsModulePreload) {
       urls.forEach(({ url }) => this._injectModulePreload(url));
@@ -6819,6 +6927,413 @@ class WuOverrides {
   }
 }
 
+/**
+ * WU-SEMVER: minimal semantic-version range matching (zero-dep).
+ *
+ * Enough for capability-contract negotiation (`wu.consume('cart', '^2.0')`),
+ * not a full node-semver. Supports:
+ *   - exact:       1.2.3
+ *   - X-ranges:    1, 1.2, 1.x, *, "" (match anything)
+ *   - caret:       ^1.2.3   (compatible within the leftmost non-zero)
+ *   - tilde:       ~1.2.3   (patch-level within the minor)
+ *   - comparators: >=  >  <=  <  =
+ *   - AND:         ">=1.0.0 <2.0.0" (space-separated)
+ *   - OR:          "^1.0 || ^2.0"
+ * Prerelease / build metadata is stripped (compared on major.minor.patch).
+ */
+
+function num(x) {
+  const n = parseInt(x, 10);
+  return Number.isNaN(n) ? 0 : n;
+}
+
+/** Parse a version string to a [major, minor, patch] tuple. */
+function parseVersion(v) {
+  const core = String(v).trim().replace(/^[v=\s]+/, '').split('+')[0].split('-')[0];
+  const parts = core.split('.');
+  return [num(parts[0]), num(parts[1]), num(parts[2])];
+}
+
+/** Compare two versions (string or parsed tuple): -1 | 0 | 1. */
+function compareVersions(a, b) {
+  const pa = Array.isArray(a) ? a : parseVersion(a);
+  const pb = Array.isArray(b) ? b : parseVersion(b);
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] !== pb[i]) return pa[i] < pb[i] ? -1 : 1;
+  }
+  return 0;
+}
+
+function satisfiesComparator(version, raw) {
+  const comp = raw.trim();
+  if (comp === '' || comp === '*' || comp === 'x' || comp === 'X') return true;
+
+  // caret (^) / tilde (~)
+  if (comp[0] === '^' || comp[0] === '~') {
+    const caret = comp[0] === '^';
+    const spec = comp.slice(1).trim();
+    const base = parseVersion(spec);
+    if (compareVersions(version, base) < 0) return false;
+    // Count only CONCRETE leading components (x/X/* are unspecified), so the
+    // upper bound for partial / zero ranges matches npm's X-range desugaring.
+    const specifiedCount = spec
+      .replace(/^[v=]+/, '').split('+')[0].split('-')[0]
+      .split('.').filter((p) => p !== '' && p !== 'x' && p !== 'X' && p !== '*').length;
+    let upper;
+    if (caret) {
+      // ^1.2.3 → <2; ^0.2.3 → <0.3; ^0.0.3 → <0.0.4; but ^0 → <1, ^0.0 → <0.1
+      // (the leftmost non-zero rule needs how many components were written).
+      if (base[0] > 0) upper = [base[0] + 1, 0, 0];
+      else if (specifiedCount < 2) upper = [1, 0, 0];
+      else if (base[1] > 0) upper = [0, base[1] + 1, 0];
+      else if (specifiedCount < 3) upper = [0, 1, 0];
+      else upper = [0, 0, base[2] + 1];
+    } else {
+      // ~1.2.3 / ~1.2 → <1.3.0 ; ~1 → <2.0.0
+      upper = specifiedCount >= 2 ? [base[0], base[1] + 1, 0] : [base[0] + 1, 0, 0];
+    }
+    return compareVersions(parseVersion(version), upper) < 0;
+  }
+
+  // explicit comparator
+  const m = comp.match(/^(>=|<=|>|<|=)\s*(.+)$/);
+  if (m) {
+    const c = compareVersions(version, parseVersion(m[2]));
+    switch (m[1]) {
+      case '>': return c > 0;
+      case '>=': return c >= 0;
+      case '<': return c < 0;
+      case '<=': return c <= 0;
+      default: return c === 0; // '='
+    }
+  }
+
+  // bare version → X-range if partial / wildcarded, else exact
+  const rawParts = comp.replace(/^[v=]+/, '').split('+')[0].split('-')[0].split('.');
+  const wildcarded = rawParts.some((p) => p === 'x' || p === 'X' || p === '*');
+  if (rawParts.length < 3 || wildcarded) {
+    const vp = parseVersion(version);
+    for (let i = 0; i < 3; i++) {
+      const rp = rawParts[i];
+      if (rp === undefined || rp === '' || rp === 'x' || rp === 'X' || rp === '*') continue;
+      if (vp[i] !== num(rp)) return false;
+    }
+    return true;
+  }
+  return compareVersions(version, parseVersion(comp)) === 0;
+}
+
+/**
+ * Does `version` satisfy `range`?
+ * @param {string} version - e.g. "2.3.0"
+ * @param {string} range   - e.g. "^2.0", "~1.2.3", ">=1.0.0 <2.0.0", "1.x || 2.x"
+ * @returns {boolean}
+ */
+function satisfies(version, range) {
+  if (range === null || range === undefined || range === '' || range === '*') return true;
+  return String(range).split('||').some((group) =>
+    group.trim().split(/\s+/).filter(Boolean).every((comp) => satisfiesComparator(version, comp))
+  );
+}
+
+/**
+ * WU-CONTRACTS: typed, versioned, runtime-verified capability contracts.
+ *
+ * Kills Module Federation's worst failure mode — silent shared-singleton
+ * version skew that explodes at runtime as `undefined is not a function`.
+ * Instead of sharing fragile singletons, independently-deployed micro-apps
+ * declare what they OFFER and what they NEED, and the runtime negotiates and
+ * verifies:
+ *
+ *   // Provider (team Cart, deployed independently)
+ *   wu.provide('cart', { add(item){…}, get count(){…} }, { version: '2.3.0', app: 'cart' });
+ *
+ *   // Consumer (team Header)
+ *   const cart = wu.consume('cart', '^2.0');   // honest failure if unsatisfied
+ *   cart.add(product);
+ *
+ * - Semver negotiation: `consume('cart','^2.0')` against the provider's declared
+ *   version; a mismatch fails LOUDLY ("cart@1.4 does not satisfy ^2.0") instead
+ *   of MF's silent breakage.
+ * - Runtime shape verification: an impl that drifts from its declared interface
+ *   fails at provide() time, not at the consumer's call site.
+ * - Lifecycle-aware: consume() returns a LIVE proxy that re-resolves on every
+ *   access, so a capability becoming unavailable (provider unmounts) yields a
+ *   clear "no provider for 'cart'" — never a stale reference. Capabilities are
+ *   auto-revoked when their providing app unmounts.
+ * - Event-backed: `wu:capability:provided` / `wu:capability:revoked` let late
+ *   consumers `await wu.consume('cart','^2.0',{ wait:true })`.
+ *
+ * Eager (in the main bundle, like the store and event bus) — provide/consume
+ * must work synchronously the moment an app mounts.
+ */
+
+
+class WuContracts {
+  /**
+   * @param {object} core - The WuCore instance (for the event bus + lifecycle).
+   */
+  constructor(core) {
+    this.core = core;
+    this._providers = new Map();   // name -> { impl, version, app, shape, providedAt }
+    this._waiters = new Map();     // name -> Set<{ range, resolve, reject, timer }>
+    // NOTE: auto-revoke on app unmount is driven by WuCore._executeUnmount
+    // calling revokeByApp() with the FRAMEWORK-VERIFIED app name — NOT by
+    // listening to the app:unmounted bus event. The bus treats any 'app:'
+    // event as system-trusted (no token), so a malicious micro-app could forge
+    // app:unmounted with a rival's appName to revoke its capability. Driving it
+    // from the core's own unmount path closes that spoofing vector.
+  }
+
+  /**
+   * Register a capability implementation.
+   * @param {string} name
+   * @param {object|Function} impl
+   * @param {object} [opts]
+   * @param {string} [opts.version='0.0.0'] - Semver the impl satisfies
+   * @param {string[]|Object<string,string>} [opts.shape] - Required keys, or key→typeof
+   * @param {string} [opts.app] - Providing app; the capability auto-revokes on its unmount
+   * @returns {{ revoke: Function }}
+   */
+  provide(name, impl, opts = {}) {
+    if (!name || typeof name !== 'string') {
+      throw new Error('[WuContracts] provide() requires a capability name (string).');
+    }
+    if (impl === null || impl === undefined || (typeof impl !== 'object' && typeof impl !== 'function')) {
+      throw new Error(`[WuContracts] provide('${name}') requires an implementation object or function.`);
+    }
+    const version = opts.version || '0.0.0';
+    if (opts.shape) this._verifyShape(name, impl, opts.shape, version);
+
+    const prev = this._providers.get(name);
+    if (prev && prev.version !== version) {
+      logger.wuDebug?.(`[WuContracts] '${name}' re-provided: ${prev.version} → ${version}`);
+    }
+
+    const record = { impl, version, app: opts.app || null, shape: opts.shape || null, providedAt: Date.now() };
+    this._providers.set(name, record);
+
+    this._emit('wu:capability:provided', { name, version, app: record.app });
+    this._resolveWaiters(name, record);
+    logger.wuDebug?.(`[WuContracts] provided '${name}@${version}'`);
+
+    // Identity-scoped revoke: only revoke if THIS record is still the current
+    // owner of the name. Prevents a stale handle (after a same-name re-provide
+    // by another app) from killing the new owner's live capability.
+    return {
+      revoke: () => (this._providers.get(name) === record ? this.revoke(name) : false),
+    };
+  }
+
+  /**
+   * Consume a capability. Returns a LIVE proxy (re-resolves on every access) —
+   * never throws at consume() time, so you can consume before the provider
+   * mounts; the first ACCESS throws a clear error if unsatisfied.
+   *
+   * With `{ wait: true }`, returns a Promise that resolves once a satisfying
+   * provider appears (optionally bounded by `timeout` ms).
+   *
+   * @param {string} name
+   * @param {string} [range='*'] - Semver range the provider must satisfy
+   * @param {object} [opts]
+   * @param {boolean} [opts.wait=false]
+   * @param {number} [opts.timeout] - ms; rejects the wait promise if exceeded
+   * @returns {Proxy|Promise<Proxy>}
+   */
+  consume(name, range = '*', opts = {}) {
+    if (!opts.wait) return this._proxy(name, range);
+
+    const cur = this._providers.get(name);
+    if (cur && satisfies(cur.version, range)) return Promise.resolve(this._proxy(name, range));
+
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        range,
+        resolve: () => resolve(this._proxy(name, range)),
+        reject,
+        timer: null,
+      };
+      if (opts.timeout) {
+        waiter.timer = setTimeout(() => {
+          this._removeWaiter(name, waiter);
+          reject(new Error(`[WuContracts] timed out after ${opts.timeout}ms waiting for '${name}' satisfying '${range}'.`));
+        }, opts.timeout);
+      }
+      this._addWaiter(name, waiter);
+    });
+  }
+
+  /** Is a satisfying provider currently registered? (never throws) */
+  has(name, range = '*') {
+    const rec = this._providers.get(name);
+    return !!rec && satisfies(rec.version, range);
+  }
+
+  /** Revoke a capability (e.g. on teardown). */
+  revoke(name) {
+    if (this._providers.delete(name)) {
+      this._emit('wu:capability:revoked', { name });
+      logger.wuDebug?.(`[WuContracts] revoked '${name}'`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Revoke every capability provided by `app`. Called by WuCore on a real
+   * unmount with the framework-verified app name (never from a bus event).
+   * @param {string} app
+   */
+  revokeByApp(app) {
+    if (!app) return;
+    for (const [name, rec] of [...this._providers]) {
+      if (rec.app === app) this.revoke(name);
+    }
+  }
+
+  /** Snapshot of registered capabilities (for wu.inspect() / devtools). */
+  list() {
+    const out = [];
+    for (const [name, rec] of this._providers) {
+      out.push({ name, version: rec.version, app: rec.app });
+    }
+    return out;
+  }
+
+  cleanup() {
+    for (const set of this._waiters.values()) {
+      for (const w of set) {
+        if (w.timer) clearTimeout(w.timer);
+        try { w.reject(new Error('[WuContracts] framework destroyed')); } catch { /* noop */ }
+      }
+    }
+    this._waiters.clear();
+    this._providers.clear();
+  }
+
+  /* ─────────────────────────────── private ────────────────────────── */
+
+  _proxy(name, range) {
+    const contracts = this;
+    const resolve = () => {
+      const rec = contracts._providers.get(name);
+      if (!rec) {
+        throw new Error(`[WuContracts] no provider for capability '${name}'. ` +
+          `Did the providing app mount and call wu.provide('${name}', …)?`);
+      }
+      if (!satisfies(rec.version, range)) {
+        throw new Error(`[WuContracts] capability '${name}@${rec.version}' does not satisfy '${range}'.`);
+      }
+      return rec;
+    };
+
+    // Memoize bound methods so `proxy.fn === proxy.fn` (stable identity needed
+    // for add/removeListener round-trips, Set/Map keys, React deps). Keyed by
+    // the unbound source fn — a swapped provider yields a new fn → new binding,
+    // so re-resolution stays live.
+    const boundCache = new WeakMap();
+    const bind = (impl, fn) => {
+      let b = boundCache.get(fn);
+      if (!b) { b = fn.bind(impl); boundCache.set(fn, b); }
+      return b;
+    };
+
+    return new Proxy(Object.create(null), {
+      get(_, prop) {
+        if (prop === '__wuCapability') return name;
+        if (prop === '__wuRange') return range;
+        if (prop === '__wuAvailable') return contracts.has(name, range);
+        // The proxy is NEVER thenable. A capability method literally named
+        // `then` is unreachable via the proxy (documented) — far safer than
+        // silently assimilating into a Promise on await/Promise.resolve.
+        if (prop === 'then') return undefined;
+        // Don't throw on Symbol probes (iterators, toPrimitive, …).
+        if (typeof prop === 'symbol') {
+          if (!contracts.has(name, range)) return undefined;
+          const rec = contracts._providers.get(name);
+          const v = rec.impl[prop];
+          return typeof v === 'function' ? bind(rec.impl, v) : v;
+        }
+        const rec = resolve();
+        const val = rec.impl[prop];
+        return typeof val === 'function' ? bind(rec.impl, val) : val;
+      },
+      set(_, prop) {
+        // Consumed capabilities are READ-ONLY — a consumer writing through the
+        // proxy would mutate the provider's shared impl (and could repoint its
+        // prototype via __proto__). Honest no-op + warn.
+        logger.wuWarn?.(`[WuContracts] ignored write to '${String(prop)}' on consumed capability '${name}': consumed capabilities are read-only.`);
+        return true;
+      },
+      has(_, prop) {
+        const rec = contracts._providers.get(name);
+        return rec ? (prop in rec.impl) : false;
+      },
+    });
+  }
+
+  _verifyShape(name, impl, shape, version) {
+    const problems = [];
+    if (Array.isArray(shape)) {
+      for (const key of shape) if (!WuContracts._provides(impl, key)) problems.push(`${key} (missing)`);
+    } else if (shape && typeof shape === 'object') {
+      for (const [key, type] of Object.entries(shape)) {
+        if (!WuContracts._provides(impl, key)) problems.push(`${key} (missing)`);
+        else if (type && typeof impl[key] !== type) problems.push(`${key} (expected ${type}, got ${typeof impl[key]})`);
+      }
+    }
+    if (problems.length) {
+      throw new Error(`[WuContracts] provide('${name}@${version}') violates its declared shape — ${problems.join(', ')}.`);
+    }
+  }
+
+  /**
+   * Is `key` GENUINELY provided by impl? Walks own props + the impl's own
+   * prototype chain (so class-instance methods count) but stops before
+   * Object/Function.prototype — otherwise inherited toString/valueOf/hasOwnProperty
+   * would let a hollow `{}` satisfy any contract demanding those names.
+   * @private
+   */
+  static _provides(impl, key) {
+    let obj = impl;
+    while (obj && obj !== Object.prototype && obj !== Function.prototype) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) return true;
+      obj = Object.getPrototypeOf(obj);
+    }
+    return false;
+  }
+
+  _addWaiter(name, waiter) {
+    if (!this._waiters.has(name)) this._waiters.set(name, new Set());
+    this._waiters.get(name).add(waiter);
+  }
+
+  _removeWaiter(name, waiter) {
+    const set = this._waiters.get(name);
+    if (set) { set.delete(waiter); if (!set.size) this._waiters.delete(name); }
+  }
+
+  _resolveWaiters(name, rec) {
+    const set = this._waiters.get(name);
+    if (!set) return;
+    for (const w of [...set]) {
+      if (satisfies(rec.version, w.range)) {
+        if (w.timer) clearTimeout(w.timer);
+        set.delete(w);
+        w.resolve();
+      }
+    }
+    if (!set.size) this._waiters.delete(name);
+  }
+
+  _emit(event, data) {
+    try {
+      // `wu:` events are system-trusted by the bus (no token needed).
+      this.core.eventBus?.emit(event, data, { appName: 'wu-core' });
+    } catch { /* bus may be torn down */ }
+  }
+}
+
 /**
  * WU-FRAMEWORK: UNIVERSAL MICROFRONTENDS
  * Motor principal agnostico - Funciona con cualquier framework
@@ -6834,7 +7349,8 @@ class WuCore {
     this.mounted = new Map();        // Apps montadas
     this.hidden = new Map();         // Keep-alive hidden apps
     this._pendingUnmounts = new Map(); // Deferred unmount timers (StrictMode compat)
-    this._mountingPromises = new Map(); // In-flight mount dedup
+    this._mountingPromises = new Map(); // In-flight mount dedup: appName -> { promise, containerSelector }
+    this._unmountingPromises = new Map(); // In-flight deferred teardowns: appName -> Promise
     this._defineWaiters = new Map();    // Promise waiters for wu.define(): appName -> { resolve, timer, promise }
     this._resolvedPaths = new Map();    // Cached module URL: cacheKey -> resolved path
     // Reference counting for mount/unmount. Survives multi-cycle StrictMode +
@@ -6856,6 +7372,9 @@ class WuCore {
     // Loader for wu.use() — same lazy pattern. Only instantiated when a
     // caller actually requests a shared component. See _ensureLoader().
     this.loader = null;
+    // Time-travel recorder — lazy chunk, instantiated on first wu.timeline.*
+    // access. See _ensureTimeline().
+    this._timeline = null;
 
     // Sistemas esenciales
     // Cache: localStorage backing has a real-world ceiling of ~5MB per origin.
@@ -6873,6 +7392,10 @@ class WuCore {
     this.hooks = new WuLifecycleHooks(this);
     this.prefetcher = new WuPrefetch(this);
     this.overrides = new WuOverrides();
+    // Capability contracts — typed/versioned provide/consume between apps.
+    // Eager (like store/eventBus): provide/consume must work synchronously
+    // the moment an app mounts. Needs eventBus, which is created above.
+    this.contracts = new WuContracts(this);
 
     // Estado
     this.isInitialized = false;
@@ -7026,43 +7549,174 @@ class WuCore {
       logger.wuDebug(`${appName} deferred unmount cancelled by remount`);
     }
 
-    // Already mounted in same container → no-op (refs already incremented above)
-    if (this.mounted.has(appName)) {
-      const existing = this.mounted.get(appName);
-      if (existing.containerSelector === containerSelector) {
-        logger.wuDebug(`${appName} already mounted in ${containerSelector}`);
-        return;
+    // Failed/cancelled mounts must release their ref, otherwise future
+    // unmounts are skipped forever ("refs still active").
+    let refReleased = false;
+    const releaseRef = () => {
+      if (refReleased) return;
+      refReleased = true;
+      this._releaseMountRef(appName);
+    };
+    // Teardowns (force unmount / deferred teardown) delete the whole ref
+    // entry, taking this caller's +1 with it — re-establish it so the
+    // remounted instance survives until its own unmount.
+    const reclaimRef = () => {
+      if (!refReleased && (this._mountRefs.get(appName) || 0) === 0) {
+        this._mountRefs.set(appName, 1);
+      }
+    };
+
+    try {
+      // Wait for any in-flight deferred teardown before evaluating mounted
+      // state — otherwise we'd report "already mounted" while the teardown
+      // finishes underneath and leaves the container empty. The wait is
+      // bounded: a beforeUnmount/afterUnmount hook that mounts this same
+      // app would otherwise form a circular teardown→hook→mount() wait.
+      if (this._unmountingPromises.has(appName)) {
+        await Promise.race([
+          this._unmountingPromises.get(appName),
+          new Promise((resolve) => setTimeout(resolve, 5000)),
+        ]);
+        reclaimRef();
       }
+
+      // Already mounted in same container → no-op (refs already incremented above)
+      if (this.mounted.has(appName)) {
+        const existing = this.mounted.get(appName);
+        if (existing.containerSelector === containerSelector) {
+          logger.wuDebug(`${appName} already mounted in ${containerSelector}`);
+          return;
+        }
+        // Different container → destroy the old instance, then remount normally
+        await this.unmount(appName, { force: true });
+        reclaimRef();
+      }
+
+      // Deduplicate concurrent mounts (StrictMode fires effect twice)
+      const inflight = this._mountingPromises.get(appName);
+      if (inflight) {
+        if (inflight.containerSelector === containerSelector) {
+          logger.wuDebug(`${appName} mount already in progress, deduplicating`);
+          return await inflight.promise;
+        }
+        // Different container → wait for the in-flight mount to settle,
+        // then remount normally (the recursive call manages its own ref)
+        releaseRef();
+        await inflight.promise.catch(() => {});
+        return await this.mount(appName, containerSelector);
+      }
+
+      // Check if app is in keep-alive (hidden) state
+      const hiddenEntry = this.hidden.get(appName);
+      if (hiddenEntry) {
+        if (hiddenEntry.containerSelector === containerSelector) {
+          // Same container → instant show (no reload)
+          return await this.show(appName);
+        }
+        // Different container → destroy hidden state, remount normally
+        await this._destroyHidden(appName);
+      }
+
+      // Track mount promise for deduplication
+      const mountPromise = this.mountWithRecovery(appName, containerSelector, 0);
+      this._mountingPromises.set(appName, { promise: mountPromise, containerSelector });
+
+      try {
+        return await mountPromise;
+      } finally {
+        this._mountingPromises.delete(appName);
+      }
+    } catch (error) {
+      releaseRef();
+      throw error;
     }
+  }
 
-    // Deduplicate concurrent mounts (StrictMode fires effect twice)
-    if (this._mountingPromises.has(appName)) {
-      logger.wuDebug(`${appName} mount already in progress, deduplicating`);
-      return await this._mountingPromises.get(appName);
+  /**
+   * Push new props into an already-mounted micro-app WITHOUT remounting —
+   * the live-props channel. Calls the app's optional `update(container, props)`
+   * lifecycle slot (adapters built on createWuAdapter expose it when their
+   * framework can re-render in place).
+   *
+   * Honest no-op semantics: returns false (and warns once) when the app is not
+   * mounted or its adapter did not advertise an `update` slot — never throws,
+   * never silently pretends to have updated.
+   *
+   * @param {string} appName - Nombre de la app montada
+   * @param {Object} props - Props a fusionar/empujar a la app
+   * @returns {Promise<boolean>} true si la app recibió las props
+   */
+  async update(appName, props = {}) {
+    // Wait out any in-flight deferred teardown so we don't update an app that
+    // is about to disappear (mirrors mount()'s teardown coordination).
+    if (this._unmountingPromises.has(appName)) {
+      await Promise.race([
+        this._unmountingPromises.get(appName),
+        new Promise((resolve) => setTimeout(resolve, 5000)),
+      ]);
+    }
+
+    // Re-validate AFTER the race: if the timeout won (teardown >5s) the mount
+    // record may still be present mid-unmount — its container/lifecycle are
+    // already torn down, so don't update it.
+    if (this._unmountingPromises.has(appName)) {
+      logger.wuWarn(`[Wu] update('${appName}') ignored: app is being unmounted`);
+      return false;
     }
 
-    // Check if app is in keep-alive (hidden) state
-    const hiddenEntry = this.hidden.get(appName);
-    if (hiddenEntry) {
-      if (hiddenEntry.containerSelector === containerSelector) {
-        // Same container → instant show (no reload)
-        return await this.show(appName);
-      }
-      // Different container → destroy hidden state, remount normally
-      await this._destroyHidden(appName);
+    const mounted = this.mounted.get(appName) || this.hidden.get(appName);
+    if (!mounted) {
+      logger.wuWarn(`[Wu] update('${appName}') ignored: app is not mounted`);
+      return false;
     }
 
-    // Track mount promise for deduplication
-    const mountPromise = this.mountWithRecovery(appName, containerSelector, 0);
-    this._mountingPromises.set(appName, mountPromise);
+    const lifecycle = mounted.lifecycle;
+    if (!lifecycle || typeof lifecycle.update !== 'function') {
+      logger.wuWarn(
+        `[Wu] update('${appName}') is a no-op: this app's adapter does not support ` +
+        `live props (no update() slot). Re-mount to change props, or use the ` +
+        `event bus / store for cross-app state.`
+      );
+      return false;
+    }
 
     try {
-      return await mountPromise;
-    } finally {
-      this._mountingPromises.delete(appName);
+      // A beforeUpdate hook may veto the push, like every other before* phase.
+      const before = await this.hooks.execute('beforeUpdate', { appName, props, mounted });
+      if (before.cancelled) {
+        logger.wuWarn(`[Wu] update('${appName}') cancelled by beforeUpdate hook`);
+        return false;
+      }
+      await lifecycle.update(mounted.container, props);
+      // Retain the latest props on the mount record for inspection/devtools.
+      mounted.props = { ...(mounted.props || {}), ...props };
+      await this.hooks.execute('afterUpdate', { appName, props });
+      this.eventBus.emit('app:updated', { appName, props }, { appName });
+      logger.wuDebug(`${appName} props updated`);
+      return true;
+    } catch (error) {
+      logger.wuError(`[Wu] update('${appName}') failed:`, error);
+      this.errorBoundary.handle(error, { appName, phase: 'update' });
+      return false;
     }
   }
 
+  /**
+   * Release one mount reference. Used when a mount fails or is cancelled,
+   * so the ref count stays balanced with successful mounts.
+   * @private
+   */
+  _releaseMountRef(appName) {
+    const prev = this._mountRefs.get(appName) || 0;
+    const next = prev - 1;
+    if (next > 0) {
+      this._mountRefs.set(appName, next);
+    } else {
+      this._mountRefs.delete(appName);
+    }
+    logger.wuDebug(`${appName} mount ref released: ${prev} → ${Math.max(0, next)}`);
+  }
+
   /**
    * Mount with recovery: self-healing app mounting
    */
@@ -7079,6 +7733,7 @@ class WuCore {
       const beforeLoadResult = await this.hooks.execute('beforeLoad', { appName, containerSelector, attempt });
       if (beforeLoadResult.cancelled) {
         logger.wuWarn('Mount cancelled by beforeLoad hook');
+        this._releaseMountRef(appName);
         return;
       }
 
@@ -7086,6 +7741,7 @@ class WuCore {
       const pluginBeforeMount = await this.pluginSystem.callHook('beforeMount', { appName, containerSelector });
       if (pluginBeforeMount === false) {
         logger.wuWarn('Mount cancelled by plugin beforeMount hook');
+        this._releaseMountRef(appName);
         return;
       }
 
@@ -7127,6 +7783,12 @@ class WuCore {
       const beforeMountResult = await this.hooks.execute('beforeMount', { appName, containerSelector, sandbox, lifecycle });
       if (beforeMountResult.cancelled) {
         logger.wuWarn('Mount cancelled by beforeMount hook');
+        if (sandbox.iframeSandbox) {
+          sandbox.iframeSandbox.destroy();
+          sandbox.iframeSandbox = null;
+        }
+        this.sandbox.cleanup(sandbox);
+        this._releaseMountRef(appName);
         return;
       }
 
@@ -7173,8 +7835,12 @@ class WuCore {
       try {
         if (this.sandbox && this.sandbox.sandboxes && this.sandbox.sandboxes.has(appName)) {
           const sb = this.sandbox.sandboxes.get(appName);
-          if (sb && sb.proxySandbox) {
-            sb.proxySandbox.deactivate();
+          if (sb && sb.iframeSandbox) {
+            sb.iframeSandbox.destroy();
+            sb.iframeSandbox = null;
+          }
+          if (sb && sb.jsSandbox && sb.jsSandbox.isActive()) {
+            sb.jsSandbox.deactivate();
           }
           this.sandbox.sandboxes.delete(appName);
           logger.wuDebug(`Sandbox cleaned up after mount failure for ${appName}`);
@@ -7191,18 +7857,20 @@ class WuCore {
         container: containerSelector
       });
 
-      // Si el error boundary recupero el error, no necesitamos reintentar
-      if (errorResult.recovered) {
-        logger.wuDebug('Error recovered by error boundary');
-        return;
-      }
-
-      // Recovery protocol
-      if (attempt < maxAttempts - 1 && errorResult.action === 'retry') {
+      // Recovery protocol: handlers that ask for a retry get actual retries
+      const wantsRetry = errorResult.action === 'retry' ||
+                         errorResult.action === 'retry-with-longer-timeout';
+      if (wantsRetry && attempt < maxAttempts - 1) {
         logger.wuDebug('Initiating recovery protocol...');
 
-        // Clean app state
-        await this.appStateCleanup(appName, containerSelector);
+        // Clean app state (keeping the wu.define() registration: the module
+        // is cached by the browser and won't re-register on re-import)
+        await this.appStateCleanup(appName, containerSelector, { preserveDefinition: true });
+        // The cleanup's force-unmount wipes the ref table — restore the
+        // caller's ref so the retried mount stays balanced with its unmount.
+        if ((this._mountRefs.get(appName) || 0) === 0) {
+          this._mountRefs.set(appName, 1);
+        }
 
         // Temporal stabilization
         await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1)));
@@ -7211,6 +7879,14 @@ class WuCore {
         return await this.mountWithRecovery(appName, containerSelector, attempt + 1);
       }
 
+      // Recovered without a retry request (custom handler resolved it).
+      // Nothing was mounted by us, so the ref must be released.
+      if (errorResult.recovered && !wantsRetry) {
+        logger.wuDebug('Error recovered by error boundary');
+        this._releaseMountRef(appName);
+        return;
+      }
+
       // Call plugin error hooks
       await this.pluginSystem.callHook('onError', { phase: 'mount', error, appName });
 
@@ -7221,8 +7897,10 @@ class WuCore {
 
   /**
    * App state cleanup: Enhanced container cleanup with framework protection
+   * `preserveDefinition` keeps the wu.define() registration: a cached ES
+   * module won't re-execute on re-import, so a retry could never restore it.
    */
-  async appStateCleanup(appName, containerSelector) {
+  async appStateCleanup(appName, containerSelector, { preserveDefinition = false } = {}) {
     try {
       logger.wuDebug(`Starting app state cleanup for ${appName}...`);
 
@@ -7280,7 +7958,9 @@ class WuCore {
       }
 
       // Reset definition state
-      this.definitions.delete(appName);
+      if (!preserveDefinition) {
+        this.definitions.delete(appName);
+      }
 
       // Clear sandbox registry
       if (this.sandbox && this.sandbox.sandboxes) {
@@ -7548,7 +8228,15 @@ class WuCore {
     }
 
     // Wait for wu.define()
-    await this._waitForDefine(app.name, 'strict');
+    try {
+      await this._waitForDefine(app.name, 'strict');
+    } catch (defineError) {
+      // Module imported but never called wu.define() — destroy the iframe
+      // so each failed strict mount doesn't leak a hidden window.
+      iframeSandbox.destroy();
+      sandbox.iframeSandbox = null;
+      throw defineError;
+    }
 
     logger.wuDebug(`[strict] ${app.name} loaded and registered via iframe`);
   }
@@ -7905,18 +8593,25 @@ class WuCore {
       clearTimeout(this._pendingUnmounts.get(appName));
     }
 
-    this._pendingUnmounts.set(appName, setTimeout(async () => {
+    this._pendingUnmounts.set(appName, setTimeout(() => {
       this._pendingUnmounts.delete(appName);
       // Re-check refs at fire time — caller may have re-mounted during grace
       if ((this._mountRefs.get(appName) || 0) > 0) return;
       // Re-verify: only unmount if the same mount entry is still current
       if (this.mounted.has(appName) && this.mounted.get(appName) === mounted) {
-        try {
-          await this._executeUnmount(appName, mounted);
-          this._mountRefs.delete(appName);
-        } catch (error) {
-          logger.wuError(`Deferred unmount failed for ${appName}:`, error);
-        }
+        // Track the in-flight teardown synchronously so a concurrent mount()
+        // awaits it instead of seeing a half-unmounted app as "already mounted"
+        const teardown = (async () => {
+          try {
+            await this._executeUnmount(appName, mounted);
+            this._mountRefs.delete(appName);
+          } catch (error) {
+            logger.wuError(`Deferred unmount failed for ${appName}:`, error);
+          } finally {
+            this._unmountingPromises.delete(appName);
+          }
+        })();
+        this._unmountingPromises.set(appName, teardown);
       }
     }, 60));
   }
@@ -7965,6 +8660,10 @@ class WuCore {
       // Call plugin afterUnmount hooks
       await this.pluginSystem.callHook('afterUnmount', { appName });
 
+      // Revoke this app's capability contracts with the framework-verified
+      // app name (NOT from the spoofable app:unmounted bus event).
+      try { this.contracts.revokeByApp(appName); } catch { /* best effort */ }
+
       // Emit unmount event
       this.eventBus.emit('app:unmounted', { appName }, { appName });
 
@@ -8192,6 +8891,138 @@ class WuCore {
     };
   }
 
+  /**
+   * Register a capability another app can consume (typed, versioned contract).
+   * @param {string} name
+   * @param {object|Function} impl
+   * @param {Object} [opts] - { version, shape, app }
+   * @returns {{ revoke: Function }}
+   * @see WuContracts#provide
+   */
+  provide(name, impl, opts) {
+    return this.contracts.provide(name, impl, opts);
+  }
+
+  /**
+   * Consume a capability provided by another app. Returns a live proxy that
+   * fails loudly on access if no provider satisfies the range (or a Promise
+   * with { wait: true }).
+   * @param {string} name
+   * @param {string} [range='*']
+   * @param {Object} [opts] - { wait, timeout }
+   * @returns {Proxy|Promise<Proxy>}
+   * @see WuContracts#consume
+   */
+  consume(name, range, opts) {
+    return this.contracts.consume(name, range, opts);
+  }
+
+  /**
+   * Full diagnostic snapshot of the whole page — one structured object that
+   * aggregates state scattered across mounted/hidden/definitions/apps, the
+   * event bus, the store, and per-app sandbox info. The data backbone for
+   * `wu.showInspector()` and the `window.__WU_DEVTOOLS__` bridge, and useful
+   * on its own for debugging multi-framework pages where per-framework
+   * devtools each see only their own island.
+   *
+   * @param {Object} [opts]
+   * @param {number} [opts.events=25] - Recent events to include
+   * @returns {Object} snapshot
+   */
+  inspect(opts = {}) {
+    const { events = 25 } = opts;
+
+    const describeMount = (name, rec, status) => {
+      const lifecycle = rec.lifecycle || this.definitions.get(name);
+      return {
+        name,
+        status,
+        framework: rec.app?.framework || rec.app?.config?.framework || null,
+        containerSelector: rec.containerSelector || null,
+        mountedAt: rec.timestamp || null,
+        liveProps: typeof lifecycle?.update === 'function',
+        props: rec.props || null,
+        sandbox: this.getSandboxInfo(name),
+      };
+    };
+
+    const apps = [];
+    for (const [name, rec] of this.mounted) apps.push(describeMount(name, rec, 'mounted'));
+    for (const [name, rec] of this.hidden) apps.push(describeMount(name, rec, 'hidden'));
+
+    let eventHistory = [];
+    try {
+      const hist = this.eventBus.history || [];
+      eventHistory = hist.slice(-events).map((e) => ({
+        // WuEventBus stores the event under `name`; keep type/event fallbacks
+        // for any external producer that uses a different field.
+        type: e.name || e.type || e.event,
+        appName: e.appName,
+        timestamp: e.timestamp,
+      }));
+    } catch { /* bus may not expose history */ }
+
+    let storeSnapshot = null;
+    try { storeSnapshot = this.store.get(); } catch { /* guarded */ }
+
+    return {
+      version: this.version || null,
+      timestamp: Date.now(),
+      summary: {
+        registered: this.apps.size,
+        defined: this.definitions.size,
+        mounted: this.mounted.size,
+        hidden: this.hidden.size,
+      },
+      apps,
+      defined: Array.from(this.definitions.keys()),
+      registered: Array.from(this.apps.keys()),
+      capabilities: (() => { try { return this.contracts.list(); } catch { return []; } })(),
+      events: {
+        recent: eventHistory,
+        stats: (() => { try { return this.eventBus.getStats(); } catch { return null; } })(),
+      },
+      store: {
+        snapshot: storeSnapshot,
+        metrics: (() => { try { return this.store.getMetrics(); } catch { return null; } })(),
+      },
+    };
+  }
+
+  /**
+   * Open the visual inspector overlay (lazy-loaded, Shadow-DOM isolated so it
+   * never collides with app styles). Returns a handle with .close().
+   * @returns {Promise<{close: Function}|null>}
+   */
+  async showInspector() {
+    if (typeof window === 'undefined') return null;
+    const { mountInspector } = await import('./core/wu-devtools.js');
+    return mountInspector(this);
+  }
+
+  /**
+   * Lazy-load and instantiate the time-travel recorder. Kept out of the main
+   * bundle (like devtools/loader) — only paid for when something asks for
+   * `wu.timeline`. Cached on `this._timeline`.
+   * @private
+   * @returns {Promise<import('./wu-timeline.js').WuTimeline>}
+   */
+  async _ensureTimeline() {
+    if (this._timeline) return this._timeline;
+    const { WuTimeline } = await import('./core/wu-timeline.js');
+    this._timeline = new WuTimeline(this);
+    return this._timeline;
+  }
+
+  /** Close the inspector overlay if open. */
+  async hideInspector() {
+    if (typeof window === 'undefined') return;
+    try {
+      const { unmountInspector } = await import('./core/wu-devtools.js');
+      unmountInspector();
+    } catch { /* never opened */ }
+  }
+
   /**
    * Store methods: Convenience methods for state management
    */
@@ -8338,6 +9169,14 @@ class WuCore {
     logger.wuDebug('Destroying framework...');
 
     try {
+      // Close the inspector overlay so its refresh timer doesn't outlive us
+      await this.hideInspector();
+
+      // Stop the timeline recorder so its store/bus taps don't dangle.
+      if (this._timeline) {
+        try { this._timeline.stop(); } catch { /* best effort */ }
+      }
+
       // Execute beforeDestroy hooks
       await this.hooks.execute('beforeDestroy', {});
 
@@ -8350,6 +9189,7 @@ class WuCore {
       }
       this._pendingUnmounts.clear();
       this._mountingPromises.clear();
+      this._unmountingPromises.clear();
 
       // Cancel and reject any pending define() waiters
       for (const [, waiter] of this._defineWaiters) {
@@ -8382,6 +9222,7 @@ class WuCore {
       this.errorBoundary.cleanup();
       this.hooks.cleanup();
       this.prefetcher.cleanup();
+      this.contracts.cleanup();
 
       // Limpiar registros
       this.apps.clear();
@@ -8599,75 +9440,160 @@ if (typeof window !== 'undefined') {
     console.warn('[Wu Framework] window.wu already exists and is not a Wu Framework instance. Overwriting. Use Symbol.for("wu-framework") for collision-safe access.');
   }
   window.wu = wu;
+}
 
-  if (!wu.version) {
-    // "2.1.1" is replaced at build time with package.json version.
-    // Fallback handles raw-source imports (no bundler).
-    wu.version = "2.1.1" ;
-    wu.info = {
-      name: 'Wu Framework',
-      description: 'Universal Microfrontends',
-      features: ['Framework Agnostic', 'Zero Config', 'Shadow DOM Isolation', 'Runtime Loading']
-    };
-  }
+// Augment the instance everywhere (browser AND Node/SSR) — the d.ts declares
+// these members unconditionally on WuCore, so they must exist in any runtime.
+if (!wu.version) {
+  // "2.5.0" is replaced at build time with package.json version.
+  // Fallback handles raw-source imports (no bundler).
+  wu.version = "2.5.0" ;
+  wu.info = {
+    name: 'Wu Framework',
+    description: 'Universal Microfrontends',
+    features: ['Framework Agnostic', 'Zero Config', 'Shadow DOM Isolation', 'Runtime Loading']
+  };
+}
 
-  // Event Bus shortcuts on window.wu
-  if (!wu.emit) {
-    wu.emit = (event, data, opts) => wu.eventBus.emit(event, data, opts);
-    wu.on = (event, cb) => wu.eventBus.on(event, cb);
-    wu.once = (event, cb) => wu.eventBus.once(event, cb);
-    wu.off = (event, cb) => wu.eventBus.off(event, cb);
-  }
+// Event Bus shortcuts on wu
+if (!wu.emit) {
+  wu.emit = (event, data, opts) => wu.eventBus.emit(event, data, opts);
+  wu.on = (event, cb) => wu.eventBus.on(event, cb);
+  wu.once = (event, cb) => wu.eventBus.once(event, cb);
+  wu.off = (event, cb) => wu.eventBus.off(event, cb);
+}
 
-  // Prefetch shortcuts on window.wu
-  if (!wu.prefetch) {
-    wu.prefetch = (appNames, opts) => wu.prefetcher.prefetch(appNames, opts);
-    wu.prefetchAll = (opts) => wu.prefetcher.prefetchAll(opts);
-  }
+// Prefetch shortcuts on wu
+if (!wu.prefetch) {
+  wu.prefetch = (appNames, opts) => wu.prefetcher.prefetch(appNames, opts);
+  wu.prefetchAll = (opts) => wu.prefetcher.prefetchAll(opts);
+}
 
-  // Override shortcuts on window.wu
-  if (!wu.override) {
-    wu.override = (name, url, opts) => wu.overrides.set(name, url, opts);
-    wu.removeOverride = (name) => wu.overrides.remove(name);
-    wu.getOverrides = () => wu.overrides.getAll();
-    wu.clearOverrides = () => wu.overrides.clearAll();
-  }
+// Override shortcuts on wu
+if (!wu.override) {
+  wu.override = (name, url, opts) => wu.overrides.set(name, url, opts);
+  wu.removeOverride = (name) => wu.overrides.remove(name);
+  wu.getOverrides = () => wu.overrides.getAll();
+  wu.clearOverrides = () => wu.overrides.clearAll();
+}
 
-  // Log control: window.wu.silence() / window.wu.verbose()
-  if (!wu.silence) {
-    wu.silence = async () => { const { silenceAllLogs } = await Promise.resolve().then(function () { return wuLogger; }); silenceAllLogs(); };
-    wu.verbose = async () => { const { enableAllLogs } = await Promise.resolve().then(function () { return wuLogger; }); enableAllLogs(); };
-  }
+// Capability-contract shortcuts on wu (v2.5+)
+if (!wu.provide) {
+  wu.provide = (name, impl, opts) => wu.contracts.provide(name, impl, opts);
+  wu.consume = (name, range, opts) => wu.contracts.consume(name, range, opts);
+}
 
-  // AI integration — lazy-loaded chunk + transparent proxy.
-  // The wu-ai subsystem (~80–100 KB minified) lives in a separate chunk
-  // and is only fetched on first access of `wu.ai.*`. Chainable config
-  // methods (provider/action/trigger/...) queue calls sync and return the
-  // proxy. Async methods (send/stream/agent/...) await the import + delegate.
-  // Use `await wu.aiReady()` to force load + get the real instance.
-  if (!wu.ai) {
-    setupLazyAi(wu);
-  }
+// Log control: wu.silence() / wu.verbose()
+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(); };
+}
 
-  // MCP bridge — connects to wu-mcp-server for AI agent control
-  if (!wu.mcp) {
-    let _mcpBridge = null;
-    wu.mcp = {
-      async connect(url = 'ws://localhost:19100', options = {}) {
-        if (!_mcpBridge) {
-          const { createMcpBridge } = await import('./core/wu-mcp-bridge.js');
-          _mcpBridge = createMcpBridge(wu);
-        }
-        _mcpBridge.connect(url, options);
-      },
-      disconnect() {
-        _mcpBridge?.disconnect();
-      },
-      isConnected() {
-        return _mcpBridge?.isConnected() || false;
-      },
-    };
-  }
+// AI integration — lazy-loaded chunk + transparent proxy.
+// The wu-ai subsystem (~80–100 KB minified) lives in a separate chunk
+// and is only fetched on first access of `wu.ai.*`. Chainable config
+// methods (provider/action/trigger/...) queue calls sync and return the
+// proxy. Async methods (send/stream/agent/...) await the import + delegate.
+// Use `await wu.aiReady()` to force load + get the real instance.
+if (!wu.ai) {
+  setupLazyAi(wu);
+}
+
+// DevTools bridge — a tiny always-present global so external inspectors (and
+// the built-in overlay) can detect Wu and pull a full-page snapshot. The
+// visual overlay itself is a lazy chunk, loaded only on show().
+if (typeof window !== 'undefined' && !window.__WU_DEVTOOLS__) {
+  window.__WU_DEVTOOLS__ = {
+    version: wu.version,
+    isWu: true,
+    inspect: (opts) => wu.inspect(opts),
+    show: () => wu.showInspector(),
+    hide: () => wu.hideInspector(),
+    subscribe: (cb) => wu.eventBus.on('*', cb),
+  };
+}
+
+// MCP bridge — connects to wu-mcp-server for AI agent control
+if (!wu.mcp) {
+  let _mcpBridge = null;
+  wu.mcp = {
+    async connect(url = 'ws://localhost:19100', options = {}) {
+      if (!_mcpBridge) {
+        const { createMcpBridge } = await import('./core/wu-mcp-bridge.js');
+        _mcpBridge = createMcpBridge(wu);
+      }
+      _mcpBridge.connect(url, options);
+    },
+    disconnect() {
+      _mcpBridge?.disconnect();
+    },
+    isConnected() {
+      return _mcpBridge?.isConnected() || false;
+    },
+  };
+}
+
+// Timeline — cross-framework time travel. Lazy chunk (loaded on first
+// `wu.timeline.*` call). The facade is synchronous and chainable for the
+// fire-and-forget controls (record/stop/clear) and returns Promises for the
+// seek family, mirroring the real WuTimeline API. `status()` answers without
+// forcing a load so devtools can poll it cheaply.
+//
+// Honest note: the recorder is a lazy chunk, so record() ARMS asynchronously —
+// store writes made before the chunk resolves are not journaled. record()/
+// stop() intent is tracked so a stop() issued before load cancels a pending
+// record() (no "recording after stop" surprise). For programmatic recording
+// that must capture the very next write, `await wu.timelineReady()` first
+// (mirrors wu.aiReady) — after that, record() arms synchronously. In the UI
+// path the chunk is already loaded (opening the inspector loads it), so the
+// Rec button arms immediately.
+if (!wu.timeline) {
+  let _tl = null;
+  let _loading = null;
+  let _wantRecording = false;
+  let _recordOpts;
+  const ensure = () => {
+    if (_tl) return Promise.resolve(_tl);
+    if (!_loading) _loading = wu._ensureTimeline().then((t) => {
+      _tl = t;
+      // Apply the latest intent expressed before the chunk arrived.
+      if (_wantRecording && !t.status().recording) t.record(_recordOpts);
+      return t;
+    });
+    return _loading;
+  };
+  const NOT_LOADED = Object.freeze({
+    loaded: false, recording: false, live: true, position: 0, length: 0,
+    site: null, lamport: 0, snapshots: 0,
+  });
+  const facade = {
+    record(opts) {
+      _wantRecording = true; _recordOpts = opts;
+      if (_tl) { if (!_tl.status().recording) _tl.record(opts); } else ensure();
+      return facade;
+    },
+    stop() {
+      _wantRecording = false;          // cancels a record() still pending load
+      if (_tl) _tl.stop();
+      return facade;
+    },
+    clear() { ensure().then((t) => t.clear()); return facade; },
+    seek(pos, o) { return ensure().then((t) => t.seek(pos, o)); },
+    live() { return ensure().then((t) => t.live()); },
+    stepBack() { return ensure().then((t) => t.stepBack()); },
+    stepForward() { return ensure().then((t) => t.stepForward()); },
+    export() { return ensure().then((t) => t.export()); },
+    import(data) { return ensure().then((t) => t.import(data)); },
+    ingest(entries) { return ensure().then((t) => t.ingest(entries)); },
+    entries() { return _tl ? _tl.entries() : []; },
+    status() { return _tl ? _tl.status() : { ...NOT_LOADED }; },
+    get loaded() { return !!_tl; },
+    get instance() { return _tl; },
+  };
+  wu.timeline = facade;
+  // Warm-up: await it to force the chunk load + apply pending record intent,
+  // then arm recording synchronously before writes. Resolves the WuTimeline.
+  wu.timelineReady = ensure;
 }
 var wu_default = wu;
 
@@ -8694,6 +9620,8 @@ const off = (event, cb) => wu.eventBus.off(event, cb);
 const getState = (path) => wu.store.get(path);
 const setState = (path, value) => wu.store.set(path, value);
 const onStateChange = (pattern, cb) => wu.store.on(pattern, cb);
+// Real-time collaborative sync (v2.4+) — lazy CRDT layer over the store.
+const syncStore = (opts) => wu.store.sync(opts);
 
 // Performance
 const startMeasure = (name, app) => wu.performance.startMeasure(name, app);
@@ -8714,6 +9642,10 @@ const clearOverrides = () => wu.clearOverrides();
 const usePlugin = (plugin, opts) => wu.pluginSystem.use(plugin, opts);
 const useHook = (phase, middleware, opts) => wu.hooks.use(phase, middleware, opts);
 
+// Capability contracts (v2.5+)
+const provide = (name, impl, opts) => wu.contracts.provide(name, impl, opts);
+const consume = (name, range, opts) => wu.contracts.consume(name, range, opts);
+
 // --- AI subsystem ---
 // AI classes were previously re-exported from this entry point. Doing so anchored
 // the ~80 KB AI chunk to the main bundle. As of v2.0, AI is loaded lazily via the
@@ -8726,5 +9658,5 @@ const useHook = (phase, middleware, opts) => wu.hooks.use(phase, middleware, opt
 //
 // For runtime use, prefer `wu.ai.*` — it auto-loads the chunk on first method call.
 
-export { WuApp, WuCache, WuCore, WuErrorBoundary, WuEventBus, WuLifecycleHooks, WuLoadingStrategy, WuManifest, WuOverrides, WuPerformance, WuPluginSystem, WuPrefetch, WuProxySandbox, WuSandbox, WuStore, WuStyleBridge, app, clearOverrides, createConditionalHook, createGuardHook, createPlugin, createSimpleHook, createTimedHook, createTransformHook, wu_default as default, define, destroy, emit, enableAllLogs, endMeasure, generatePerformanceReport, getOverrides, getState, hide, init, isHidden, mount, normalizeStyleMode, off, on, onStateChange, once, override, prefetch, prefetchAll, removeOverride, setState, show, silenceAllLogs, startMeasure, store, unmount, useHook, usePlugin, wu };
+export { WuApp, WuCache, WuContracts, WuCore, WuErrorBoundary, WuEventBus, WuLifecycleHooks, WuLoadingStrategy, WuManifest, WuOverrides, WuPerformance, WuPluginSystem, WuPrefetch, WuProxySandbox, WuSandbox, WuStore, WuStyleBridge, app, clearOverrides, compareVersions, consume, createConditionalHook, createGuardHook, createPlugin, createSimpleHook, createTimedHook, createTransformHook, wu_default as default, define, destroy, emit, endMeasure, generatePerformanceReport, getOverrides, getState, hide, init, isHidden, mount, normalizeStyleMode, off, on, onStateChange, once, override, parseVersion, prefetch, prefetchAll, provide, removeOverride, satisfies, setState, show, startMeasure, store, syncStore, unmount, useHook, usePlugin, wu };
 //# sourceMappingURL=wu-framework.dev.js.map