sibujs 4.14.1 → 4.15.0

package/dist/testing.cjs

@@ -71,6 +71,12 @@ __export(testing_exports, {
 });
 module.exports = __toCommonJS(testing_exports);
 
+// src/utils/globalSingleton.ts
+function globalSingleton(key, create) {
+  const g = globalThis;
+  return g[key] ?? (g[key] = create());
+}
+
 // src/core/dev.ts
 var DEV = typeof __SIBU_DEV__ !== "undefined" ? !!__SIBU_DEV__ : typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : (
   // safe default: off in browser, on in test/dev Node
@@ -303,7 +309,12 @@ function beginHydration() {
 }
 
 // src/core/rendering/dispose.ts
-var elementDisposers = /* @__PURE__ */ new WeakMap();
+var state2 = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.disposers.v1"), () => ({
+  disposers: /* @__PURE__ */ new WeakMap(),
+  captures: [],
+  bindings: { count: 0 }
+}));
+var elementDisposers = state2.disposers;
 var MAX_DRAIN_TEARDOWNS = 1e4;
 function reportDrainRunaway(label, executed, remaining) {
   if (typeof console === "undefined") return;
@@ -312,13 +323,13 @@ function reportDrainRunaway(label, executed, remaining) {
     { executed, remaining }
   );
 }
-var activeBindingCount = 0;
+var bindings = state2.bindings;
 function resolveCapture(capture) {
   let frame = capture;
   while (frame?.closed) frame = frame.forwardTo;
   return frame ?? null;
 }
-var registrationCaptures = [];
+var registrationCaptures = state2.captures;
 function currentDisposerCapture() {
   return resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
 }
@@ -337,7 +348,7 @@ function registerDisposer(node, teardown) {
     elementDisposers.set(node, disposers);
   }
   disposers.push(teardown);
-  if (DEV) activeBindingCount++;
+  if (DEV) bindings.count++;
   const capture = resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
   if (capture) capture.entries.push([node, teardown]);
 }
