sibujs 4.14.0 → 4.15.0

package/dist/extras.cjs

@@ -452,6 +452,12 @@ function reportError(error, context) {
   });
 }
 
+// src/utils/globalSingleton.ts
+function globalSingleton(key, create) {
+  const g2 = globalThis;
+  return g2[key] ?? (g2[key] = create());
+}
+
 // src/core/rendering/adoptScope.ts
 var current = null;
 function inAdoptScope() {
@@ -557,7 +563,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(label2, executed, remaining) {
   if (typeof console === "undefined") return;
@@ -566,13 +577,13 @@ function reportDrainRunaway(label2, 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]);
 }
@@ -591,7 +602,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]);
 }
@@ -644,7 +655,7 @@ function unregisterDisposer(node, teardown) {
   const index = disposers.indexOf(teardown);
   if (index === -1) return false;
   disposers.splice(index, 1);
-  if (DEV) activeBindingCount--;
+  if (DEV) bindings.count--;
   if (disposers.length === 0) elementDisposers.delete(node);
   return true;
 }
@@ -668,17 +679,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 i2 = 0; i2 < snapshot.length; i2++) {
       if (executed >= MAX_DRAIN_TEARDOWNS) {
         const rest = snapshot.slice(i2);
         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;
@@ -881,6 +892,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(sub2) {
+  if (frozenOwners !== 0 && hasFrozenOwner(sub2)) return true;
+  if (heldRoots.size !== 0) {
+    const node = sub2._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 sub2 of skippedWhileHeld) {
+    if (sub2._disposed === true || sub2.depsHead == null) skippedWhileHeld.delete(sub2);
+  }
+}
+function settleHeld() {
+  for (const sub2 of skippedWhileHeld) {
+    if (sub2._disposed === true) skippedWhileHeld.delete(sub2);
+    else if (!isHeld(sub2)) {
+      skippedWhileHeld.delete(sub2);
+      if (!pendingSet.has(sub2)) {
+        pendingSet.add(sub2);
+        pendingQueue.push(sub2);
+      }
+    }
+  }
+  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(sub2) {
+  for (let t = sub2._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;
@@ -988,6 +1194,20 @@ function structuralBinding(commit, ownerNode) {
       } finally {
         currentStructOwner = prev;
       }
+    },
+    freeze: () => {
+      const s2 = sub2;
+      if (s2._disposed || s2._frozen) return;
+      s2._frozen = true;
+      frozenOwners++;
+      queueStateCheck();
+    },
+    thaw: () => {
+      if (!sub2._frozen) return;
+      sub2._frozen = false;
+      frozenOwners--;
+      queueStateCheck();
+      settleHeld();
     }
   };
 }
@@ -1016,20 +1236,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;
@@ -1139,6 +1373,10 @@ function runPendingOwners(sub2) {
   }
 }
 function runQueued(sub2) {
+  if ((frozenOwners !== 0 || heldRoots.size !== 0) && isHeld(sub2)) {
+    skippedWhileHeld.add(sub2);
+    return;
+  }
   if (quarantined.size > 0 && quarantined.has(sub2)) return;
   if (sub2._hasComputedDep === true && !depsChanged(sub2)) return;
   if (tickRepeat(sub2)) {
@@ -1286,7 +1524,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.14.0" : "dev";
+var _runtimeVersion = true ? "4.15.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
@@ -1322,6 +1560,8 @@ function resolveReactiveApi() {
     runWithOwnerScope,
     bindOwnerScope,
     structuralBinding,
+    captureFrozen,
+    holdSubtree,
     version: _runtimeVersion
   };
   g2[REGISTRY_KEY] = local;
@@ -1349,6 +1589,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) {
@@ -1598,14 +1854,14 @@ function runInSSRContext(fn) {
 }
 function trackPending(promise, label2, 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: label2, 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();
   };
@@ -1804,7 +2060,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,
@@ -1817,67 +2073,61 @@ 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];
 }
 
-// src/utils/globalSingleton.ts
-function globalSingleton(key, create) {
-  const g2 = globalThis;
-  return g2[key] ?? (g2[key] = create());
-}
-
 // src/utils/guards.ts
 var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function isUnsafeKey(key) {
@@ -2183,10 +2433,10 @@ function primeFromTransfer() {
   }
 }
 registerTransferCollector("q", () => {
-  const cache = getRequestScopedCache("query");
-  if (!cache) return void 0;
+  const cache2 = getRequestScopedCache("query");
+  if (!cache2) return void 0;
   const out = {};
-  for (const [key, entry] of cache) {
+  for (const [key, entry] of cache2) {
     if (entry.noTransfer || entry.data === void 0 || entry.error) continue;
     out[key] = { d: entry.data, t: entry.dataUpdatedAt };
   }
@@ -2200,8 +2450,8 @@ function abandonEntry(entry) {
   entry.promise = null;
   entry.generation++;
 }
-function getOrCreateEntry(cache, key, initialData) {
-  let entry = cache.get(key);
+function getOrCreateEntry(cache2, key, initialData) {
+  let entry = cache2.get(key);
   if (!entry) {
     entry = {
       data: initialData,
@@ -2219,7 +2469,7 @@ function getOrCreateEntry(cache, key, initialData) {
       sharedFrom: void 0,
       hasShared: false
     };
-    cache.set(key, entry);
+    cache2.set(key, entry);
   }
   return entry;
 }
@@ -2244,7 +2494,7 @@ function query(key, fetcher, options = {}) {
   const resolveKey = typeof key === "function" ? key : () => key;
   const enabledGate = typeof enabled === "function" ? derived(() => Boolean(enabled())) : null;
   const isEnabled = onServer && !ssr ? () => false : enabledGate ?? (() => Boolean(enabled));
-  const cache = getActiveQueryCache();
+  const cache2 = getActiveQueryCache();
   const [data2, setData] = signal(initialData);
   const [isFetching, setIsFetching] = signal(false);
   const [error, setError] = signal(void 0);
@@ -2269,7 +2519,7 @@ function query(key, fetcher, options = {}) {
     data2();
     updatedAt();
     if (!currentKey) return true;
-    const entry = cache.get(currentKey);
+    const entry = cache2.get(currentKey);
     if (!entry || entry.dataUpdatedAt === 0) return true;
     return Date.now() - entry.dataUpdatedAt >= staleTime;
   });
@@ -2328,13 +2578,13 @@ function query(key, fetcher, options = {}) {
     entry.refetchers.delete(doFetch);
     entry.subscribers = Math.max(0, entry.subscribers - 1);
     if (entry.subscribers > 0 || cacheTime < 0 || key2 === null) return;
-    if (cache.get(key2) !== entry) return;
+    if (cache2.get(key2) !== entry) return;
     if (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
     entry.gcTimer = setTimeout(() => {
-      const current2 = cache.get(key2);
+      const current2 = cache2.get(key2);
       if (current2 === entry && current2.subscribers <= 0) {
         abandonEntry(current2);
-        cache.delete(key2);
+        cache2.delete(key2);
       }
     }, cacheTime);
     entry.gcTimer.unref?.();
@@ -2361,7 +2611,7 @@ function query(key, fetcher, options = {}) {
   async function doFetch() {
     if (disposed || !currentKey || !untracked2(isEnabled)) return;
     const key2 = currentKey;
-    const entry = getOrCreateEntry(cache, key2);
+    const entry = getOrCreateEntry(cache2, key2);
     attachToEntry(entry, key2);
     if (entry.promise) {
       setIsFetching(true);
@@ -2441,7 +2691,7 @@ function query(key, fetcher, options = {}) {
   }
   function onCacheUpdate() {
     if (disposed || !currentKey) return;
-    const entry = cache.get(currentKey);
+    const entry = cache2.get(currentKey);
     if (!entry) {
       batch(() => {
         commitBase(null, void 0);
@@ -2471,7 +2721,7 @@ function query(key, fetcher, options = {}) {
       setIsFetching(false);
       return;
     }
-    const entry = getOrCreateEntry(cache, key2, initialData);
+    const entry = getOrCreateEntry(cache2, key2, initialData);
     if (!ssr) entry.noTransfer = true;
     const reattached = attachedEntry !== entry;
     attachToEntry(entry, key2);
@@ -2890,23 +3140,23 @@ function debounce(getter, delay) {
 function throttle(getter, interval) {
   const [throttled, setThrottled] = signal(getter());
   let cooldown = false;
-  let pending = null;
+  let pending2 = null;
   let lastEmitted = getter();
   let timer = null;
   function emit(value) {
     setThrottled(value);
     lastEmitted = value;
     cooldown = true;
-    pending = null;
+    pending2 = null;
     timer = setTimeout(endWindow, interval);
   }
   function endWindow() {
     timer = null;
-    if (pending !== null && !Object.is(pending.value, lastEmitted)) {
-      emit(pending.value);
+    if (pending2 !== null && !Object.is(pending2.value, lastEmitted)) {
+      emit(pending2.value);
       return;
     }
-    pending = null;
+    pending2 = null;
     cooldown = false;
   }
   const stop2 = effect(() => {
@@ -2914,7 +3164,7 @@ function throttle(getter, interval) {
     if (!cooldown) {
       if (!Object.is(value, lastEmitted)) emit(value);
     } else {
-      pending = { value };
+      pending2 = { value };
     }
   });
   Object.defineProperty(throttled, "dispose", {
@@ -3268,8 +3518,8 @@ async function offlineStore(options) {
     const out = [];
     for (const remote of remoteItems) {
       const key = remote[keyPath];
-      const pending = key == null ? void 0 : pendingByKey.get(key);
-      if (!pending) {
+      const pending2 = key == null ? void 0 : pendingByKey.get(key);
+      if (!pending2) {
         out.push(remote);
         continue;
       }
@@ -3287,8 +3537,8 @@ async function offlineStore(options) {
           continue;
         }
         try {
-          const local = pending.type === "delete" ? void 0 : await idbGet(db, "items", key);
-          const choice = await activeAdapter.resolveConflict({ key, local, remote, pending });
+          const local = pending2.type === "delete" ? void 0 : await idbGet(db, "items", key);
+          const choice = await activeAdapter.resolveConflict({ key, local, remote, pending: pending2 });
           if (choice !== void 0) out.push(choice);
         } catch (err) {
           if (typeof console !== "undefined") {
@@ -3340,23 +3590,23 @@ function syncAdapter(config) {
 var _clientScope = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.routeLoader.v2"), () => ({ stack: [] }));
 var _disposed = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.routeLoader.disposed.v1"), () => /* @__PURE__ */ new WeakSet());
 function currentScope() {
-  const cache = getRequestScopedCache("routeLoader");
-  if (!cache) return _clientScope;
-  let scope = cache.get("scope");
+  const cache2 = getRequestScopedCache("routeLoader");
+  if (!cache2) return _clientScope;
+  let scope = cache2.get("scope");
   if (!scope) {
     scope = { stack: [] };
-    cache.set("scope", scope);
+    cache2.set("scope", scope);
   }
   return scope;
 }
 function automaticKey(loader, context) {
   const key = `loader:${context.path}${loader.name ? `:${loader.name}` : ""}`;
-  const cache = getRequestScopedCache("routeLoader");
-  if (!cache) return key;
-  let owners = cache.get("owners");
+  const cache2 = getRequestScopedCache("routeLoader");
+  if (!cache2) return key;
+  let owners = cache2.get("owners");
   if (!owners) {
     owners = /* @__PURE__ */ new Map();
-    cache.set("owners", owners);
+    cache2.set("owners", owners);
   }
   const owner = owners.get(key);
   if (owner === void 0) {
@@ -4352,13 +4602,13 @@ function idle(timeout = 6e4) {
 
 // src/browser/permissions.ts
 function permissions(name) {
-  const [state3, setState] = signal("prompt");
+  const [state5, setState] = signal("prompt");
   let permissionStatus = null;
   let onChange = null;
   let disposed = false;
   if (typeof navigator === "undefined" || !navigator.permissions) {
     setState("unsupported");
-    return { state: state3, dispose: () => {
+    return { state: state5, dispose: () => {
     } };
   }
   navigator.permissions.query({ name }).then((status) => {
@@ -4381,7 +4631,7 @@ function permissions(name) {
       onChange = null;
     }
   }
-  return { state: state3, dispose: dispose2 };
+  return { state: state5, dispose: dispose2 };
 }
 
 // src/browser/clipboard.ts
@@ -4730,9 +4980,9 @@ function colorScheme() {
 // src/browser/format.ts
 var I18N_STATE = /* @__PURE__ */ Symbol.for("sibujs.i18n.v1");
 function activeI18nLocale() {
-  const state3 = globalThis[I18N_STATE];
-  if (!state3) return void 0;
-  return state3.getLocale ? state3.getLocale() : state3.locale?.[0]();
+  const state5 = globalThis[I18N_STATE];
+  if (!state5) return void 0;
+  return state5.getLocale ? state5.getLocale() : state5.locale?.[0]();
 }
 function formatNumber(value, options) {
   const { locale, ...formatOptions } = options ?? {};
@@ -4914,9 +5164,9 @@ function notifyUrlWrite() {
   for (const sync of Array.from(_url.instances)) sync();
 }
 var SCROLL_ENTRY_KEY = "__sibuScrollKey";
-function withoutEntryIdentity(state3) {
-  if (state3 === null || typeof state3 !== "object" || !Object.hasOwn(state3, SCROLL_ENTRY_KEY)) return state3;
-  const { [SCROLL_ENTRY_KEY]: _identity, ...rest } = state3;
+function withoutEntryIdentity(state5) {
+  if (state5 === null || typeof state5 !== "object" || !Object.hasOwn(state5, SCROLL_ENTRY_KEY)) return state5;
+  const { [SCROLL_ENTRY_KEY]: _identity, ...rest } = state5;
   return rest;
 }
 function urlState() {
@@ -4954,9 +5204,9 @@ function urlState() {
   window.addEventListener("hashchange", syncFromLocation);
   _url.instances.add(syncFromLocation);
   function writeHistory(newUrl, opts) {
-    const state3 = "state" in opts ? opts.state : window.history.state;
-    if (opts.replace) window.history.replaceState(state3, "", newUrl);
-    else window.history.pushState("state" in opts ? state3 : withoutEntryIdentity(state3), "", newUrl);
+    const state5 = "state" in opts ? opts.state : window.history.state;
+    if (opts.replace) window.history.replaceState(state5, "", newUrl);
+    else window.history.pushState("state" in opts ? state5 : withoutEntryIdentity(state5), "", newUrl);
   }
   function setParams(next, opts = {}) {
     const p2 = next instanceof URLSearchParams ? next : new URLSearchParams(next);
@@ -5763,7 +6013,7 @@ function ownEntry(table2, key) {
   return Object.hasOwn(table2, key) ? table2[key] : void 0;
 }
 function machine(config) {
-  const [state3, setState] = signal(config.initial);
+  const [state5, setState] = signal(config.initial);
   const [context, setContext] = signal(config.context || {});
   let currentState = config.initial;
   let currentContext = context();
@@ -5837,10 +6087,10 @@ function machine(config) {
     if (queue.length > 0) drain();
   }
   function matches(s2) {
-    return state3() === s2;
+    return state5() === s2;
   }
   function can(event) {
-    const currentState2 = state3();
+    const currentState2 = state5();
     const stateDef = ownEntry(config.states, currentState2);
     if (!stateDef?.on) return false;
     const transition2 = ownEntry(stateDef.on, event);
@@ -5851,7 +6101,7 @@ function machine(config) {
     }
     return true;
   }
-  return { state: state3, context, send, matches, can };
+  return { state: state5, context, send, matches, can };
 }
 
 // src/patterns/persist.ts
@@ -5940,7 +6190,7 @@ function persisted(key, initial, options = {}) {
 // src/patterns/optimistic.ts
 function optimistic(initialValue) {
   const [value, setValue] = signal(initialValue);
-  const [pending, setPending] = signal(false);
+  const [pending2, setPending] = signal(false);
   let inflightCount = 0;
   let version = 0;
   async function update(optimisticValue, asyncAction) {
@@ -5966,7 +6216,7 @@ function optimistic(initialValue) {
       }
     }
   }
-  return { value, pending, update };
+  return { value, pending: pending2, update };
 }
 function optimisticList(initialValue) {
   let nextRowId = 0;
@@ -6012,7 +6262,7 @@ function optimisticList(initialValue) {
     if (i2 > 0) claims.splice(0, i2);
   }
   const [items, setItems] = signal(order.map((id) => effectiveValue(records.get(id))));
-  const [pending, setPending] = signal(false);
+  const [pending2, setPending] = signal(false);
   let inflight = 0;
   const retiredRowIds = /* @__PURE__ */ new Set();
   function project() {
@@ -6215,7 +6465,7 @@ function optimisticList(initialValue) {
   }
   return {
     items,
-    pending,
+    pending: pending2,
     add,
     remove,
     update: updateItem
@@ -6317,13 +6567,13 @@ function adopt(value) {
     resolvePromise = resolve;
     rejectPromise = reject;
   });
-  let state3 = "invoking";
+  let state5 = "invoking";
   let nativeTarget;
-  const waiters = [];
+  const waiters2 = [];
   const transition2 = (next) => {
-    state3 = next;
+    state5 = next;
     if (next === "invoking") return;
-    for (const waiter of waiters.splice(0)) waiter();
+    for (const waiter of waiters2.splice(0)) waiter();
   };
   const fulfil = (result) => {
     resolvePromise(result);
@@ -6379,18 +6629,18 @@ function adopt(value) {
       } catch (error) {
         onReject(error);
       }
-      if (!done && state3 === "invoking") transition2("pending");
+      if (!done && state5 === "invoking") transition2("pending");
     });
   };
   invokeLater(value, then);
   const probe = (onRejected, onOpen) => {
     const decide = () => {
-      if (state3 === "native") probeNative(nativeTarget, onRejected, onOpen);
-      else (state3 === "rejected" ? onRejected : onOpen)();
+      if (state5 === "native") probeNative(nativeTarget, onRejected, onOpen);
+      else (state5 === "rejected" ? onRejected : onOpen)();
     };
-    if (state3 === "native") probeNative(nativeTarget, onRejected, onOpen);
-    else if (state3 === "invoking") waiters.push(decide);
-    else queueMicrotask(state3 === "rejected" ? onRejected : onOpen);
+    if (state5 === "native") probeNative(nativeTarget, onRejected, onOpen);
+    else if (state5 === "invoking") waiters2.push(decide);
+    else queueMicrotask(state5 === "rejected" ? onRejected : onOpen);
   };
   return { promise, failedEarly: false, probe };
 }
@@ -6431,12 +6681,12 @@ function globalStore(config) {
   const [getState, setState] = signal({ ...initialState });
   const subscriptions = /* @__PURE__ */ new Map();
   const middlewares = config.middleware || [];
-  function notifyListeners2(state3) {
+  function notifyListeners2(state5) {
     if (subscriptions.size === 0) return;
     for (const subscription of Array.from(subscriptions.values())) {
       if (!subscription.active) continue;
       try {
-        subscription.callback(state3);
+        subscription.callback(state5);
       } catch (err) {
         reportError(err, { phase: "event", name: "globalStore(subscribe)" });
       }
@@ -7411,16 +7661,16 @@ function form(config) {
       }
       if (isValid()) {
         const report = (error) => reportError(error, { phase: "async", name: "form.handleSubmit" });
-        let pending;
+        let pending2;
         try {
-          pending = adoptThenable(onSubmit(values()));
+          pending2 = adoptThenable(onSubmit(values()));
         } catch (error) {
           report(error);
           return;
         }
-        if (pending) {
+        if (pending2) {
           setSubmitting(true);
-          pending.then(
+          pending2.then(
             () => setSubmitting(false),
             (error) => {
               setSubmitting(false);
@@ -8362,8 +8612,8 @@ function commitSafeAttribute(el, name, value, options) {
     else el.removeAttribute(name);
     return false;
   }
-  const pending = value == null || value === false ? null : value === true ? "" : String(value);
-  const refusal = contextualAttributeRefusal(el, name, pending, options.reactive ? "reactive" : "runtime");
+  const pending2 = value == null || value === false ? null : value === true ? "" : String(value);
+  const refusal = contextualAttributeRefusal(el, name, pending2, options.reactive ? "reactive" : "runtime");
   if (refusal !== ContextualRefusal.None) {
     warnContextualRefusal(options.label ?? "setSafeAttribute", name, refusal);
     if (ns) el.removeAttributeNS(ns, localName);
@@ -9188,14 +9438,14 @@ function noSideEffect(fn) {
 }
 
 // src/utils/embedPolicy.ts
-var state2 = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.embed.v2"), () => ({
+var state3 = 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 ?? state3.allowed;
 }
 function resolveEmbedSrc(value, allowed = currentEmbedAllowlist()) {
   if (typeof value !== "string" || sanitizeUrl(value) === "") return null;
@@ -9255,7 +9505,7 @@ function narrowEmbedAllow(value) {
   return granted.filter((feature) => !denied.includes(feature)).join("; ");
 }
 function getEmbedRecord(frame) {
-  return state2.frames.get(frame);
+  return state3.frames.get(frame);
 }
 function intersect(current2, permitted, separator) {
   const allowed = permitted.split(separator);
@@ -9370,6 +9620,25 @@ function serializePlannedHeadEntry(tag, attributes) {
   return `<${tag} ${pairs} />`;
 }
 
+// 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/platform/serverDom.ts
 var HTML_NS3 = "http://www.w3.org/1999/xhtml";
 var SVG_NS3 = "http://www.w3.org/2000/svg";
@@ -10000,9 +10269,15 @@ var ServerAttr = class {
   get nodeValue() {
     return this._value;
   }
+  set nodeValue(v) {
+    this.value = v;
+  }
   get textContent() {
     return this._value;
   }
+  set textContent(v) {
+    this.value = v;
+  }
 };
 var ServerNamedNodeMap = class extends Array {
   static get [Symbol.species]() {
@@ -10039,12 +10314,6 @@ function splitDeclarations(text2) {
   out.push(text2.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;
@@ -10139,13 +10408,13 @@ function styleProxy(style2) {
     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);
@@ -10550,6 +10819,10 @@ var ServerInputElement = class extends ServerHTMLElement {
   get defaultChecked() {
     return this.hasAttribute("checked");
   }
+  /** Reflects to the `checked` attribute; `checked` follows it until written (dirty checkedness). */
+  set defaultChecked(v) {
+    this.toggleAttribute("checked", !!v);
+  }
   get type() {
     return (this.getAttribute("type") ?? "text").toLowerCase();
   }
@@ -10607,8 +10880,10 @@ reflectDisabled(ServerTextAreaElement.prototype);
 var ServerOptionElement = class extends ServerHTMLElement {
   constructor() {
     super(...arguments);
-    /** @internal */
+    /** Selectedness; `null` while it follows the `selected` attribute. @internal */
     this._selected = null;
+    /** Set by a `selected` write: the attribute no longer decides selectedness. @internal */
+    this._dirty = false;
   }
   get value() {
     return this.getAttribute("value") ?? this.text;
@@ -10625,18 +10900,48 @@ var ServerOptionElement = class extends ServerHTMLElement {
   get label() {
     return this.getAttribute("label") ?? this.text;
   }
+  set label(v) {
+    this.setAttribute("label", v);
+  }
   get selected() {
     return this._selected ?? this.hasAttribute("selected");
   }
   set selected(v) {
     this._selected = !!v;
+    this._dirty = true;
+    const select3 = singleSelectOf(this);
+    if (select3 && v) {
+      for (const o of select3.options) if (o !== this) o._selected = false;
+    }
   }
   get defaultSelected() {
     return this.hasAttribute("selected");
   }
+  /** Reflects to the `selected` attribute; `selected` follows it unless written. */
+  set defaultSelected(v) {
+    this.toggleAttribute("selected", !!v);
+    if (this._dirty) return;
+    this._selected = null;
+    const select3 = singleSelectOf(this);
+    if (!select3) return;
+    let last = null;
+    for (const o of select3.options) if (o.selected) last = o;
+    for (const o of select3.options) if (o !== last && o.selected) o._selected = false;
+  }
 };
+function singleSelectOf(option2) {
+  let parent = option2.parentNode;
+  if (parent instanceof ServerElement && parent.localName === "optgroup") parent = parent.parentNode;
+  return parent instanceof ServerSelectElement && !parent.hasAttribute("multiple") ? parent : null;
+}
 reflectDisabled(ServerOptionElement.prototype);
 var ServerSelectElement = class extends ServerHTMLElement {
+  get multiple() {
+    return this.hasAttribute("multiple");
+  }
+  set multiple(v) {
+    this.toggleAttribute("multiple", !!v);
+  }
   get options() {
     return this.querySelectorAll("option");
   }
@@ -10941,21 +11246,21 @@ function compileSelector(selector) {
     const tokens = text2.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 });
@@ -11806,12 +12111,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 macrotask();
-      if (pending.size === 0) {
+      if (pending2.size === 0) {
         await macrotask();
-        if (pending.size === 0) break;
+        if (pending2.size === 0) break;
         continue;
       }
       const remaining = deadline - Date.now();
@@ -11882,9 +12187,9 @@ function installHook() {
   if (hookInstalled) return;
   hookInstalled = true;
   setBoundaryHook((container) => {
-    const state3 = requestSlot("stream");
+    const state5 = requestSlot("stream");
     const store = getRequestStore();
-    if (!state3 || !store) return null;
+    if (!state5 || !store) return null;
     const id = `sibu-sus-${store.suspenseIdCounter++}`;
     container.setAttribute("data-sibu-suspense-id", id);
     const record = {
@@ -11895,8 +12200,8 @@ function installHook() {
       fallbackHtml: null,
       api: {
         enter: (fn) => {
-          if (record.fallbackHtml === null && state3.serialize) {
-            record.fallbackHtml = Array.from(container.childNodes, (n) => state3.serialize?.(n) ?? "").join("");
+          if (record.fallbackHtml === null && state5.serialize) {
+            record.fallbackHtml = Array.from(container.childNodes, (n) => state5.serialize?.(n) ?? "").join("");
           }
           return runInBoundary(record.api, fn);
         },
@@ -11906,7 +12211,7 @@ function installHook() {
         }
       }
     };
-    state3.boundaries.push(record);
+    state5.boundaries.push(record);
     return record.api;
   });
 }
@@ -11991,9 +12296,9 @@ async function waitFor(ready, deadline, stop2) {
     });
   }
 }
-function pendingFor(pending, boundary) {
-  if (!pending) return false;
-  for (const work of pending) if (work.boundary === boundary) return true;
+function pendingFor(pending2, boundary) {
+  if (!pending2) return false;
+  for (const work of pending2) if (work.boundary === boundary) return true;
   return false;
 }
 function streamPage(input2, options = {}) {
@@ -12006,8 +12311,8 @@ function streamPage(input2, options = {}) {
   const MARK_END = "<sibu-stream-end>";
   void runInSSRContext(async () => {
     const store = getRequestStore();
-    const state3 = { boundaries: [], serialize: null };
-    requestSlot("stream", () => state3);
+    const state5 = { boundaries: [], serialize: null };
+    requestSlot("stream", () => state5);
     const errors = [];
     if (store) store.errors = errors;
     let holder = null;
@@ -12028,13 +12333,13 @@ function streamPage(input2, options = {}) {
         throw explainServerError(err);
       }
       const serialize = (node) => renderToStringWith(node, { marker: options.marker ?? "root", ids });
-      state3.serialize = serialize;
+      state5.serialize = serialize;
       holder = document.createDocumentFragment();
       holder.appendChild(root);
       const ready = (b2) => b2.done && !pendingFor(store?.pending, b2.api);
       const serializeWithFallbacks = (node) => {
         const held = [];
-        for (const b2 of state3.boundaries) {
+        for (const b2 of state5.boundaries) {
           if (ready(b2) || b2.container === node || !node.contains(b2.container)) continue;
           if (held.some((h) => h.b.container.contains(b2.container))) continue;
           const nodes = Array.from(b2.container.childNodes);
@@ -12056,9 +12361,9 @@ function streamPage(input2, options = {}) {
       await waitFor(() => !pendingFor(store?.pending, void 0), shellDeadline, stopWaiting);
       failIfErrored();
       if (channel.cancelled) return;
-      for (const b2 of state3.boundaries) {
+      for (const b2 of state5.boundaries) {
         const inline = (x) => x.done && !pendingFor(store?.pending, x.api);
-        const enclosing = state3.boundaries.filter((a2) => a2 !== b2 && a2.container.contains(b2.container));
+        const enclosing = state5.boundaries.filter((a2) => a2 !== b2 && a2.container.contains(b2.container));
         if (inline(b2) && enclosing.every(inline)) b2.emitted = true;
       }
       const shell = serializeWithFallbacks(holder);
@@ -12079,8 +12384,8 @@ function streamPage(input2, options = {}) {
       if (channel.cancelled) return;
       failIfErrored();
       const deadline = Date.now() + (options.timeout ?? 1e4);
-      const outstanding = () => state3.boundaries.filter((b2) => !b2.emitted);
-      const ancestorsOf = (b2) => state3.boundaries.filter((a2) => a2 !== b2 && a2.container.contains(b2.container));
+      const outstanding = () => state5.boundaries.filter((b2) => !b2.emitted);
+      const ancestorsOf = (b2) => state5.boundaries.filter((a2) => a2 !== b2 && a2.container.contains(b2.container));
       const emittable = (b2) => ready(b2) && ancestorsOf(b2).every((a2) => a2.emitted);
       let bodyClosed = false;
       for (; ; ) {
@@ -12104,7 +12409,7 @@ function streamPage(input2, options = {}) {
           if (channel.cancelled) return;
           failIfErrored();
         }
-        for (const b2 of state3.boundaries) {
+        for (const b2 of state5.boundaries) {
           if (b2 === next || !next.container.contains(b2.container) || !ready(b2)) continue;
           const between2 = ancestorsOf(b2).filter((a2) => a2 !== next && next.container.contains(a2.container));
           if (between2.every(ready)) b2.emitted = true;
@@ -12803,12 +13108,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) {
@@ -12920,8 +13225,8 @@ function normalizedStore(schema) {
     return ownGet(getState().entities, id);
   }
   function getAll() {
-    const state3 = getState();
-    return state3.ids.map((id) => state3.entities[id]);
+    const state5 = getState();
+    return state5.ids.map((id) => state5.entities[id]);
   }
   function update(id, partial) {
     const prev = getState();
@@ -12954,8 +13259,8 @@ function normalizedStore(schema) {
     });
   }
   function select3(predicate) {
-    const state3 = getState();
-    return state3.ids.map((id) => state3.entities[id]).filter(predicate);
+    const state5 = getState();
+    return state5.ids.map((id) => state5.entities[id]).filter(predicate);
   }
   return { add, addMany, get, getAll, update, remove, select: select3, getState };
 }
@@ -13043,8 +13348,8 @@ function createChunkRegistry(config = {}) {
     onLoadEnd,
     onLoadError
   } = config;
-  const cache = /* @__PURE__ */ new Map();
-  const pending = /* @__PURE__ */ new Map();
+  const cache2 = /* @__PURE__ */ new Map();
+  const pending2 = /* @__PURE__ */ new Map();
   const preloaded = /* @__PURE__ */ new Map();
   function notify2(name, run) {
     try {
@@ -13054,17 +13359,17 @@ function createChunkRegistry(config = {}) {
     }
   }
   function evict() {
-    while (cache.size >= maxCacheSize) {
+    while (cache2.size >= maxCacheSize) {
       let lru = null;
       let lruTime = Infinity;
-      for (const [key, entry] of cache) {
+      for (const [key, entry] of cache2) {
         if (entry.lastAccess < lruTime) {
           lruTime = entry.lastAccess;
           lru = key;
         }
       }
       if (!lru) return;
-      cache.delete(lru);
+      cache2.delete(lru);
     }
   }
   function isValid(entry) {
@@ -13101,13 +13406,13 @@ function createChunkRegistry(config = {}) {
     }
   }
   async function loadFn(id, loader) {
-    const cached = cache.get(id);
+    const cached = cache2.get(id);
     if (cached && isValid(cached)) {
       cached.accessCount++;
       cached.lastAccess = Date.now();
       return cached.value;
     }
-    const existing = pending.get(id);
+    const existing = pending2.get(id);
     if (existing) return existing.promise;
     let resolveOuter;
     let rejectOuter;
@@ -13116,22 +13421,22 @@ function createChunkRegistry(config = {}) {
       rejectOuter = reject;
     });
     const entry = { promise: outcome };
-    pending.set(id, entry);
-    const owns = () => pending.get(id) === entry;
+    pending2.set(id, entry);
+    const owns = () => pending2.get(id) === entry;
     notify2("onLoadStart", () => onLoadStart?.(id));
     void loadWithRetry(id, loader).then(
       (value) => {
         if (owns()) {
-          pending.delete(id);
+          pending2.delete(id);
           evict();
           const now = Date.now();
-          cache.set(id, { value, timestamp: now, lastAccess: now, accessCount: 1 });
+          cache2.set(id, { value, timestamp: now, lastAccess: now, accessCount: 1 });
         }
         notify2("onLoadEnd", () => onLoadEnd?.(id));
         resolveOuter(value);
       },
       (err) => {
-        if (owns()) pending.delete(id);
+        if (owns()) pending2.delete(id);
         const error = err instanceof Error ? err : new Error(String(err));
         notify2("onLoadError", () => onLoadError?.(id, error));
         rejectOuter(error);
@@ -13143,7 +13448,7 @@ function createChunkRegistry(config = {}) {
     return outcome;
   }
   function preloadFn(id, loader) {
-    if (cache.has(id) || pending.has(id) || preloaded.has(id)) return;
+    if (cache2.has(id) || pending2.has(id) || preloaded.has(id)) return;
     const marker2 = {};
     preloaded.set(id, marker2);
     loadFn(id, loader).catch(() => {
@@ -13165,14 +13470,14 @@ function createChunkRegistry(config = {}) {
      * Check if a chunk is cached and valid.
      */
     has(id) {
-      const entry = cache.get(id);
+      const entry = cache2.get(id);
       return !!entry && isValid(entry);
     },
     /**
      * Get a cached chunk synchronously. Returns undefined if not cached.
      */
     get(id) {
-      const entry = cache.get(id);
+      const entry = cache2.get(id);
       if (entry && isValid(entry)) {
         entry.accessCount++;
         entry.lastAccess = Date.now();
@@ -13189,9 +13494,9 @@ function createChunkRegistry(config = {}) {
      * a subsequent `load(id, …)` starts fresh work rather than adopting it.
      */
     invalidate(id) {
-      cache.delete(id);
+      cache2.delete(id);
       preloaded.delete(id);
-      pending.delete(id);
+      pending2.delete(id);
     },
     /**
      * Clear all cached chunks, and supersede every load still in flight.
@@ -13199,9 +13504,9 @@ function createChunkRegistry(config = {}) {
      * Same barrier as `invalidate`, applied to every key at once.
      */
     clear() {
-      cache.clear();
+      cache2.clear();
       preloaded.clear();
-      pending.clear();
+      pending2.clear();
     },
     /**
      * Get cache statistics.
@@ -13211,9 +13516,9 @@ function createChunkRegistry(config = {}) {
      */
     stats() {
       return {
-        size: cache.size,
+        size: cache2.size,
         maxSize: maxCacheSize,
-        pending: pending.size,
+        pending: pending2.size,
         preloaded: preloaded.size
       };
     }
@@ -13951,16 +14256,16 @@ async function loadWasmModuleWithOptions(source2, opts = {}) {
   if (cachedInstance) return cachedInstance;
   const inFlight = inFlightCache.get(key);
   if (inFlight) return inFlight;
-  const pending = instantiateWasm(source2, opts.imports, key, generation).then((instance) => {
+  const pending2 = instantiateWasm(source2, opts.imports, key, generation).then((instance) => {
     if (isCurrentGeneration(generation)) instanceCache.set(key, instance);
     return instance;
   });
-  inFlightCache.set(key, pending);
-  void pending.catch(() => {
+  inFlightCache.set(key, pending2);
+  void pending2.catch(() => {
   }).then(() => {
-    if (inFlightCache.get(key) === pending) inFlightCache.delete(key);
+    if (inFlightCache.get(key) === pending2) inFlightCache.delete(key);
   });
-  return pending;
+  return pending2;
 }
 async function instantiateWasm(source2, wasmImports, key, generation) {
   const cachedModule = key ? moduleCache.get(key) : void 0;
@@ -14137,7 +14442,7 @@ function restoreFocusWithin(snapshot, nodes, where, policy) {
   const active = document.activeElement;
   if (active === snapshot.el) return;
   if (active && active !== document.body && active !== document.documentElement) return;
-  if (snapshot.el.isConnected) {
+  if (snapshot.el.isConnected && !snapshot.el.closest("[inert]")) {
     refocus(snapshot.el, snapshot);
     return;
   }
@@ -14164,8 +14469,25 @@ function restoreFocusWithin(snapshot, nodes, where, policy) {
   });
 }
 
+// src/core/rendering/range.ts
+var state4 = 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 = state4.ends;
+function registerRange(start, last) {
+  ends.set(start, last);
+}
+var pending = state4.pending;
+var registrations = state4.registrations;
+var loadListeners = state4.listeners;
+var notice = state4.notice;
+
 // src/reactivity/bindChildNode.ts
-function bindChildNode(placeholder, getter) {
+function bindChildNode(placeholder, getter, exposeNodes) {
   let lastNodes = [];
   const scope = captureScope();
   function commit() {
@@ -14236,6 +14558,12 @@ function bindChildNode(placeholder, getter) {
     lastNodes = newNodes;
     restoreFocusWithin(focused, newNodes, "bindChildNode");
   }
+  if (exposeNodes) {
+    registerRange(placeholder, () => {
+      for (let i2 = lastNodes.length - 1; i2 >= 0; i2--) if (lastNodes[i2].parentNode !== null) return lastNodes[i2];
+      return null;
+    });
+  }
   return reactiveBinding2(commit, placeholder, true);
 }
 
@@ -14264,14 +14592,6 @@ var CLOBBER_RISKY_IDS = /* @__PURE__ */ new Set([
 var warnedLoneStrings = /* @__PURE__ */ new Set();
 var MAX_WARNED_LONE_STRINGS = 100;
 var loneStringCapAnnounced = false;
-var kebabCache = /* @__PURE__ */ new Map();
-function toKebab2(prop) {
-  let cached = kebabCache.get(prop);
-  if (cached !== void 0) return cached;
-  cached = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-  kebabCache.set(prop, cached);
-  return cached;
-}
 function applyStyle(el, style2) {
   if (typeof style2 === "function") {
     const getter = style2;
@@ -14295,7 +14615,7 @@ function applyStyle(el, style2) {
         if (!Object.hasOwn(value, prop)) continue;
         const val = value[prop];
         if (val == null) continue;
-        const name = toKebab2(prop);
+        const name = styleKeyToProperty(prop);
         next.push(name);
         decl.setProperty(name, sanitizeCSSDeclaration(name, String(val), { element: el }));
       }
@@ -14315,7 +14635,7 @@ function applyStyle(el, style2) {
   for (const prop in style2) {
     if (!Object.hasOwn(style2, prop)) continue;
     const val = style2[prop];
-    const name = toKebab2(prop);
+    const name = styleKeyToProperty(prop);
     if (typeof val === "function") {
       const getter = val;
       const teardown = reactiveBinding2(() => {
@@ -15134,8 +15454,8 @@ function scrollRestoration(options) {
     nativeModeLease = acquireScrollRestorationMode("manual");
     if (currentKey !== null) tagCurrentEntry(currentKey);
     popstateHandler = (event) => {
-      const state3 = event.state ?? null;
-      const rawDestination = state3 ? state3[stateKey] : void 0;
+      const state5 = event.state ?? null;
+      const rawDestination = state5 ? state5[stateKey] : void 0;
       const destination = typeof rawDestination === "string" ? rawDestination : null;
       let outgoing = currentKey;
       if (outgoing === null && options?.getKey) {
@@ -15291,18 +15611,18 @@ function createPluginRegistry() {
         return true;
       };
       installStack.add(p2.name);
-      let pending;
+      let pending2;
       try {
-        pending = adoptThenable(p2.install(ctx, options));
+        pending2 = adoptThenable(p2.install(ctx, options));
       } finally {
         installStack.delete(p2.name);
       }
-      if (!pending) {
+      if (!pending2) {
         if (!commit()) throw new PluginInstallCancelledError(p2.name);
         return;
       }
       if (myGeneration === generation) pendingInstalls.set(p2.name, myGeneration);
-      const settled = pending.then(
+      const settled = pending2.then(
         () => {
           if (commit()) return;
           if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
@@ -15485,16 +15805,16 @@ function createModuleRegistry() {
   };
 }
 function createBundle(modules) {
-  const cache = /* @__PURE__ */ new Map();
+  const cache2 = /* @__PURE__ */ new Map();
   const bundle = {};
   for (const key of Object.keys(modules)) {
     Object.defineProperty(bundle, key, {
       get() {
-        if (cache.has(key)) {
-          return cache.get(key);
+        if (cache2.has(key)) {
+          return cache2.get(key);
         }
         const value = modules[key]();
-        cache.set(key, value);
+        cache2.set(key, value);
         return value;
       },
       enumerable: true,
@@ -15563,7 +15883,7 @@ var CDN_ENTRY_POINTS = {
 };
 var packageInfo = {
   name: "sibujs",
-  version: true ? "4.14.0" : "dev",
+  version: true ? "4.15.0" : "dev",
   entryPoints: MODULE_ENTRY_POINTS,
   /**
    * Generate the package.json `exports` map. Module entries resolve to the
@@ -15708,7 +16028,7 @@ var env = {
 };
 
 // src/plugins/versioning.ts
-var VERSION = true ? "4.14.0" : "dev";
+var VERSION = true ? "4.15.0" : "dev";
 var NUM = "(?:0|[1-9]\\d*)";
 var PRE_ID = `(?:${NUM}|\\d*[a-zA-Z-][0-9a-zA-Z-]*)`;
 var BUILD_ID = "[0-9a-zA-Z-]+";
@@ -15893,9 +16213,9 @@ function createMigrationRunner(config) {
       return serialize(async () => {
         const applied = [];
         const errors = [];
-        let pending;
+        let pending2;
         try {
-          pending = getPending();
+          pending2 = getPending();
         } catch (e) {
           errors.push({
             version: getAppliedVersion() ?? "",
@@ -15903,7 +16223,7 @@ function createMigrationRunner(config) {
           });
           return { applied, errors };
         }
-        for (const migration of pending) {
+        for (const migration of pending2) {
           try {
             await migration.up();
           } catch (e) {
@@ -16014,24 +16334,24 @@ function assertCacheSize(name, value) {
     throw new RangeError(`[Startup] ${name} must be a non-negative integer, got ${value}`);
   }
 }
-function makeRoomFor(cache, key, maxSize, isValid) {
+function makeRoomFor(cache2, key, maxSize, isValid) {
   if (maxSize === 0) return false;
-  if (cache.has(key)) return true;
-  if (cache.size < maxSize) return true;
-  for (const [k, entry] of cache) {
-    if (!isValid(entry)) cache.delete(k);
+  if (cache2.has(key)) return true;
+  if (cache2.size < maxSize) return true;
+  for (const [k, entry] of cache2) {
+    if (!isValid(entry)) cache2.delete(k);
   }
-  while (cache.size >= maxSize) {
+  while (cache2.size >= maxSize) {
     let oldestKey = null;
     let oldestTime = Infinity;
-    for (const [k, entry] of cache) {
+    for (const [k, entry] of cache2) {
       if (entry.timestamp < oldestTime) {
         oldestTime = entry.timestamp;
         oldestKey = k;
       }
     }
     if (oldestKey === null) break;
-    cache.delete(oldestKey);
+    cache2.delete(oldestKey);
   }
   return true;
 }
@@ -16039,57 +16359,57 @@ function prerenderRoutes(routes, options) {
   const maxCacheSize = options?.maxCacheSize ?? 50;
   const cacheTTL = options?.cacheTTL ?? 0;
   assertCacheSize("maxCacheSize", maxCacheSize);
-  const cache = /* @__PURE__ */ new Map();
+  const cache2 = /* @__PURE__ */ new Map();
   function isValid(entry) {
     if (cacheTTL === 0) return true;
     return Date.now() - entry.timestamp < cacheTTL;
   }
   for (const route of routes) {
-    if (!makeRoomFor(cache, route.path, maxCacheSize, isValid)) break;
+    if (!makeRoomFor(cache2, route.path, maxCacheSize, isValid)) break;
     const html2 = renderToString(route.component());
-    cache.set(route.path, { html: html2, timestamp: Date.now() });
+    cache2.set(route.path, { html: html2, timestamp: Date.now() });
   }
   return {
     /** Get cached HTML for a route, or undefined if not cached or expired */
     get(path2) {
-      const entry = cache.get(path2);
+      const entry = cache2.get(path2);
       if (!entry) return void 0;
       if (!isValid(entry)) {
-        cache.delete(path2);
+        cache2.delete(path2);
         return void 0;
       }
       return entry.html;
     },
     /** Check if a route has been prerendered and is still valid */
     has(path2) {
-      const entry = cache.get(path2);
+      const entry = cache2.get(path2);
       if (!entry) return false;
       if (!isValid(entry)) {
-        cache.delete(path2);
+        cache2.delete(path2);
         return false;
       }
       return true;
     },
     /** Invalidate a cached route */
     invalidate(path2) {
-      cache.delete(path2);
+      cache2.delete(path2);
     },
     /** Clear all cached routes */
     clear() {
-      cache.clear();
+      cache2.clear();
     },
     /** Get cache statistics */
     stats() {
       if (cacheTTL > 0) {
-        for (const [key, entry] of cache) {
+        for (const [key, entry] of cache2) {
           if (!isValid(entry)) {
-            cache.delete(key);
+            cache2.delete(key);
           }
         }
       }
       return {
-        size: cache.size,
-        routes: Array.from(cache.keys())
+        size: cache2.size,
+        routes: Array.from(cache2.keys())
       };
     }
   };
@@ -16098,7 +16418,7 @@ function createSSRCache(config) {
   const maxSize = config?.maxSize ?? 100;
   const defaultTTL = config?.defaultTTL ?? 6e4;
   assertCacheSize("maxSize", maxSize);
-  const cache = /* @__PURE__ */ new Map();
+  const cache2 = /* @__PURE__ */ new Map();
   let hits = 0;
   let misses = 0;
   function isValid(entry) {
@@ -16108,13 +16428,13 @@ function createSSRCache(config) {
   return {
     /** Get cached HTML for a key, or undefined if not cached or expired */
     get(key) {
-      const entry = cache.get(key);
+      const entry = cache2.get(key);
       if (!entry) {
         misses++;
         return void 0;
       }
       if (!isValid(entry)) {
-        cache.delete(key);
+        cache2.delete(key);
         misses++;
         return void 0;
       }
@@ -16123,8 +16443,8 @@ function createSSRCache(config) {
     },
     /** Cache an HTML string with an optional TTL override */
     set(key, html2, ttl) {
-      if (!makeRoomFor(cache, key, maxSize, isValid)) return;
-      cache.set(key, {
+      if (!makeRoomFor(cache2, key, maxSize, isValid)) return;
+      cache2.set(key, {
         html: html2,
         timestamp: Date.now(),
         ttl: ttl ?? defaultTTL
@@ -16132,27 +16452,27 @@ function createSSRCache(config) {
     },
     /** Check if a key exists in the cache and is still valid */
     has(key) {
-      const entry = cache.get(key);
+      const entry = cache2.get(key);
       if (!entry) return false;
       if (!isValid(entry)) {
-        cache.delete(key);
+        cache2.delete(key);
         return false;
       }
       return true;
     },
     /** Invalidate a cached entry */
     invalidate(key) {
-      cache.delete(key);
+      cache2.delete(key);
     },
     /** Clear all cached entries and reset statistics */
     clear() {
-      cache.clear();
+      cache2.clear();
       hits = 0;
       misses = 0;
     },
     /** Get cache statistics including hit/miss counts */
     stats() {
-      return { size: cache.size, hits, misses };
+      return { size: cache2.size, hits, misses };
     }
   };
 }
@@ -16565,8 +16885,8 @@ function initDevTools(config) {
   function clearEvents() {
     eventLog.length = 0;
   }
-  function registerComponent(name, element, state3) {
-    hook.components.set(name, { element, state: state3 });
+  function registerComponent(name, element, state5) {
+    hook.components.set(name, { element, state: state5 });
     emit();
   }
   function unregisterComponent(name) {
@@ -19010,9 +19330,9 @@ function zustandAdapter(options) {
   return createPlugin("sibu-zustand", (ctx) => {
     const { store } = options;
     const [getState, setSibuState] = signal(store.getState());
-    const unsubscribe = store.subscribe((state3) => {
+    const unsubscribe = store.subscribe((state5) => {
       batch(() => {
-        setSibuState(state3);
+        setSibuState(state5);
       });
     });
     function select3(selector) {