@@ -361,17 +372,17 @@ function disposeNodeOwn(node) {
   let executed = 0;
   let runaway = false;
   while (!runaway) {
-    const pending = elementDisposers.get(node);
-    if (!pending || pending.length === 0) break;
-    const snapshot = pending.slice();
+    const pending2 = elementDisposers.get(node);
+    if (!pending2 || pending2.length === 0) break;
+    const snapshot = pending2.slice();
     elementDisposers.delete(node);
-    if (DEV) activeBindingCount -= snapshot.length;
+    if (DEV) bindings.count -= snapshot.length;
     for (let i = 0; i < snapshot.length; i++) {
       if (executed >= MAX_DRAIN_TEARDOWNS) {
         const rest = snapshot.slice(i);
         const added = elementDisposers.get(node);
         elementDisposers.set(node, added ? rest.concat(added) : rest);
-        if (DEV) activeBindingCount += rest.length;
+        if (DEV) bindings.count += rest.length;
         reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
         runaway = true;
         break;
@@ -411,12 +422,6 @@ function replaceChildrenSafely(parent, ...next) {
   parent.replaceChildren(...next);
 }
 
-// src/utils/globalSingleton.ts
-function globalSingleton(key, create) {
-  const g = globalThis;
-  return g[key] ?? (g[key] = create());
-}
-
 // src/reactivity/track-core.ts
 var POOL_MAX = 4096;
 var nodePool = [];
@@ -580,6 +585,201 @@ function bindOwnerScope(fn) {
   return (...args) => runWithOwnerScope(scope, () => fn(...args));
 }
 var currentStructOwner = null;
+var frozenOwners = 0;
+var ACTIVE = 0;
+var PAUSED = 1;
+var ENDED = 2;
+var NOOP = () => {
+};
+var skippedWhileHeld = /* @__PURE__ */ new Set();
+var waiters = /* @__PURE__ */ new Set();
+var heldRoots = /* @__PURE__ */ new Set();
+function ownerState(tok) {
+  let state5 = ACTIVE;
+  for (let t = tok; t !== null; ) {
+    const o = t.sub;
+    if (o === null) return ENDED;
+    if (o._frozen === true) state5 = PAUSED;
+    t = o._owner ?? null;
+  }
+  return state5;
+}
+var endWatchers = /* @__PURE__ */ new Set();
+var stateWatchers = /* @__PURE__ */ new Set();
+var stateCheckQueued = false;
+function queueStateCheck() {
+  if (stateCheckQueued || stateWatchers.size === 0) return;
+  stateCheckQueued = true;
+  queueMicrotask(() => {
+    stateCheckQueued = false;
+    for (const watcher of [...stateWatchers]) {
+      if (!stateWatchers.has(watcher)) continue;
+      const state5 = watcher.check.state();
+      if (state5 === ENDED) stateWatchers.delete(watcher);
+      if (state5 === ENDED || state5 === watcher.last) continue;
+      watcher.last = state5;
+      try {
+        watcher.listener(state5);
+      } catch (err) {
+        reportError(err, { phase: "effect" });
+      }
+    }
+  });
+}
+var ALWAYS_ACTIVE = Object.assign(() => false, {
+  state: () => ACTIVE,
+  wait: (onActive) => {
+    onActive();
+    return NOOP;
+  },
+  onEnd: () => NOOP,
+  run: (fn) => fn(),
+  onChange: () => NOOP,
+  within: () => false
+});
+function captureFrozen() {
+  const tok = currentStructOwner;
+  if (tok === null) return ALWAYS_ACTIVE;
+  const state5 = () => ownerState(tok);
+  const check = Object.assign(() => state5() !== ACTIVE, {
+    state: state5,
+    wait: (onActive, onEnd) => {
+      const now = state5();
+      if (now !== PAUSED) {
+        (now === ACTIVE ? onActive : onEnd)();
+        return NOOP;
+      }
+      const waiter = { check, onActive, onEnd };
+      waiters.add(waiter);
+      return () => {
+        waiters.delete(waiter);
+      };
+    },
+    onEnd: (onEnd) => {
+      if (state5() === ENDED) {
+        onEnd();
+        return NOOP;
+      }
+      const watcher = { check, onActive: NOOP, onEnd };
+      endWatchers.add(watcher);
+      return () => {
+        endWatchers.delete(watcher);
+      };
+    },
+    run: (fn) => {
+      const prev = currentStructOwner;
+      currentStructOwner = tok.sub === null ? null : tok;
+      try {
+        return fn();
+      } finally {
+        currentStructOwner = prev;
+      }
+    },
+    onChange: (listener) => {
+      const last = state5();
+      if (last === ENDED) return NOOP;
+      const watcher = { check, last, listener };
+      stateWatchers.add(watcher);
+      return () => {
+        stateWatchers.delete(watcher);
+      };
+    },
+    within: (owner) => {
+      const target = owner.run(() => currentStructOwner);
+      if (target === null) return false;
+      for (let t = tok; t !== null; ) {
+        if (t === target) return true;
+        const o = t.sub;
+        if (o === null) return false;
+        t = o._owner ?? null;
+      }
+      return false;
+    }
+  });
+  return check;
+}
+function holdSubtree(root) {
+  heldRoots.add(root);
+  return () => {
+    if (heldRoots.delete(root)) settleHeld();
+  };
+}
+function isHeld(sub) {
+  if (frozenOwners !== 0 && hasFrozenOwner(sub)) return true;
+  if (heldRoots.size !== 0) {
+    const node = sub._errorNode;
+    if (node != null) {
+      for (const root of heldRoots) if (root.contains(node)) return true;
+    }
+  }
+  return false;
+}
+function notifyEnded() {
+  for (const watcher of stateWatchers) if (watcher.check.state() === ENDED) stateWatchers.delete(watcher);
+  let ended = null;
+  for (const watcher of endWatchers) {
+    if (watcher.check.state() !== ENDED) continue;
+    endWatchers.delete(watcher);
+    (ended ?? (ended = [])).push(watcher);
+  }
+  if (ended === null) return;
+  for (const watcher of ended) {
+    try {
+      watcher.onEnd();
+    } catch (err) {
+      reportError(err, { phase: "cleanup" });
+    }
+  }
+}
+function dropReleasedSkipped() {
+  for (const sub of skippedWhileHeld) {
+    if (sub._disposed === true || sub.depsHead == null) skippedWhileHeld.delete(sub);
+  }
+}
+function settleHeld() {
+  for (const sub of skippedWhileHeld) {
+    if (sub._disposed === true) skippedWhileHeld.delete(sub);
+    else if (!isHeld(sub)) {
+      skippedWhileHeld.delete(sub);
+      if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
+      }
+    }
+  }
+  if (frozenOwners === 0 && heldRoots.size === 0) skippedWhileHeld.clear();
+  let ready = null;
+  for (const waiter of waiters) {
+    if (waiter.check.state() === PAUSED) continue;
+    waiters.delete(waiter);
+    (ready ?? (ready = [])).push(waiter);
+  }
+  if (ready !== null) {
+    const settle = ready;
+    queueMicrotask(() => {
+      for (const waiter of settle) {
+        const state5 = waiter.check.state();
+        if (state5 === PAUSED) waiters.add(waiter);
+        else
+          try {
+            (state5 === ACTIVE ? waiter.onActive : waiter.onEnd)();
+          } catch (err) {
+            reportError(err, { phase: "effect" });
+          }
+      }
+    });
+  }
+  if (pendingQueue.length > 0) drainNotificationQueue();
+}
+function hasFrozenOwner(sub) {
+  for (let t = sub._owner ?? null; t !== null; ) {
+    const o = t.sub;
+    if (o === null) return false;
+    if (o._frozen === true) return true;
+    t = o._owner ?? null;
+  }
+  return false;
+}
 var subscriberEpochCounter = 0;
 function retrack(effectFn, subscriber) {
   const prev = currentSubscriber;
@@ -687,6 +887,20 @@ function structuralBinding(commit, ownerNode) {
       } finally {
         currentStructOwner = prev;
       }
+    },
+    freeze: () => {
+      const s = sub;
+      if (s._disposed || s._frozen) return;
+      s._frozen = true;
+      frozenOwners++;
+      queueStateCheck();
+    },
+    thaw: () => {
+      if (!sub._frozen) return;
+      sub._frozen = false;
+      frozenOwners--;
+      queueStateCheck();
+      settleHeld();
     }
   };
 }
@@ -715,20 +929,34 @@ function createBinding(commit, ownerNode, structural) {
   subscriber._errorNode = ownerNode;
   subscriber._tok = null;
   subscriber._owner = null;
+  subscriber._frozen = false;
   if (structural) subscriber._tok = { sub: subscriber };
   try {
     run();
   } catch (err) {
     subscriber._disposed = true;
     subscriber._errorNode = void 0;
-    if (subscriber._tok != null) subscriber._tok.sub = null;
+    if (subscriber._tok != null) {
+      subscriber._tok.sub = null;
+      if (endWatchers.size !== 0 || stateWatchers.size !== 0) notifyEnded();
+    }
     cleanup(subscriber);
     throw err;
   }
   subscriber._dispose = () => {
     subscriber._disposed = true;
+    const wasFrozen = subscriber._frozen === true;
+    if (wasFrozen) {
+      subscriber._frozen = false;
+      frozenOwners--;
+    }
     subscriber._errorNode = void 0;
-    if (subscriber._tok != null) subscriber._tok.sub = null;
+    if (subscriber._tok != null) {
+      subscriber._tok.sub = null;
+      if (endWatchers.size !== 0 || stateWatchers.size !== 0) notifyEnded();
+      if (skippedWhileHeld.size !== 0) dropReleasedSkipped();
+      if (wasFrozen || waiters.size !== 0) settleHeld();
+    }
     cleanup(subscriber);
   };
   return subscriber;
@@ -838,6 +1066,10 @@ function runPendingOwners(sub) {
   }
 }
 function runQueued(sub) {
+  if ((frozenOwners !== 0 || heldRoots.size !== 0) && isHeld(sub)) {
+    skippedWhileHeld.add(sub);
+    return;
+  }
   if (quarantined.size > 0 && quarantined.has(sub)) return;
   if (sub._hasComputedDep === true && !depsChanged(sub)) return;
   if (tickRepeat(sub)) {
@@ -985,7 +1217,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.14.1" : "dev";
+var _runtimeVersion = true ? "4.15.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
@@ -1021,6 +1253,8 @@ function resolveReactiveApi() {
     runWithOwnerScope,
     bindOwnerScope,
     structuralBinding,
+    captureFrozen,
+    holdSubtree,
     version: _runtimeVersion
   };
   g[REGISTRY_KEY] = local;
@@ -1048,6 +1282,22 @@ var getOwnerScope2 = API.getOwnerScope ?? getOwnerScope;
 var runWithOwnerScope2 = API.runWithOwnerScope ?? runWithOwnerScope;
 var bindOwnerScope2 = API.bindOwnerScope ?? bindOwnerScope;
 var structuralBinding2 = API.structuralBinding ?? ((commit, ownerNode) => ({ stop: API.reactiveBinding(commit, ownerNode), run: (fn) => fn() }));
+var captureFrozen2 = API.captureFrozen ?? (() => Object.assign(() => false, {
+  state: () => 0,
+  wait: (onActive) => {
+    onActive();
+    return () => {
+    };
+  },
+  onEnd: () => () => {
+  },
+  run: (fn) => fn(),
+  onChange: () => () => {
+  },
+  within: () => false
+}));
+var holdSubtree2 = API.holdSubtree ?? (() => () => {
+});
 
 // src/core/devtoolsHook.ts
 function emitDevtools(hook, event, payload) {
@@ -1132,6 +1382,10 @@ function requestSlot(name, create) {
   if (!slots.has(name) && create) slots.set(name, create());
   return slots.get(name);
 }
+var PRERENDER_HOST = /* @__PURE__ */ Symbol.for("sibujs.prerender.v1");
+function isServer() {
+  return getSSRStore().ssr || globalThis[PRERENDER_HOST] !== void 0;
+}
 function runInSSRContext(fn) {
   const store = {
     ssr: true,
@@ -1160,14 +1414,14 @@ function runInSSRContext(fn) {
 }
 function trackPending(promise, label, hydration = true) {
   const store = getRequestStore();
-  const pending = store?.pending;
-  const sessions = pending || !hydration ? [] : hydrationOwners();
-  if (!pending && sessions.length === 0) return promise;
+  const pending2 = store?.pending;
+  const sessions = pending2 || !hydration ? [] : hydrationOwners();
+  if (!pending2 && sessions.length === 0) return promise;
   const entry = { label, since: Date.now(), boundary: currentBoundary() ?? void 0 };
-  pending?.add(entry);
+  pending2?.add(entry);
   const release = holdHydration(sessions, entry);
   const done = () => {
-    pending?.delete(entry);
+    pending2?.delete(entry);
     store?.wake?.();
     release();
   };
@@ -2367,6 +2621,25 @@ function assertA11y(root, options) {
   }
 }
 
+// src/utils/styleKey.ts
+var EXCEPTIONS = { cssFloat: "float" };
+var VENDOR_PREFIX = /^(webkit|moz|ms|o)-/;
+var cache = /* @__PURE__ */ new Map();
+var CACHE_MAX = 1e3;
+function styleKeyToProperty(key) {
+  let name = cache.get(key);
+  if (name !== void 0) return name;
+  if (key.startsWith("--")) name = key;
+  else if (Object.hasOwn(EXCEPTIONS, key)) name = EXCEPTIONS[key];
+  else {
+    name = key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    if (VENDOR_PREFIX.test(name)) name = `-${name}`;
+  }
+  if (cache.size >= CACHE_MAX) cache.clear();
+  cache.set(key, name);
+  return name;
+}
+
 // src/testing/adapters.ts
 function escapeAttrValue(value) {
   return value.replace(/[\\"]/g, "\\$&").replace(/\n/g, "\\a ").replace(/\r/g, "\\d ").replace(/\0/g, "\\fffd ");
@@ -2483,8 +2756,7 @@ function createJestAdapter() {
       toHaveStyle(element, style) {
         const mismatches = [];
         for (const [prop, expected] of Object.entries(style)) {
-          const kebabProp = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-          const actual = element.style.getPropertyValue(kebabProp);
+          const actual = element.style.getPropertyValue(styleKeyToProperty(prop));
           if (actual !== expected) {
             mismatches.push(`${prop}: expected "${expected}" but got "${actual}"`);
           }
@@ -3226,6 +3498,133 @@ ${result.diff ?? ""}`);
   };
 }
 
+// src/core/rendering/heldCommit.ts
+var NOOP2 = () => {
+};
+function commitWhenActive(slot3, c) {
+  let over = false;
+  let unhold = null;
+  let drop = NOOP2;
+  const finish = () => {
+    over = true;
+    if (slot3.cancel === cancel) slot3.cancel = NOOP2;
+    drop();
+    drop = NOOP2;
+  };
+  const cancel = () => {
+    if (over) return;
+    finish();
+    const release = unhold;
+    unhold = null;
+    try {
+      c.discard();
+    } finally {
+      release?.();
+    }
+  };
+  const attempt = () => {
+    drop = NOOP2;
+    let clean = false;
+    while (!over) {
+      const state5 = c.held.state();
+      if (state5 === 2 || c.owned !== void 0 && !c.owned()) {
+        cancel();
+        return;
+      }
+      if (state5 === 1) {
+        if (c.node !== null && unhold === null) unhold = holdSubtree2(c.node);
+        drop = c.held.wait(attempt, attempt);
+        return;
+      }
+      if (unhold !== null) {
+        const release = unhold;
+        unhold = null;
+        release();
+        continue;
+      }
+      if (!clean) {
+        clean = c.teardown?.() !== true;
+        continue;
+      }
+      finish();
+      c.insert();
+      return;
+    }
+  };
+  slot3.cancel = cancel;
+  attempt();
+}
+
+// src/core/rendering/range.ts
+var state3 = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.ranges.v1"), () => ({
+  ends: /* @__PURE__ */ new WeakMap(),
+  pending: /* @__PURE__ */ new WeakMap(),
+  registrations: /* @__PURE__ */ new Set(),
+  listeners: /* @__PURE__ */ new Set(),
+  notice: { queued: false, batch: [] }
+}));
+var ends = state3.ends;
+function registerRange(start, last) {
+  ends.set(start, last);
+}
+var pending = state3.pending;
+var NOTHING = () => {
+};
+var registrations = state3.registrations;
+var loadListeners = state3.listeners;
+var notice = state3.notice;
+function notifyLoad(settled2) {
+  if (loadListeners.size === 0) return;
+  if (settled2 !== null) notice.batch.push(settled2);
+  if (notice.queued) return;
+  notice.queued = true;
+  queueMicrotask(() => {
+    notice.queued = false;
+    const batch2 = notice.batch;
+    notice.batch = [];
+    for (const listener of [...loadListeners]) listener(batch2);
+  });
+}
+function beginPending(at, held) {
+  const entry = { at, held, settled: false, cancelled: false, committed: null };
+  registrations.add(entry);
+  notifyLoad(null);
+  const settle = (cancelled, committed) => {
+    if (entry.settled) return;
+    entry.settled = true;
+    entry.cancelled = cancelled;
+    entry.committed = committed;
+    registrations.delete(entry);
+    notifyLoad(entry);
+  };
+  return {
+    entry,
+    done: (committed) => settle(false, committed ?? null),
+    cancel: () => settle(true, null)
+  };
+}
+var INERT = { done: NOTHING, cancel: NOTHING };
+function beginLoading(anchor) {
+  if (isServer()) return INERT;
+  const { done, cancel } = beginPending(anchor, null);
+  return { done: () => done(), cancel };
+}
+function registerNodesRange(anchor, nodes) {
+  registerRange(anchor, () => {
+    const parent = anchor.parentNode;
+    const wanted = nodes().filter((n) => n !== null && n.parentNode === parent);
+    let last = null;
+    let left = wanted.length;
+    for (let n = anchor.nextSibling; n !== null && left > 0; n = n.nextSibling) {
+      if (wanted.includes(n)) {
+        last = n;
+        left--;
+      }
+    }
+    return last;
+  });
+}
+
 // src/utils/sanitize.ts
 function stripControlChars(value) {
   return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
@@ -3746,7 +4145,7 @@ var isBatching = API2.isBatching;
 // src/core/signals/signal.ts
 var _g2 = globalThis;
 function signal(initial, options) {
-  const state3 = {
+  const state5 = {
     value: initial,
     __v: 0,
     __sc: 0,
@@ -3759,57 +4158,57 @@ function signal(initial, options) {
   };
   const debugName = DEV ? options?.name : void 0;
   const equalsFn = options?.equals;
-  if (debugName) state3.__name = debugName;
+  if (debugName) state5.__name = debugName;
   function get() {
-    recordDependency2(state3);
-    return state3.value;
+    recordDependency2(state5);
+    return state5.value;
   }
-  get.__signal = state3;
+  get.__signal = state5;
   if (debugName) get.__name = debugName;
   let set;
   if (equalsFn) {
     set = (next) => {
-      const prev = state3.value;
+      const prev = state5.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (equalsFn(prev, newValue)) return;
-      state3.value = newValue;
-      state3.__v++;
+      state5.value = newValue;
+      state5.__v++;
       if (DEV) {
         const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-        if (hook) emitDevtools(hook, "signal:update", { signal: state3, name: debugName, oldValue: prev, newValue });
+        if (hook) emitDevtools(hook, "signal:update", { signal: state5, name: debugName, oldValue: prev, newValue });
       }
-      if (!enqueueBatchedSignal(state3)) {
-        notifySubscribers2(state3);
+      if (!enqueueBatchedSignal(state5)) {
+        notifySubscribers2(state5);
       }
     };
   } else if (DEV) {
     set = (next) => {
-      const prev = state3.value;
+      const prev = state5.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state3.value = newValue;
-      state3.__v++;
+      state5.value = newValue;
+      state5.__v++;
       const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-      if (hook) emitDevtools(hook, "signal:update", { signal: state3, name: debugName, oldValue: prev, newValue });
-      if (!enqueueBatchedSignal(state3)) {
-        notifySubscribers2(state3);
+      if (hook) emitDevtools(hook, "signal:update", { signal: state5, name: debugName, oldValue: prev, newValue });
+      if (!enqueueBatchedSignal(state5)) {
+        notifySubscribers2(state5);
       }
     };
   } else {
     set = (next) => {
-      const prev = state3.value;
+      const prev = state5.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state3.value = newValue;
-      state3.__v++;
-      if (!enqueueBatchedSignal(state3)) {
-        notifySubscribers2(state3);
+      state5.value = newValue;
+      state5.__v++;
+      if (!enqueueBatchedSignal(state5)) {
+        notifySubscribers2(state5);
       }
     };
   }
   if (DEV) {
     const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (hook) emitDevtools(hook, "signal:create", { signal: state3, name: debugName, getter: get, initial });
+    if (hook) emitDevtools(hook, "signal:create", { signal: state5, name: debugName, getter: get, initial });
   }
   return [get, set];
 }
@@ -4856,15 +5255,15 @@ var _ComponentLoader = class _ComponentLoader {
     const cached = this.planCache.get(cacheKey);
     if (cached && cached.kind === "factory") return cached.component;
     this.assertNotHot(cacheKey);
-    let pending = this.moduleLoads.get(cacheKey);
-    const owner = pending === void 0;
-    if (pending === void 0) {
-      pending = plan.load();
-      this.moduleLoads.set(cacheKey, pending);
+    let pending2 = this.moduleLoads.get(cacheKey);
+    const owner = pending2 === void 0;
+    if (pending2 === void 0) {
+      pending2 = plan.load();
+      this.moduleLoads.set(cacheKey, pending2);
     }
     let resolved;
     try {
-      resolved = await pending;
+      resolved = await pending2;
     } catch (error) {
       this.noteError(cacheKey);
       throw error;
@@ -4886,7 +5285,14 @@ var _ComponentLoader = class _ComponentLoader {
    * is a configuration error, not something to chase.
    */
   async instantiateFactory(component, route2, routePath, scope, depth = 0) {
-    const build = () => scope ? runWithOwnerScope2(scope, component) : component();
+    const gate = scope?.gate;
+    if (gate) {
+      while (gate.held()) if (!await gate.until()) throw gate.cancellation();
+      if (scope?.current?.() === false) throw gate.cancellation();
+    }
+    const owner = scope?.owner;
+    const invoke = () => scope ? runWithOwnerScope2(scope, component) : component();
+    const build = owner ? () => owner.run(invoke) : invoke;
     const result = scope?.adopt ? inScope(scope.adopt, build) : build();
     const value = this.isThenable(result) ? await result : result;
     if (this.isElement(value)) return value;
@@ -5095,7 +5501,7 @@ var _SibuRouter = class _SibuRouter {
     return this.loadedPromise;
   }
   createInitialRoute() {
-    return {
+    const route2 = {
       path: "/",
       params: {},
       query: {},
@@ -5104,6 +5510,8 @@ var _SibuRouter = class _SibuRouter {
       meta: {},
       matched: []
     };
+    bootstrapRoutes.add(route2);
+    return route2;
   }
   handleLocationChange(skipHistory = true, initialResolution = false) {
     const path = this.getCurrentPath();
@@ -5144,8 +5552,31 @@ var _SibuRouter = class _SibuRouter {
       matched
     };
   }
+  /**
+   * Once no navigation is in flight: if the route is still the placeholder
+   * the router started with — every navigation that could have replaced it
+   * was cancelled by a guard, failed, or was a duplicate — that IS the
+   * outcome, and the outlets that rendered nothing for it settle (see
+   * `settleEmpty`). Checked when a navigation has definitively completed,
+   * never from `isReady` (set before the guards run). A navigation still
+   * pending — a newer one, or a guard that never resolves — keeps them
+   * pending; an outlet's enter is bounded by its own deadline then.
+   */
+  settleBootstrap() {
+    if (this.destroyed || this.navigator.isNavigating) return;
+    const current2 = untracked2(() => this.currentRouteGetter());
+    if (!bootstrapRoutes.delete(current2)) return;
+    const waiting = bootstrapWaiters.get(current2);
+    bootstrapWaiters.delete(current2);
+    if (waiting) for (const settle of waiting) settle();
+  }
   // Public API
   async navigate(to, options = {}) {
+    const result = await this.attemptNavigation(to, options);
+    this.settleBootstrap();
+    return result;
+  }
+  async attemptNavigation(to, options) {
     try {
       await this.navigator.navigate(async (signal2) => {
         const targetPath = this.resolvePath(to);
@@ -5399,6 +5830,13 @@ var _SibuRouter = class _SibuRouter {
   /**
    * Create exactly one real instance from an already-resolved plan. With a
    * `scope`, the factory runs in it (see `RouteScope`).
+   *
+   * When the scope belongs to an outlet whose branch is paused (playing a
+   * leave it may still be taken back from), a lazy module that resolves does
+   * not run its factory yet: the promise stays pending and continues once the
+   * branch resumes. If the branch ends, or the outlet's pass was superseded
+   * meanwhile, it rejects with a `DOMException` named `"AbortError"`. Genuine
+   * loader and component failures reject with their own error, as before.
    */
   async instantiateComponent(plan, route2, routePath, scope) {
     return prerenderWait(this.loader.instantiate(plan, route2, routePath, scope), `router:render ${route2.path}`);
@@ -5643,6 +6081,21 @@ var RouteScope = class {
   constructor(route2) {
     /** Creation scope the instance is built in (adopting hydration); see `adoptScope`. */
     this.adopt = null;
+    /**
+     * The outlet's pause gate: while the branch holding the outlet is paused (it
+     * began a leave and may still be taken back), a lazy module that resolves
+     * does not get its factory invoked yet; instantiation waits for the branch
+     * to resume, and is cancelled if it ends.
+     */
+    this.gate = null;
+    /** Whether the outlet pass this instance is for is still the current one. */
+    this.current = null;
+    /**
+     * The instance's structural owner, nested under the outlet's: its factory
+     * runs as it, so what it creates is paused with the branch holding the
+     * outlet, and ends (`lifecycleScope()` work included) with the instance.
+     */
+    this.owner = null;
     this.released = false;
     const [get, set] = signal(route2);
     this.get = get;
@@ -5669,6 +6122,112 @@ var RouteScope = class {
     queueMicrotask(() => this.set(null));
   }
 };
+var NOOP3 = () => {
+};
+var bootstrapRoutes = /* @__PURE__ */ new WeakSet();
+var bootstrapWaiters = /* @__PURE__ */ new WeakMap();
+function settleEmpty(route2, loaded, current2) {
+  if (!bootstrapRoutes.has(route2)) {
+    loaded.done();
+    return;
+  }
+  let waiting = bootstrapWaiters.get(route2);
+  if (waiting === void 0) bootstrapWaiters.set(route2, waiting = /* @__PURE__ */ new Set());
+  waiting.add(() => {
+    if (current2()) loaded.done();
+  });
+}
+var cancellations = /* @__PURE__ */ new WeakSet();
+function pauseGate(frozen) {
+  let closed = false;
+  const pending2 = /* @__PURE__ */ new Set();
+  return {
+    held: () => closed || frozen(),
+    until: () => {
+      if (closed) return Promise.resolve(false);
+      return new Promise((resolve) => {
+        const settle = (active) => {
+          pending2.delete(cancel);
+          resolve(active && !closed);
+        };
+        const drop = frozen.wait(
+          () => settle(true),
+          () => settle(false)
+        );
+        const cancel = () => {
+          drop();
+          settle(false);
+        };
+        pending2.add(cancel);
+      });
+    },
+    cancellation: () => {
+      const error = new DOMException("Route instantiation cancelled: its branch was released", "AbortError");
+      cancellations.add(error);
+      return error;
+    },
+    close: () => {
+      closed = true;
+      for (const cancel of [...pending2]) cancel();
+    },
+    run: frozen.run,
+    frozen,
+    closed: () => closed,
+    onClose: (fn) => {
+      pending2.add(fn);
+      return () => {
+        pending2.delete(fn);
+      };
+    }
+  };
+}
+function whenActive(gate, fn) {
+  if (!gate.held()) fn();
+  else
+    void gate.until().then((active) => {
+      if (active) whenActive(gate, fn);
+    });
+}
+function commitPass(gate, c) {
+  const frozen = gate.frozen;
+  const held = {
+    state: frozen.state,
+    wait: (onActive, onEnd) => {
+      let live = true;
+      const later = (fn) => () => {
+        void Promise.resolve().then(() => {
+          if (live) fn();
+        });
+      };
+      const drop = frozen.wait(later(onActive), later(onEnd));
+      return () => {
+        live = false;
+        drop();
+      };
+    }
+  };
+  return new Promise((resolve, reject) => {
+    const slot3 = { cancel: NOOP3 };
+    const untrack = gate.onClose(() => slot3.cancel());
+    const settle = (fn) => () => {
+      untrack();
+      try {
+        fn();
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    };
+    commitWhenActive(slot3, {
+      held,
+      node: c.node,
+      owned: () => !gate.closed() && c.owned(),
+      teardown: c.teardown,
+      insert: settle(c.insert),
+      discard: settle(c.discard)
+    });
+  });
+}
 function activeRouteScope() {
   const scope = getOwnerScope2();
   return scope instanceof RouteScope ? scope : null;
@@ -5682,14 +6241,27 @@ function scopedRoute(router) {
   return router.currentRoute;
 }
 var instanceScopes = /* @__PURE__ */ new WeakMap();
-async function instantiateScoped(router, plan, routeDef, routePath, route2, adopt = null) {
+async function instantiateScoped(router, plan, routeDef, routePath, route2, adopt = null, gate = null, current2 = null) {
   const scope = new RouteScope(route2);
   scope.adopt = adopt;
-  const node = await router.instantiateComponent(plan, routeDef, routePath, scope);
+  scope.gate = gate;
+  scope.current = current2;
+  const owner = gate ? gate.run(() => structuralBinding2(NOOP3)) : structuralBinding2(NOOP3);
+  scope.owner = owner;
+  let node;
+  try {
+    node = await router.instantiateComponent(plan, routeDef, routePath, scope);
+  } catch (error) {
+    owner.stop();
+    throw error;
+  }
   if (node) {
     instanceScopes.set(node, scope);
-    registerDisposer(node, () => scope.release());
-  }
+    registerDisposer(node, () => {
+      owner.stop();
+      scope.release();
+    });
+  } else owner.stop();
   return node;
 }
 function updateInstanceRoute(node, route2) {
@@ -5732,6 +6304,8 @@ function instanceKey(owner, records, route2) {
 function Route() {
   const anchor = document.createComment("route-outlet");
   const adoptScope = captureScope();
+  const frozen = captureFrozen2();
+  const gate = pauseGate(frozen);
   let currentNode = null;
   let loadingNode = null;
   let errorNode = null;
@@ -5739,6 +6313,7 @@ function Route() {
   let currentTopRoute = null;
   let currentKey = null;
   let routeTorn = false;
+  const loaded = beginLoading(anchor);
   const commitTarget = (seq) => routeTorn || seq !== navSeq ? null : anchor.parentNode;
   const retryIfDetached = (seq) => {
     if (!routeTorn && seq === navSeq && !anchor.parentNode) attachWait.request();
@@ -5783,24 +6358,54 @@ function Route() {
       loadingNode = null;
     }
   };
-  const showError = (error, routeDef) => {
+  const showError = (seq, error, routeDef) => {
     if (!anchor.parentNode) return;
-    cleanupNodes();
-    errorNode = document.createElement("div");
-    errorNode.className = "route-error";
-    errorNode.setAttribute("role", "alert");
-    errorNode.setAttribute("aria-live", "assertive");
+    const view = errorView(error, routeDef);
+    void commitPass(gate, {
+      node: view,
+      owned: () => !routeTorn && seq === navSeq,
+      discard: () => dispose(view),
+      teardown: () => {
+        if (!anchor.parentNode || !(currentNode || loadingNode || errorNode)) return false;
+        cleanupNodes();
+        return true;
+      },
+      insert: () => {
+        const parent = anchor.parentNode;
+        if (!parent) {
+          dispose(view);
+          unshownFailure = { seq, error, routeDef };
+          attachWait.request();
+          return;
+        }
+        errorNode = view;
+        try {
+          parent.insertBefore(view, anchor.nextSibling);
+        } catch (err) {
+          if (errorNode === view) errorNode = null;
+          release(view);
+          throw err;
+        }
+        if (!routeTorn && seq === navSeq) loaded.done();
+      }
+    }).catch((err) => console.error("[Route] Error view failed:", err));
+  };
+  const errorView = (error, routeDef) => {
+    const errorNode2 = document.createElement("div");
+    errorNode2.className = "route-error";
+    errorNode2.setAttribute("role", "alert");
+    errorNode2.setAttribute("aria-live", "assertive");
     if (routeDef && "component" in routeDef) {
       const src = routeDef.component.toString();
       const importMatch = src.match(/import\(["']([^"']+)["']\)/);
       if (importMatch) {
-        errorNode.setAttribute("data-component-source", importMatch[1]);
+        errorNode2.setAttribute("data-component-source", importMatch[1]);
       }
       if (routeDef.component.name) {
-        errorNode.setAttribute("data-component-name", routeDef.component.name);
+        errorNode2.setAttribute("data-component-name", routeDef.component.name);
       }
     }
-    errorNode.__routeError = error;
+    errorNode2.__routeError = error;
     const title = document.createElement("h3");
     title.textContent = "Route Error";
     title.className = "route-error-title";
@@ -5819,10 +6424,10 @@ function Route() {
     };
     retryButton.addEventListener("click", onRetryClick);
     registerDisposer(retryButton, () => retryButton.removeEventListener("click", onRetryClick));
-    errorNode.appendChild(title);
-    errorNode.appendChild(message);
-    errorNode.appendChild(retryButton);
-    anchor.parentNode.insertBefore(errorNode, anchor.nextSibling);
+    errorNode2.appendChild(title);
+    errorNode2.appendChild(message);
+    errorNode2.appendChild(retryButton);
+    return errorNode2;
   };
   const update = async () => {
     routerRevision();
@@ -5835,12 +6440,14 @@ function Route() {
         currentTopRoute = null;
         currentKey = null;
         cleanupNodes();
+        settleEmpty(route2, loaded, () => !routeTorn && seq === navSeq);
         return;
       }
       const routeDef = match.matched[0] || match.route;
       const key = instanceKey(routeDef, [routeDef], route2);
       if (routeDef === currentTopRoute && key === currentKey && currentNode) {
         updateInstanceRoute(currentNode, route2);
+        loaded.done();
         return;
       }
       if ("redirect" in routeDef) {
@@ -5859,6 +6466,7 @@ function Route() {
             showLoading();
           }
           const plan = await _routerRef.current.loadPlan(routeDef, route2.path);
+          while (gate.held()) if (!await gate.until()) return;
           if (!commitTarget(seq)) {
             retryIfDetached(seq);
             return;
@@ -5869,28 +6477,57 @@ function Route() {
             routeDef,
             route2.path,
             route2,
-            keyedScope(adoptScope, routeDef.path)
+            keyedScope(adoptScope, routeDef.path),
+            gate,
+            () => commitTarget(seq) !== null
           );
-          const parent = commitTarget(seq);
-          if (!parent) {
-            release(node);
-            retryIfDetached(seq);
-            return;
-          }
-          if (node) {
-            currentTopRoute = routeDef;
-            currentKey = key;
-            cleanupNodes();
-            parent.insertBefore(node, anchor.nextSibling);
-            currentNode = node;
-          }
+          await commitPass(gate, {
+            node,
+            owned: () => !routeTorn && seq === navSeq,
+            discard: () => release(node),
+            // The outgoing views go first — only when there is a page to
+            // show, and a parent to show it in.
+            teardown: () => {
+              if (!node || !anchor.parentNode || !(currentNode || loadingNode || errorNode)) return false;
+              cleanupNodes();
+              return true;
+            },
+            insert: () => {
+              const parent = commitTarget(seq);
+              if (!parent) {
+                release(node);
+                retryIfDetached(seq);
+                return;
+              }
+              if (node) {
+                currentTopRoute = routeDef;
+                currentKey = key;
+                currentNode = node;
+                try {
+                  parent.insertBefore(node, anchor.nextSibling);
+                } catch (error) {
+                  if (currentNode === node) {
+                    currentNode = null;
+                    currentTopRoute = null;
+                    currentKey = null;
+                  }
+                  release(node);
+                  throw error;
+                }
+              }
+              if (!routeTorn && seq === navSeq) loaded.done();
+            }
+          });
         } catch (error) {
+          if (cancellations.has(error)) return;
           if (routeTorn || seq !== navSeq) return;
-          hideLoading();
           console.error("[Route] Component error:", error);
+          while (gate.held()) if (!await gate.until()) return;
+          if (routeTorn || seq !== navSeq) return;
+          hideLoading();
           fail(seq, error, routeDef);
         }
-      }
+      } else settleEmpty(route2, loaded, () => !routeTorn && seq === navSeq);
     } catch (error) {
       if (seq !== navSeq) return;
       if (routeTorn) return;
@@ -5902,16 +6539,20 @@ function Route() {
   const fail = (seq, error, routeDef) => {
     const err = error instanceof Error ? error : new Error(String(error));
     if (anchor.parentNode) {
-      showError(err, routeDef);
+      showError(seq, err, routeDef);
       return;
     }
     unshownFailure = { seq, error: err, routeDef };
     attachWait.request();
   };
   const onAttached = () => {
+    if (gate.held()) {
+      void gate.until().then((active) => active && onAttached());
+      return;
+    }
     const failure = unshownFailure;
     unshownFailure = null;
-    if (failure && failure.seq === navSeq) showError(failure.error, failure.routeDef);
+    if (failure && failure.seq === navSeq) showError(failure.seq, failure.error, failure.routeDef);
     else update();
   };
   let routeInitialized = false;
@@ -5921,11 +6562,16 @@ function Route() {
     routeInitialized = true;
   };
   const attachWait = attachRetry(anchor, onAttached);
-  const routeTeardown = track2(wrappedUpdate);
+  const routeTeardown = reactiveBinding2(wrappedUpdate, anchor);
   if (!routeInitialized) {
     queueMicrotask(
       bindOwnerScope2(() => {
-        if (!routeInitialized && anchor.parentNode) wrappedUpdate();
+        whenActive(
+          gate,
+          bindOwnerScope2(() => {
+            if (!routeInitialized && anchor.parentNode) wrappedUpdate();
+          })
+        );
       })
     );
   }
@@ -5933,6 +6579,8 @@ function Route() {
     if (routeTorn) return;
     routeTorn = true;
     navSeq++;
+    gate.close();
+    loaded.cancel();
     routeTeardown();
     attachWait.cancel();
     unshownFailure = null;
@@ -5940,6 +6588,7 @@ function Route() {
     currentTopRoute = null;
     currentKey = null;
   };
+  registerNodesRange(anchor, () => [currentNode, loadingNode, errorNode]);
   registerDisposer(anchor, routeCleanup);
   routeCleanups.push(routeCleanup);
   return anchor;
@@ -5969,14 +6618,14 @@ function ensureRouterPagehide() {
 }
 
 // src/utils/embedPolicy.ts
-var state2 = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.embed.v2"), () => ({
+var state4 = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.embed.v2"), () => ({
   allowed: [],
   frames: /* @__PURE__ */ new WeakMap()
 }));
 var REQUEST_CACHE = "embed";
 function currentEmbedAllowlist() {
   const scoped = getRequestStore()?.caches?.get(REQUEST_CACHE)?.get("allowed");
-  return scoped ?? state2.allowed;
+  return scoped ?? state4.allowed;
 }
 function resolveEmbedSrc(value, allowed = currentEmbedAllowlist()) {
   if (typeof value !== "string" || sanitizeUrl(value) === "") return null;
@@ -6036,7 +6685,7 @@ function narrowEmbedAllow(value) {
   return granted.filter((feature) => !denied.includes(feature)).join("; ");
 }
 function getEmbedRecord(frame) {
-  return state2.frames.get(frame);
+  return state4.frames.get(frame);
 }
 function intersect(current2, permitted, separator) {
   const allowed = permitted.split(separator);
@@ -6797,12 +7446,6 @@ function splitDeclarations(text) {
   out.push(text.slice(start));
   return out;
 }
-var CAMEL_EXCEPTIONS = { cssFloat: "float" };
-function toKebab(prop) {
-  if (prop.startsWith("--")) return prop;
-  if (Object.hasOwn(CAMEL_EXCEPTIONS, prop)) return CAMEL_EXCEPTIONS[prop];
-  return prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`).replace(/^(webkit|moz|ms)-/, "-$1-");
-}
 var ServerStyle = class {
   constructor(el) {
     this.el = el;
@@ -6897,13 +7540,13 @@ function styleProxy(style) {
     get(target, key, receiver) {
       if (typeof key === "string" && !(key in target)) {
         if (/^\d+$/.test(key)) return target.item(Number(key));
-        return target.getPropertyValue(toKebab(key));
+        return target.getPropertyValue(styleKeyToProperty(key));
       }
       return Reflect.get(target, key, receiver);
     },
     set(target, key, value, receiver) {
       if (typeof key === "string" && !(key in target)) {
-        target.setProperty(toKebab(key), value == null ? "" : String(value));
+        target.setProperty(styleKeyToProperty(key), value == null ? "" : String(value));
         return true;
       }
       return Reflect.set(target, key, value, receiver);
@@ -7735,21 +8378,21 @@ function compileSelector(selector) {
     const tokens = text.match(/(?:\\.|\[[^\]]*\]|[^\s>])+|>/g) ?? [];
     const compounds = [];
     const combinators = [];
-    let pending = " ";
+    let pending2 = " ";
     let scoped = false;
     for (const token of tokens) {
       if (token === ">") {
-        pending = ">";
+        pending2 = ">";
         continue;
       }
       if (token === ":scope") {
         scoped = true;
-        pending = " ";
+        pending2 = " ";
         continue;
       }
-      if (compounds.length > 0) combinators.unshift(pending);
+      if (compounds.length > 0) combinators.unshift(pending2);
       compounds.unshift(parseCompound(token, selector));
-      pending = " ";
+      pending2 = " ";
     }
     if (compounds.length === 0) throw syntaxError(selector);
     groups.push({ compounds, combinators, scoped });
@@ -8016,14 +8659,14 @@ async function settled(_root, options = {}) {
   const deadline = Date.now() + timeout;
   for (; ; ) {
     await macrotask();
-    const pending = store?.pending;
-    if (!pending || pending.size === 0) {
+    const pending2 = store?.pending;
+    if (!pending2 || pending2.size === 0) {
       await macrotask();
-      if (!pending || pending.size === 0) return { timedOut: false, pending: [] };
+      if (!pending2 || pending2.size === 0) return { timedOut: false, pending: [] };
       continue;
     }
     const remaining = deadline - Date.now();
-    if (remaining <= 0) return { timedOut: true, pending: describePending(pending) };
+    if (remaining <= 0) return { timedOut: true, pending: describePending(pending2) };
     await new Promise((resolve) => {
       const done = () => {
         clearTimeout(timer);
@@ -8035,9 +8678,9 @@ async function settled(_root, options = {}) {
     });
   }
 }
-function describePending(pending) {
+function describePending(pending2) {
   const now = Date.now();
-  return Array.from(pending, (work) => `${work.label} (${now - work.since} ms)`);
+  return Array.from(pending2, (work) => `${work.label} (${now - work.since} ms)`);
 }
 function formatRenderDiagnostics(d, label = "render") {
   const lines = [
@@ -8165,7 +8808,7 @@ async function renderCore(input, options) {
     releaseTree();
     throw err;
   }
-  let state3 = "";
+  let state5 = "";
   let stateData = null;
   let stateBytes = 0;
   let largestState = [];
@@ -8174,7 +8817,7 @@ async function renderCore(input, options) {
     const collected = collectTransfer();
     if (collected) {
       const built = buildTransfer(collected, options.maxStateBytes ?? DEFAULT_TRANSFER_MAX_BYTES, options.nonce);
-      state3 = built.script;
+      state5 = built.script;
       stateData = built.data;
       stateBytes = built.bytes;
       largestState = built.largest;
@@ -8195,7 +8838,7 @@ async function renderCore(input, options) {
   if (DEV && options.log) {
     console.info(formatRenderDiagnostics(diagnostics, typeof options.log === "string" ? options.log : void 0));
   }
-  return { content, result: { head, state: state3, stateData, status: 200, diagnostics } };
+  return { content, result: { head, state: state5, stateData, status: 200, diagnostics } };
 }
 function inRequest(api, fn) {
   try {
@@ -8733,12 +9376,12 @@ async function hydrateAdopt(component, container, options = {}) {
       inScope(rootScope, () => session.place(container, tree));
     }
     const deadline = Date.now() + (options.timeout ?? 1e4);
-    const { pending, wake } = hydration;
+    const { pending: pending2, wake } = hydration;
     for (; ; ) {
       await macrotask2();
-      if (pending.size === 0) {
+      if (pending2.size === 0) {
         await macrotask2();
-        if (pending.size === 0) break;
+        if (pending2.size === 0) break;
         continue;
       }
       const remaining = deadline - Date.now();
@@ -9201,12 +9844,12 @@ function escapeScriptJson(json) {
 }
 var DEFAULT_MAX_SSR_BYTES = 1024 * 1024;
 var SAFE_GLOBAL_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-function serializeState(state3, nonce, options) {
+function serializeState(state5, nonce, options) {
   const globalName = options?.global ?? SSR_DATA_ATTR;
   if (!SAFE_GLOBAL_NAME.test(globalName)) {
     throw new Error(`[SibuJS SSR] serializeState: global must be an identifier (got: ${JSON.stringify(globalName)})`);
   }
-  const rawJson = JSON.stringify(state3);
+  const rawJson = JSON.stringify(state5);
   const maxBytes = options?.maxBytes ?? DEFAULT_MAX_SSR_BYTES;
   const byteLen = typeof TextEncoder !== "undefined" ? new TextEncoder().encode(rawJson).byteLength : Buffer.byteLength(rawJson, "utf8");
   if (byteLen > maxBytes) {
@@ -9272,17 +9915,17 @@ function renderRoute(routes, url, options = {}) {
     const started = Date.now();
     const deadline = started + (options.timeout ?? DEFAULT_SETTLE_TIMEOUT);
     const router = createRouter(routes, { ...options.router, mode: "memory", url });
-    const wrap = (body, headHtml, state3) => options.document ? assembleDocument(body, options.document, headHtml, state3) : body;
+    const wrap = (body, headHtml, state5) => options.document ? assembleDocument(body, options.document, headHtml, state5) : body;
     const timedOut = (phase) => {
       const now = Date.now();
-      const pending = [
+      const pending2 = [
         `${phase} (${now - started} ms)`,
         ...Array.from(getRequestStore()?.pending ?? [], (work) => `${work.label} (${now - work.since} ms)`)
       ];
-      const diagnostics = { ...emptyDiagnostics(), timedOut: true, pending, durationMs: now - started };
+      const diagnostics = { ...emptyDiagnostics(), timedOut: true, pending: pending2, durationMs: now - started };
       if (DEV) {
         console.warn(
-          `[SibuJS SSR] ${url}: the route did not render within ${options.timeout ?? DEFAULT_SETTLE_TIMEOUT} ms; pending: ${pending.join(", ")}`
+          `[SibuJS SSR] ${url}: the route did not render within ${options.timeout ?? DEFAULT_SETTLE_TIMEOUT} ms; pending: ${pending2.join(", ")}`
         );
       }
       return {
@@ -9832,14 +10475,14 @@ function mockRouter(initialPath = "/") {
   return { currentPath, navigate, history: history2 };
 }
 function mockStore(initialState) {
-  let state3 = { ...initialState };
+  let state5 = { ...initialState };
   return {
-    getState: () => ({ ...state3 }),
+    getState: () => ({ ...state5 }),
     setState: (patch) => {
-      state3 = { ...state3, ...patch };
+      state5 = { ...state5, ...patch };
     },
     reset: () => {
-      state3 = { ...initialState };
+      state5 = { ...initialState };
     }
   };
 }