sibujs 3.4.0 → 4.0.0

package/dist/extras.cjs

@@ -175,6 +175,7 @@ __export(extras_exports, {
   lazyModule: () => lazyModule,
   loadRemoteModule: () => loadRemoteModule,
   loadWasmModule: () => loadWasmModule,
+  loadWasmModuleWithOptions: () => loadWasmModuleWithOptions,
   loaderData: () => loaderData,
   machine: () => machine,
   matchesPattern: () => matchesPattern,
@@ -338,8 +339,95 @@ function devWarn(message) {
   }
 }
 
+// src/core/errors.ts
+var ERROR_STATE_KEY = /* @__PURE__ */ Symbol.for("sibujs.runtime-errors.v1");
+function state() {
+  const g2 = globalThis;
+  const existing = g2[ERROR_STATE_KEY];
+  if (existing) return existing;
+  const created = { handler: null, handlerDepth: 0 };
+  g2[ERROR_STATE_KEY] = created;
+  return created;
+}
+function normalizeError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" ? value : `Non-Error value thrown: ${safeStringify(value)}`;
+  return new Error(message, { cause: value });
+}
+function safeStringify(value) {
+  if (typeof value === "symbol") return value.toString();
+  try {
+    return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+function describe(context2) {
+  return context2.name ? `${context2.phase} "${context2.name}"` : context2.phase;
+}
+var REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
+function untrackedRun(fn) {
+  const api = globalThis[REACTIVE_REGISTRY_KEY];
+  return api?.untracked ? api.untracked(fn) : fn();
+}
+var PROPAGATE_EVENT = "sibu:error-propagate";
+function claimedByBoundary(error, context2) {
+  const raw = context2.node;
+  if (!raw || typeof CustomEvent === "undefined") return false;
+  const target = resolveEventTarget(raw);
+  if (!target) return false;
+  try {
+    const event = new CustomEvent(PROPAGATE_EVENT, {
+      bubbles: true,
+      cancelable: true,
+      detail: { error, context: context2 }
+    });
+    return target.dispatchEvent(event) === false;
+  } catch {
+    return false;
+  }
+}
+function resolveEventTarget(node) {
+  const ELEMENT_NODE = 1;
+  let current = node;
+  while (current) {
+    if (current.nodeType === ELEMENT_NODE && typeof current.dispatchEvent === "function") {
+      return current;
+    }
+    current = current.parentNode;
+  }
+  const self2 = node;
+  return typeof self2.dispatchEvent === "function" ? self2 : null;
+}
+function defaultReport(error, context2) {
+  if (typeof console === "undefined") return;
+  console.error(`[SibuJS] Uncaught error during ${describe(context2)}: ${error.message}`, error);
+}
+function reportError(error, context2) {
+  const err = normalizeError(error);
+  untrackedRun(() => {
+    if (claimedByBoundary(err, context2)) return;
+    const s2 = state();
+    const handler = s2.handler;
+    if (handler && s2.handlerDepth === 0) {
+      s2.handlerDepth++;
+      try {
+        handler(error instanceof Error ? error : err, context2);
+        return;
+      } catch (handlerError) {
+        if (typeof console !== "undefined") {
+          const detail = handlerError instanceof Error ? handlerError.message : String(handlerError);
+          console.error(`[SibuJS] runtime error handler itself threw: ${detail}`, handlerError);
+        }
+      } finally {
+        s2.handlerDepth--;
+      }
+    }
+    defaultReport(err, context2);
+  });
+}
+
 // src/reactivity/track-core.ts
-var _isDev2 = isDev();
 var POOL_MAX = 4096;
 var nodePool = [];
 function createNode() {
@@ -347,6 +435,7 @@ function createNode() {
     sig: null,
     sub: null,
     epoch: 0,
+    depVersion: 0,
     sigPrev: null,
     sigNext: null,
     subPrev: null,
@@ -431,8 +520,27 @@ function safeInvoke(sub2) {
   try {
     sub2();
   } catch (err) {
-    if (_isDev2) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
+    const s2 = sub2;
+    reportError(err, { phase: s2._errorPhase ?? "effect", name: s2.__name, node: s2._errorNode });
+  }
+}
+function depsChanged(sub2) {
+  let node = sub2.depsHead ?? null;
+  if (node === null) return true;
+  while (node !== null) {
+    const sig = node.sig;
+    if (sig === null) return true;
+    if (sig._d === true && sig._validate !== void 0) {
+      try {
+        sig._validate();
+      } catch {
+        return true;
+      }
+    }
+    if (node.depVersion !== sig.__v) return true;
+    node = node.subNext;
   }
+  return false;
 }
 var suspendDepth = 0;
 var trackingSuspended = false;
@@ -514,7 +622,7 @@ function track(effectFn, subscriber) {
   const sub2 = subscriber;
   return sub2._dispose ?? (sub2._dispose = () => cleanup(subscriber));
 }
-function reactiveBinding(commit) {
+function reactiveBinding(commit, ownerNode) {
   const run = () => {
     const s2 = subscriber;
     if (s2._disposed || s2._reentrant) return;
@@ -530,13 +638,17 @@ function reactiveBinding(commit) {
   subscriber.depsTail = null;
   subscriber._epoch = 0;
   subscriber._structDirty = false;
+  subscriber._hasComputedDep = false;
   subscriber._runEpoch = 0;
   subscriber._runs = 0;
   subscriber._reentrant = false;
   subscriber._disposed = false;
+  subscriber._errorPhase = "binding";
+  subscriber._errorNode = ownerNode;
   run();
   return subscriber._dispose ?? (subscriber._dispose = () => {
     subscriber._disposed = true;
+    subscriber._errorNode = void 0;
     cleanup(subscriber);
   });
 }
@@ -548,9 +660,12 @@ function recordDependency(signal2) {
   const active = sig.__activeNode ?? null;
   if (active !== null && active.sub === sub2) {
     active.epoch = epoch;
+    active.depVersion = sig.__v ?? Number.NaN;
     return;
   }
+  if (sig._validate !== void 0) sub2._hasComputedDep = true;
   const node = allocNode(signal2, sub2, epoch);
+  node.depVersion = sig.__v ?? Number.NaN;
   node.prevActive = active;
   sig.__activeNode = node;
   linkSub(sub2, node);
@@ -569,9 +684,10 @@ function cleanup(subscriber) {
     node = next;
   }
 }
-var maxSubscriberRepeats = 50;
+var maxSubscriberRepeats = 1e3;
 var maxDrainIterations = 1e6;
 var drainEpoch = 0;
+var quarantined = /* @__PURE__ */ new Set();
 function setMaxSubscriberRepeats(n) {
   const prev = maxSubscriberRepeats;
   if (Number.isFinite(n) && n > 0) maxSubscriberRepeats = Math.floor(n);
@@ -593,19 +709,21 @@ function tickRepeat(sub2) {
   return s2._runs > maxSubscriberRepeats;
 }
 function cycleError(sub2) {
-  if (typeof console !== "undefined") {
-    const name = sub2.__name ?? "<unnamed>";
-    console.error(
-      `[SibuJS] subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. Breaking to prevent infinite loop.`
-    );
-  }
+  const name = sub2.__name ?? "<unnamed>";
+  reportError(
+    new Error(
+      `subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. This subscriber is quarantined for the rest of this update; other pending work still runs.`
+    ),
+    { phase: "scheduler", name }
+  );
 }
 function absoluteDrainError() {
-  if (typeof console !== "undefined") {
-    console.error(
-      `[SibuJS] Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
-    );
-  }
+  reportError(
+    new Error(
+      `Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
+    ),
+    { phase: "scheduler" }
+  );
 }
 function drainQueue() {
   let i2 = 0;
@@ -615,11 +733,14 @@ function drainQueue() {
       break;
     }
     const sub2 = pendingQueue[i2++];
+    pendingSet.delete(sub2);
+    if (quarantined.size > 0 && quarantined.has(sub2)) continue;
+    if (sub2._hasComputedDep === true && !depsChanged(sub2)) continue;
     if (tickRepeat(sub2)) {
       cycleError(sub2);
-      break;
+      quarantined.add(sub2);
+      continue;
     }
-    pendingSet.delete(sub2);
     safeInvoke(sub2);
   }
 }
@@ -634,6 +755,7 @@ function drainNotificationQueue() {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -727,6 +849,7 @@ function notifySubscribers(signal2) {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -753,14 +876,14 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _isDev3 = isDev();
-var _runtimeVersion = true ? "3.4.0" : "dev";
+var _isDev2 = isDev();
+var _runtimeVersion = true ? "4.0.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
   const existing = g2[REGISTRY_KEY];
   if (existing) {
-    if (_isDev3 && !existing.__dupWarned) {
+    if (_isDev2 && !existing.__dupWarned) {
       existing.__dupWarned = true;
       devWarn(
         `Multiple instances of the reactive runtime detected on this page (active: ${existing.version}, duplicate: ${_runtimeVersion}). Reactivity still works \u2014 all copies share the first one \u2014 but de-duplicate sibujs in your bundler (e.g. Vite optimizeDeps.exclude: ['sibujs'] or resolve.dedupe: ['sibujs']).`
@@ -845,6 +968,21 @@ function derived(getter, options) {
   }, markDirty);
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   let evaluating = false;
+  const validate = () => {
+    if (!cs._d) return;
+    const oldValue = cs._v;
+    evaluating = true;
+    try {
+      retrack2(recompute, markDirty);
+      if (!Object.is(oldValue, cs._v)) cs.__v++;
+    } finally {
+      evaluating = false;
+    }
+    if (hook && !Object.is(oldValue, cs._v)) {
+      hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+    }
+  };
+  cs._validate = validate;
   function computedGetter() {
     if (evaluating) {
       throw new Error(
@@ -852,32 +990,11 @@ function derived(getter, options) {
       );
     }
     if (isTrackingSuspended2()) {
-      if (cs._d) {
-        const prev = cs._v;
-        evaluating = true;
-        try {
-          retrack2(recompute, markDirty);
-          if (!Object.is(prev, cs._v)) cs.__v++;
-        } finally {
-          evaluating = false;
-        }
-      }
+      if (cs._d) validate();
       return cs._v;
     }
+    if (cs._d) validate();
     recordDependency2(cs);
-    if (cs._d) {
-      const oldValue = cs._v;
-      evaluating = true;
-      try {
-        retrack2(recompute, markDirty);
-        if (!Object.is(oldValue, cs._v)) cs.__v++;
-      } finally {
-        evaluating = false;
-      }
-      if (hook && oldValue !== cs._v) {
-        hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
-      }
-    }
     return cs._v;
   }
   if (debugName) {
@@ -899,20 +1016,24 @@ function detectSSRShared() {
       const getBuiltin = process.getBuiltinModule;
       if (typeof getBuiltin === "function") {
         mod = getBuiltin("node:async_hooks");
-      } else {
-        const req = Function("return typeof require==='function'?require:null")();
-        if (req) mod = req("node:async_hooks");
+      } else if (typeof require === "function") {
+        mod = require("async_hooks");
       }
       if (mod) detected = new mod.AsyncLocalStorage();
     }
   } catch {
     detected = null;
   }
-  return { als: detected, fallbackStore: { ssr: false, suspenseIdCounter: 0 } };
+  return {
+    als: detected,
+    fallbackStore: { ssr: false, suspenseIdCounter: 0, locale: void 0 },
+    fallbackDepth: 0
+  };
 }
 var _shared = globalThis[SSR_KEY] ?? (globalThis[SSR_KEY] = detectSSRShared());
 var als = _shared.als;
 var fallbackStore = _shared.fallbackStore;
+_shared.fallbackDepth ?? (_shared.fallbackDepth = 0);
 function getSSRStore() {
   if (als) {
     const s2 = als.getStore();
@@ -946,7 +1067,7 @@ function flushUserCleanups(ctx) {
     try {
       list[i2]();
     } catch (err) {
-      if (typeof console !== "undefined") console.warn("[SibuJS effect] onCleanup threw:", err);
+      reportError(err, { phase: "cleanup" });
     }
   }
 }
@@ -959,11 +1080,12 @@ function drainReruns(ctx) {
   } while (ctx.rerunPending && ++reruns <= MAX_RERUNS);
   if (ctx.rerunPending) {
     ctx.rerunPending = false;
-    if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
-      console.error(
-        `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
-      );
-    }
+    reportError(
+      new Error(
+        `effect re-requested itself ${MAX_RERUNS}+ times \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
+      ),
+      { phase: "effect" }
+    );
   }
 }
 function disposeEffect(ctx) {
@@ -1040,6 +1162,8 @@ function effect(effectFn, options) {
   sub2.depsTail = null;
   sub2._epoch = 0;
   sub2._structDirty = false;
+  sub2._hasComputedDep = false;
+  sub2._errorPhase = "effect";
   sub2._runEpoch = 0;
   sub2._runs = 0;
   ctx.subscriber = sub2;
@@ -1108,70 +1232,72 @@ var isBatching = API2.isBatching;
 
 // src/core/signals/signal.ts
 var _g2 = globalThis;
-var _isDev4 = isDev();
+var _isDev3 = isDev();
 function signal(initial, options) {
-  const state = {
+  const state2 = {
     value: initial,
     __v: 0,
     __sc: 0,
     subsHead: null,
     subsTail: null,
     __activeNode: null,
-    __name: void 0
+    __name: void 0,
+    _d: false,
+    _validate: void 0
   };
-  const debugName = _isDev4 ? options?.name : void 0;
+  const debugName = _isDev3 ? options?.name : void 0;
   const equalsFn = options?.equals;
-  if (debugName) state.__name = debugName;
+  if (debugName) state2.__name = debugName;
   function get() {
-    recordDependency2(state);
-    return state.value;
+    recordDependency2(state2);
+    return state2.value;
   }
-  get.__signal = state;
+  get.__signal = state2;
   if (debugName) get.__name = debugName;
   let set;
   if (equalsFn) {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (equalsFn(prev, newValue)) return;
-      state.value = newValue;
-      state.__v++;
-      if (_isDev4) {
+      state2.value = newValue;
+      state2.__v++;
+      if (_isDev3) {
         const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-        if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
+        if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
       }
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
-  } else if (_isDev4) {
+  } else if (_isDev3) {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state.value = newValue;
-      state.__v++;
+      state2.value = newValue;
+      state2.__v++;
       const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-      if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue: prev, newValue });
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
   } else {
     set = (next) => {
-      const prev = state.value;
+      const prev = state2.value;
       const newValue = typeof next === "function" ? next(prev) : next;
       if (Object.is(newValue, prev)) return;
-      state.value = newValue;
-      state.__v++;
-      if (!enqueueBatchedSignal(state)) {
-        notifySubscribers2(state);
+      state2.value = newValue;
+      state2.__v++;
+      if (!enqueueBatchedSignal(state2)) {
+        notifySubscribers2(state2);
       }
     };
   }
-  if (_isDev4) {
+  if (_isDev3) {
     const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+    if (hook) hook.emit("signal:create", { signal: state2, name: debugName, getter: get, initial });
   }
   return [get, set];
 }
@@ -1182,6 +1308,50 @@ function globalSingleton(key, create) {
   return g2[key] ?? (g2[key] = create());
 }
 
+// src/data/abort.ts
+function isAbortError(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+function createAbortError(message = "Aborted") {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException(message, "AbortError");
+  }
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+
+// src/data/callbacks.ts
+function reportCallbackError(label2, error) {
+  if (typeof console !== "undefined") {
+    console.error(`[SibuJS data] ${label2} threw. The operation's own status is unaffected.`, error);
+  }
+}
+function runCallback(label2, fn) {
+  try {
+    fn();
+  } catch (error) {
+    reportCallbackError(label2, error);
+  }
+}
+function runSelect(label2, fn) {
+  try {
+    return { ok: true, value: fn() };
+  } catch (error) {
+    reportCallbackError(label2, error);
+    return { ok: false };
+  }
+}
+function notifyListeners(listeners, label2) {
+  for (const listener of Array.from(listeners)) {
+    try {
+      listener();
+    } catch (error) {
+      reportCallbackError(label2, error);
+    }
+  }
+}
+
 // src/data/retry.ts
 function calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter) {
   let delay;
@@ -1214,39 +1384,54 @@ async function withRetry(fn, options, onRetry, signal2) {
   const shouldRetry = options?.shouldRetry ?? (() => true);
   let lastError;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    if (signal2?.aborted) throw new DOMException("Aborted", "AbortError");
+    if (signal2?.aborted) throw createAbortError();
     try {
-      if (signal2?.aborted) throw new DOMException("Aborted", "AbortError");
       return await fn();
     } catch (error) {
       lastError = error;
+      if (signal2?.aborted) throw createAbortError();
+      if (isAbortError(error)) throw error;
       if (attempt >= maxRetries || !shouldRetry(error, attempt)) throw error;
       const delay = calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter);
       onRetry?.(error, attempt, delay);
-      await new Promise((resolve, reject) => {
-        let onAbort = null;
-        const timer = setTimeout(() => {
-          if (onAbort && signal2) signal2.removeEventListener("abort", onAbort);
-          resolve();
-        }, delay);
-        if (signal2) {
-          onAbort = () => {
-            clearTimeout(timer);
-            reject(new DOMException("Aborted", "AbortError"));
-          };
-          signal2.addEventListener("abort", onAbort, { once: true });
-        }
-      });
+      await waitForRetryDelay(delay, signal2);
     }
   }
   throw lastError;
 }
+function waitForRetryDelay(delay, signal2) {
+  if (signal2?.aborted) return Promise.reject(createAbortError());
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (action) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (signal2) signal2.removeEventListener("abort", onAbort);
+      action();
+    };
+    const onAbort = () => finish(() => reject(createAbortError()));
+    const timer = setTimeout(() => finish(resolve), delay);
+    if (signal2) {
+      signal2.addEventListener("abort", onAbort, { once: true });
+      if (signal2.aborted) onAbort();
+    }
+  });
+}
 
 // src/data/query.ts
 var globalQueryCache = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.query.cache.v1"), () => /* @__PURE__ */ new Map());
 function getActiveQueryCache() {
   return getRequestScopedCache("query") ?? globalQueryCache;
 }
+function abandonEntry(entry) {
+  if (entry.gcTimer) clearTimeout(entry.gcTimer);
+  entry.gcTimer = null;
+  entry.controller?.abort();
+  entry.controller = null;
+  entry.promise = null;
+  entry.generation++;
+}
 function getOrCreateEntry(cache, key, initialData) {
   let entry = cache.get(key);
   if (!entry) {
@@ -1258,7 +1443,9 @@ function getOrCreateEntry(cache, key, initialData) {
       gcTimer: null,
       promise: null,
       listeners: /* @__PURE__ */ new Set(),
-      refetchers: /* @__PURE__ */ new Set()
+      refetchers: /* @__PURE__ */ new Set(),
+      controller: null,
+      generation: 0
     };
     cache.set(key, entry);
   }
@@ -1284,9 +1471,10 @@ function query(key, fetcher, options = {}) {
   const [data2, setData] = signal(initialData);
   const [isFetching, setIsFetching] = signal(false);
   const [error, setError] = signal(void 0);
-  let abortController = null;
   let disposed = false;
   let currentKey = null;
+  let attachedEntry = null;
+  let attachedKey = null;
   let intervalTimer = null;
   const loading = derived(() => isFetching() && data2() === void 0);
   const isStale = derived(() => {
@@ -1296,82 +1484,128 @@ function query(key, fetcher, options = {}) {
     if (!entry || entry.dataUpdatedAt === 0) return true;
     return Date.now() - entry.dataUpdatedAt >= staleTime;
   });
+  function detachFromEntry() {
+    const entry = attachedEntry;
+    const key2 = attachedKey;
+    if (!entry) return;
+    attachedEntry = null;
+    attachedKey = null;
+    entry.listeners.delete(onCacheUpdate);
+    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 (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
+    entry.gcTimer = setTimeout(() => {
+      const current = cache.get(key2);
+      if (current === entry && current.subscribers <= 0) {
+        abandonEntry(current);
+        cache.delete(key2);
+      }
+    }, cacheTime);
+    entry.gcTimer.unref?.();
+  }
+  function attachToEntry(entry, key2) {
+    if (attachedEntry === entry) {
+      if (entry.gcTimer !== null) {
+        clearTimeout(entry.gcTimer);
+        entry.gcTimer = null;
+      }
+      return;
+    }
+    detachFromEntry();
+    attachedEntry = entry;
+    attachedKey = key2;
+    entry.subscribers++;
+    entry.listeners.add(onCacheUpdate);
+    entry.refetchers.add(doFetch);
+    if (entry.gcTimer !== null) {
+      clearTimeout(entry.gcTimer);
+      entry.gcTimer = null;
+    }
+  }
   async function doFetch() {
     if (disposed || !currentKey || !enabled) return;
     const key2 = currentKey;
-    let entry = cache.get(key2);
-    if (!entry) {
-      entry = getOrCreateEntry(cache, key2);
-      entry.listeners.add(onCacheUpdate);
-      entry.refetchers.add(doFetch);
-    }
+    const entry = getOrCreateEntry(cache, key2);
+    attachToEntry(entry, key2);
     if (entry.promise) {
       setIsFetching(true);
       const captured = entry.promise;
       try {
         await captured;
-        if (disposed || currentKey !== key2) return;
-        if (entry.promise === captured) {
-          onCacheUpdate();
-          if (entry.error) onError?.(entry.error);
-          else if (entry.data !== void 0) onSuccess?.(entry.data);
-        }
       } catch {
-        if (disposed || currentKey !== key2) return;
-        if (entry.promise === captured) {
+      } finally {
+        if (!disposed && currentKey === key2) {
           onCacheUpdate();
-          if (entry.error) onError?.(entry.error);
+          if (entry.error) {
+            const settledError = entry.error;
+            runCallback("query onError", () => onError?.(settledError));
+          } else if (entry.data !== void 0) {
+            const settledData = entry.data;
+            runCallback("query onSuccess", () => onSuccess?.(settledData));
+          }
+          runCallback("query onSettled", () => onSettled?.());
         }
-      } finally {
-        if (!disposed && currentKey === key2) onSettled?.();
       }
       return;
     }
-    abortController?.abort();
-    abortController = new AbortController();
-    const signal2 = abortController.signal;
+    entry.controller = new AbortController();
+    const signal2 = entry.controller.signal;
+    const generation = ++entry.generation;
     setIsFetching(true);
     let promise;
     try {
       promise = withRetry(() => fetcher({ signal: signal2, key: key2 }), retryOptions, void 0, signal2);
     } catch (err) {
       setIsFetching(false);
+      if (isAbortError(err)) return;
       const errorObj = err instanceof Error ? err : new Error(String(err));
       entry.error = errorObj;
-      onError?.(errorObj);
-      onSettled?.();
+      runCallback("query onError", () => onError?.(errorObj));
+      runCallback("query onSettled", () => onSettled?.());
       return;
     }
     entry.promise = promise;
     try {
       const result = await promise;
+      if (entry.generation !== generation) return;
       entry.promise = null;
-      if (disposed || currentKey !== key2) return;
+      entry.controller = null;
       entry.data = result;
       entry.dataUpdatedAt = Date.now();
       entry.error = void 0;
-      const selected = select3 ? select3(result) : result;
+      notifyListeners(entry.listeners, "query cache listener");
+      if (disposed || currentKey !== key2) return;
+      const selected = runSelect("query select", () => select3 ? select3(result) : result);
       batch(() => {
-        setData(selected);
+        if (selected.ok) setData(selected.value);
         setIsFetching(false);
         setError(void 0);
       });
-      for (const listener of entry.listeners) listener();
-      onSuccess?.(result);
+      runCallback("query onSuccess", () => onSuccess?.(result));
     } catch (err) {
+      if (entry.generation !== generation) return;
       entry.promise = null;
-      if (disposed || currentKey !== key2) return;
-      if (err instanceof DOMException && err.name === "AbortError") return;
+      entry.controller = null;
+      if (isAbortError(err)) {
+        notifyListeners(entry.listeners, "query cache listener");
+        if (!disposed && currentKey === key2) setIsFetching(false);
+        return;
+      }
       const errorObj = err instanceof Error ? err : new Error(String(err));
       entry.error = errorObj;
+      notifyListeners(entry.listeners, "query cache listener");
+      if (disposed || currentKey !== key2) return;
       batch(() => {
         setError(errorObj);
         setIsFetching(false);
       });
-      for (const listener of entry.listeners) listener();
-      onError?.(errorObj);
+      runCallback("query onError", () => onError?.(errorObj));
     } finally {
-      if (!disposed && currentKey === key2) onSettled?.();
+      if (!disposed && currentKey === key2 && entry.generation === generation) {
+        runCallback("query onSettled", () => onSettled?.());
+      }
     }
   }
   function onCacheUpdate() {
@@ -1386,43 +1620,24 @@ function query(key, fetcher, options = {}) {
       return;
     }
     const raw = entry.data;
-    const selected = raw !== void 0 && select3 ? select3(raw) : raw;
+    const selected = raw !== void 0 && select3 ? runSelect("query select", () => select3(raw)) : { ok: true, value: raw };
     batch(() => {
-      setData(selected);
+      if (selected.ok) setData(selected.value);
       setError(entry.error);
       if (!entry.promise) setIsFetching(false);
     });
   }
   const effectCleanup = effect(() => {
     const key2 = resolveKey();
-    if (currentKey !== null && currentKey !== key2) {
-      const oldEntry = cache.get(currentKey);
-      if (oldEntry) {
-        oldEntry.listeners.delete(onCacheUpdate);
-        oldEntry.refetchers.delete(doFetch);
-        oldEntry.subscribers--;
-        if (oldEntry.subscribers <= 0 && cacheTime >= 0) {
-          const oldKey = currentKey;
-          if (oldEntry.gcTimer !== null) clearTimeout(oldEntry.gcTimer);
-          oldEntry.gcTimer = setTimeout(() => cache.delete(oldKey), cacheTime);
-        }
-      }
-    }
     const keyChanged = currentKey !== key2;
     currentKey = key2;
     const entry = getOrCreateEntry(cache, key2, initialData);
-    if (keyChanged) entry.subscribers++;
-    if (entry.gcTimer !== null) {
-      clearTimeout(entry.gcTimer);
-      entry.gcTimer = null;
-    }
-    entry.listeners.add(onCacheUpdate);
-    entry.refetchers.add(doFetch);
+    attachToEntry(entry, key2);
     if (entry.data !== void 0) {
       const raw = entry.data;
-      const selected = select3 ? select3(raw) : raw;
+      const selected = runSelect("query select", () => select3 ? select3(raw) : raw);
       batch(() => {
-        setData(selected);
+        if (selected.ok) setData(selected.value);
         setError(entry.error);
       });
     }
@@ -1460,22 +1675,9 @@ function query(key, fetcher, options = {}) {
   function dispose2() {
     if (disposed) return;
     disposed = true;
-    abortController?.abort();
     effectCleanup();
     if (intervalTimer) clearInterval(intervalTimer);
-    if (currentKey) {
-      const entry = cache.get(currentKey);
-      if (entry) {
-        entry.listeners.delete(onCacheUpdate);
-        entry.refetchers.delete(doFetch);
-        entry.subscribers--;
-        if (entry.subscribers <= 0 && cacheTime >= 0) {
-          const key2 = currentKey;
-          if (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
-          entry.gcTimer = setTimeout(() => cache.delete(key2), cacheTime);
-        }
-      }
-    }
+    detachFromEntry();
     if (focusHandler && typeof globalThis.removeEventListener === "function") {
       globalThis.removeEventListener("focus", focusHandler);
     }
@@ -1511,21 +1713,21 @@ function setQueryData(key, data2) {
   const newData = typeof data2 === "function" ? data2(entry.data) : data2;
   entry.data = newData;
   entry.dataUpdatedAt = Date.now();
-  for (const listener of entry.listeners) listener();
+  notifyListeners(entry.listeners, "query cache listener");
 }
 function clearQueryCache() {
   const activeListeners = [];
   const activeRefetchers = [];
   const activeCache = getActiveQueryCache();
   for (const entry of activeCache.values()) {
-    if (entry.gcTimer) clearTimeout(entry.gcTimer);
     if (entry.subscribers > 0) {
       for (const listener of entry.listeners) activeListeners.push(listener);
       for (const refetcher of entry.refetchers) activeRefetchers.push(refetcher);
     }
+    abandonEntry(entry);
   }
   activeCache.clear();
-  for (const listener of activeListeners) listener();
+  notifyListeners(activeListeners, "query cache listener");
   for (const refetcher of activeRefetchers) {
     refetcher().catch((err) => {
       if (typeof console !== "undefined") {
@@ -1537,7 +1739,7 @@ function clearQueryCache() {
 function __resetQueryCache() {
   const activeCache = getActiveQueryCache();
   for (const entry of activeCache.values()) {
-    if (entry.gcTimer) clearTimeout(entry.gcTimer);
+    abandonEntry(entry);
   }
   activeCache.clear();
 }
@@ -1552,6 +1754,8 @@ function mutation(mutationFn, options = {}) {
   const isIdle = derived(() => status() === "idle");
   let runId = 0;
   let abortController = null;
+  let terminalStatus = "idle";
+  let terminalError;
   async function execute(variables) {
     abortController?.abort();
     abortController = new AbortController();
@@ -1569,25 +1773,38 @@ function mutation(mutationFn, options = {}) {
       }
       const result = await withRetry(() => mutationFn(variables, signal2), options.retry, void 0, signal2);
       if (myRun !== runId) return result;
+      terminalStatus = "success";
+      terminalError = void 0;
       batch(() => {
         setData(result);
         setLoading(false);
         setStatus("success");
       });
-      options.onSuccess?.(result, variables, context2);
-      options.onSettled?.(result, void 0, variables, context2);
+      runCallback("mutation onSuccess", () => options.onSuccess?.(result, variables, context2));
+      runCallback("mutation onSettled", () => options.onSettled?.(result, void 0, variables, context2));
       return result;
     } catch (err) {
+      if (isAbortError(err)) {
+        if (myRun === runId) {
+          batch(() => {
+            setLoading(false);
+            setError(terminalError);
+            setStatus(terminalStatus);
+          });
+        }
+        throw err;
+      }
       const errorObj = err instanceof Error ? err : new Error(String(err));
-      if (errorObj instanceof DOMException && errorObj.name === "AbortError") throw errorObj;
       if (myRun !== runId) throw errorObj;
+      terminalStatus = "error";
+      terminalError = errorObj;
       batch(() => {
         setError(errorObj);
         setLoading(false);
         setStatus("error");
       });
-      options.onError?.(errorObj, variables, context2);
-      options.onSettled?.(void 0, errorObj, variables, context2);
+      runCallback("mutation onError", () => options.onError?.(errorObj, variables, context2));
+      runCallback("mutation onSettled", () => options.onSettled?.(void 0, errorObj, variables, context2));
       throw errorObj;
     }
   }
@@ -1595,6 +1812,8 @@ function mutation(mutationFn, options = {}) {
     runId++;
     abortController?.abort();
     abortController = null;
+    terminalStatus = "idle";
+    terminalError = void 0;
     batch(() => {
       setData(void 0);
       setError(void 0);
@@ -1610,7 +1829,7 @@ function mutation(mutationFn, options = {}) {
     isIdle,
     mutate: (variables) => {
       execute(variables).catch((err) => {
-        if (err instanceof DOMException && err.name === "AbortError") return;
+        if (isAbortError(err)) return;
         if (typeof console !== "undefined") {
           console.warn("[SibuJS mutation] mutate() failed; check `.error()` signal or onError option.", err);
         }
@@ -1683,10 +1902,17 @@ function infiniteQuery(key, fetcher, options) {
           setIsFetchingNext(false);
           setIsFetchingPrev(false);
         });
-        onSuccess?.(newPages);
+        runCallback("infiniteQuery onSuccess", () => onSuccess?.(newPages));
       } catch (err) {
         if (disposed || myRun !== runId) return;
-        if (err instanceof DOMException && err.name === "AbortError") return;
+        if (isAbortError(err)) {
+          batch(() => {
+            setIsFetching(false);
+            setIsFetchingNext(false);
+            setIsFetchingPrev(false);
+          });
+          return;
+        }
         const errorObj = err instanceof Error ? err : new Error(String(err));
         batch(() => {
           setError(errorObj);
@@ -1694,7 +1920,7 @@ function infiniteQuery(key, fetcher, options) {
           setIsFetchingNext(false);
           setIsFetchingPrev(false);
         });
-        onError?.(errorObj);
+        runCallback("infiniteQuery onError", () => onError?.(errorObj));
       }
     })();
     inFlight = promise;
@@ -1876,7 +2102,7 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
       setLoading(true);
       setError(void 0);
     });
-    options.onStart?.();
+    runCallback("resource onStart", () => options.onStart?.());
     try {
       const result = await withRetry(() => fetcher(sourceValue, { signal: signal2, prev }), options.retry, void 0, signal2);
       if (version !== fetchVersion || disposed) return;
@@ -1885,10 +2111,10 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
         setData(result);
         setLoading(false);
       });
-      options.onSuccess?.(result);
+      runCallback("resource onSuccess", () => options.onSuccess?.(result));
     } catch (err) {
       if (version !== fetchVersion || disposed) return;
-      if (err instanceof DOMException && err.name === "AbortError") {
+      if (isAbortError(err)) {
         if (version === fetchVersion) setLoading(false);
         return;
       }
@@ -1897,10 +2123,10 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
         setError(errorObj);
         setLoading(false);
       });
-      options.onError?.(errorObj);
+      runCallback("resource onError", () => options.onError?.(errorObj));
     } finally {
       if (version === fetchVersion) {
-        options.onSettled?.();
+        runCallback("resource onSettled", () => options.onSettled?.());
       }
     }
   }
@@ -2088,13 +2314,14 @@ async function offlineStore(options) {
     return data2().filter(filter);
   }
   async function sync() {
-    if (!adapter || isSyncing() || closed) return;
+    const syncAdapter2 = adapter;
+    if (!syncAdapter2 || isSyncing() || closed) return;
     setIsSyncing(true);
     try {
       const snapshot = await idbGetAllWithKeys(db, "_changes");
       if (closed) return;
       if (snapshot.length > 0) {
-        const result = await adapter.push(snapshot.map((e) => e.value));
+        const result = await syncAdapter2.push(snapshot.map((e) => e.value));
         if (closed) return;
         if (result.ok) {
           await idbDeleteKeys(
@@ -2107,20 +2334,18 @@ async function offlineStore(options) {
           console.warn(`[offlineStore] push rejected by adapter${result.error ? `: ${result.error}` : ""}`);
         }
       }
-      const remoteItems = await adapter.pull(lastSynced());
+      const remoteItems = await syncAdapter2.pull(lastSynced());
       if (closed) return;
       const pendingChanges = await idbGetAll(db, "_changes");
       if (closed) return;
-      const pendingKeys = /* @__PURE__ */ new Set();
+      const pendingByKey = /* @__PURE__ */ new Map();
       for (const c of pendingChanges) {
         const k = c.item[keyPath];
-        if (k != null) pendingKeys.add(k);
+        if (k != null) pendingByKey.set(k, c);
       }
-      const safeRemote = remoteItems.filter((item) => {
-        const k = item[keyPath];
-        return k == null || !pendingKeys.has(k);
-      });
-      await idbPutMany(db, "items", safeRemote);
+      const resolved = await resolveRemoteItems(syncAdapter2, remoteItems, pendingByKey);
+      if (closed) return;
+      await idbPutMany(db, "items", resolved);
       if (closed) return;
       const now = Date.now();
       await idbPut(db, "_meta", now, "lastSynced");
@@ -2133,6 +2358,42 @@ async function offlineStore(options) {
       setIsSyncing(false);
     }
   }
+  async function resolveRemoteItems(activeAdapter, remoteItems, pendingByKey) {
+    const strategy = activeAdapter.conflictStrategy ?? "client-wins";
+    const out = [];
+    for (const remote of remoteItems) {
+      const key = remote[keyPath];
+      const pending = key == null ? void 0 : pendingByKey.get(key);
+      if (!pending) {
+        out.push(remote);
+        continue;
+      }
+      if (strategy === "server-wins") {
+        out.push(remote);
+        continue;
+      }
+      if (strategy === "manual") {
+        if (!activeAdapter.resolveConflict) {
+          if (typeof console !== "undefined") {
+            console.warn(
+              '[offlineStore] conflictStrategy is "manual" but the adapter has no resolveConflict(); keeping the local record for this key (client-wins).'
+            );
+          }
+          continue;
+        }
+        try {
+          const local = pending.type === "delete" ? void 0 : await idbGet(db, "items", key);
+          const choice = await activeAdapter.resolveConflict({ key, local, remote, pending });
+          if (choice !== void 0) out.push(choice);
+        } catch (err) {
+          if (typeof console !== "undefined") {
+            console.warn("[offlineStore] resolveConflict threw; keeping the local record", err);
+          }
+        }
+      }
+    }
+    return out;
+  }
   function attach(newAdapter) {
     adapter = newAdapter;
   }
@@ -2171,10 +2432,18 @@ function syncAdapter(config) {
 }
 
 // src/core/rendering/context.ts
+var _isDev4 = isDev();
 function context(defaultValue) {
   const [getValue, setValue] = signal(defaultValue);
+  const warnIfSSR = (method) => {
+    if (!_isDev4 || !isSSR()) return;
+    devWarn(
+      `context.${method}() called during SSR. SibuJS context() is application-global \u2014 it is NOT isolated per request, so a concurrent request can observe this value. Do not use context() for request-specific SSR data; pass it explicitly or use request-scoped storage instead.`
+    );
+  };
   const ctx = {
     provide(value) {
+      warnIfSSR("provide");
       const previous2 = getValue();
       setValue(value);
       return () => setValue(previous2);
@@ -2186,13 +2455,21 @@ function context(defaultValue) {
       return getValue();
     },
     set(value) {
+      warnIfSSR("set");
       setValue(value);
     },
     withContext(value, fn) {
+      warnIfSSR("withContext");
       const previous2 = getValue();
       setValue(value);
       try {
-        return fn();
+        const result = fn();
+        if (_isDev4 && result !== null && typeof result?.then === "function") {
+          devWarn(
+            "context.withContext() received an async callback. Scoping is synchronous only \u2014 the previous value is restored as soon as the callback returns its promise, so anything after an `await` runs outside the scope."
+          );
+        }
+        return result;
       } finally {
         setValue(previous2);
       }
@@ -2348,16 +2625,21 @@ function socket(url, options) {
 function stripControlChars(value) {
   return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
 }
+function canonicalAttrName(name) {
+  return name.replace(/[A-Z]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) + 32));
+}
 function isEventHandlerAttr(name) {
   if (name.length < 3) return false;
   const lower = name.toLowerCase();
   return lower[0] === "o" && lower[1] === "n" && lower.charCodeAt(2) >= 97 && lower.charCodeAt(2) <= 122;
 }
 var SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
+var OUTER_TRIM = /^[\x00-\x20\x7f-\x9f]+|[\x00-\x20\x7f-\x9f]+$/g;
 function sanitizeUrl(url) {
-  const trimmed = stripControlChars(url).trim();
-  if (!trimmed) return "";
-  const lower = trimmed.toLowerCase();
+  const probe = stripControlChars(url).trim();
+  if (!probe) return "";
+  const output2 = url.replace(OUTER_TRIM, "");
+  const lower = probe.toLowerCase();
   let schemeEnd = -1;
   for (let i2 = 0; i2 < lower.length; i2++) {
     const ch = lower.charCodeAt(i2);
@@ -2367,12 +2649,13 @@ function sanitizeUrl(url) {
     }
     if (ch === 47 || ch === 63 || ch === 35) break;
   }
-  if (schemeEnd === -1) return trimmed;
+  if (schemeEnd === -1) return output2;
   const scheme = lower.slice(0, schemeEnd + 1);
-  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return trimmed;
+  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return output2;
   if (SAFE_URL_PROTOCOLS.indexOf(scheme) === -1) return "";
-  return trimmed;
+  return output2;
 }
+var SRCSET_DESCRIPTOR = /^\s+\d+(\.\d+)?[wx]$/;
 function sanitizeSrcset(value) {
   const parts = value.split(",");
   const out = [];
@@ -2381,6 +2664,7 @@ function sanitizeSrcset(value) {
     if (!part) continue;
     const m = part.match(/^(\S+)(\s+.+)?$/);
     if (!m) continue;
+    if (m[2] !== void 0 && !SRCSET_DESCRIPTOR.test(m[2])) continue;
     const safe = sanitizeUrl(m[1]);
     if (!safe) continue;
     out.push(m[2] ? `${safe}${m[2]}` : safe);
@@ -2388,23 +2672,83 @@ function sanitizeSrcset(value) {
   return out.join(", ");
 }
 var CSS_DANGER_GATE = /[(:@\\]/;
+function isCssWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
+}
+function isHexDigit(ch) {
+  return ch >= "0" && ch <= "9" || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F";
+}
+function decodeCssEscapes(value) {
+  let out = "";
+  for (let i2 = 0; i2 < value.length; i2++) {
+    const ch = value[i2];
+    if (ch !== "\\") {
+      out += ch;
+      continue;
+    }
+    if (i2 + 1 >= value.length) break;
+    const next = value[i2 + 1];
+    if (next === "\n" || next === "\f") {
+      i2 += 1;
+      continue;
+    }
+    if (next === "\r") {
+      i2 += value[i2 + 2] === "\n" ? 2 : 1;
+      continue;
+    }
+    if (isHexDigit(next)) {
+      let hex = "";
+      let j = i2 + 1;
+      while (j < value.length && hex.length < 6 && isHexDigit(value[j])) {
+        hex += value[j];
+        j++;
+      }
+      if (j < value.length && isCssWhitespace(value[j])) {
+        j += value[j] === "\r" && value[j + 1] === "\n" ? 2 : 1;
+      }
+      const code2 = Number.parseInt(hex, 16);
+      const invalid = code2 === 0 || code2 > 1114111 || code2 >= 55296 && code2 <= 57343;
+      out += invalid ? "\uFFFD" : String.fromCodePoint(code2);
+      i2 = j - 1;
+      continue;
+    }
+    out += next;
+    i2 += 1;
+  }
+  return out;
+}
 function sanitizeCSSValue(value) {
   if (!CSS_DANGER_GATE.test(value)) return value;
-  const decoded = value.replace(/\\([0-9a-fA-F]{1,6})\s?/g, (_m, hex) => {
-    const code2 = Number.parseInt(hex, 16);
-    if (!Number.isFinite(code2) || code2 < 0 || code2 > 1114111) return "";
-    try {
-      return String.fromCodePoint(code2);
-    } catch {
-      return "";
-    }
-  });
-  const lower = decoded.toLowerCase().replace(/\s+/g, "");
+  const normalized = value.includes("\\") ? decodeCssEscapes(value) : value;
+  const lower = normalized.toLowerCase().replace(/\s+/g, "");
   if (lower.includes("url(") || lower.includes("expression(") || lower.includes("javascript:") || lower.includes("vbscript:") || lower.includes("-moz-binding") || lower.includes("behavior:") || lower.includes("@import") || lower.includes("image-set(") || lower.includes("filter:progid")) {
     return "";
   }
   return value;
 }
+function sanitizeStyleAttribute(cssText) {
+  const input2 = String(cssText);
+  if (input2.trim() === "") return "";
+  if (typeof document === "undefined") {
+    return sanitizeCSSValue(input2) === "" ? "" : input2;
+  }
+  const probe = document.createElement("div");
+  try {
+    probe.style.cssText = input2;
+  } catch {
+    return "";
+  }
+  const declarations = [];
+  for (let i2 = 0; i2 < probe.style.length; i2++) {
+    const property = probe.style[i2];
+    const value = probe.style.getPropertyValue(property);
+    if (sanitizeCSSValue(value) === "") continue;
+    if (sanitizeCSSValue(`${property}:${value}`) === "") continue;
+    const priority = probe.style.getPropertyPriority(property);
+    declarations.push(`${property}: ${value}${priority ? ` !${priority}` : ""}`);
+  }
+  return declarations.join("; ");
+}
 function stripHtml(html2) {
   const input2 = String(html2);
   if (typeof DOMParser !== "undefined") {
@@ -2433,12 +2777,25 @@ var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "background",
   "srcset",
   "ping",
-  "data"
+  "data",
+  // `<html manifest>` is a URL sink too. It was carried only by the SSR
+  // serializers' private copy of this set; folding that copy into this one would
+  // otherwise have silently dropped its coverage.
+  "manifest"
 ]);
+var HTML_CONTENT_ATTRIBUTES = /* @__PURE__ */ new Set(["srcdoc"]);
+function isHtmlContentAttribute(name) {
+  return HTML_CONTENT_ATTRIBUTES.has(name.toLowerCase());
+}
+function isPolicyAttribute(name) {
+  const lower = name.toLowerCase();
+  return lower === "style" || URL_ATTRIBUTES.has(lower);
+}
 function sanitizeAttributeString(attr, value) {
   const lower = attr.toLowerCase();
   if (lower === "srcset") return sanitizeSrcset(value);
   if (URL_ATTRIBUTES.has(lower)) return sanitizeUrl(value);
+  if (lower === "style") return sanitizeStyleAttribute(value);
   return value;
 }
 
@@ -2771,13 +3128,13 @@ function idle(timeout = 6e4) {
 
 // src/browser/permissions.ts
 function permissions(name) {
-  const [state, setState] = signal("prompt");
+  const [state2, setState] = signal("prompt");
   let permissionStatus = null;
   let onChange = null;
   let disposed = false;
   if (typeof navigator === "undefined" || !navigator.permissions) {
     setState("unsupported");
-    return { state, dispose: () => {
+    return { state: state2, dispose: () => {
     } };
   }
   navigator.permissions.query({ name }).then((status) => {
@@ -2789,6 +3146,7 @@ function permissions(name) {
     };
     status.addEventListener("change", onChange);
   }).catch(() => {
+    if (disposed) return;
     setState("unsupported");
   });
   function dispose2() {
@@ -2799,7 +3157,7 @@ function permissions(name) {
       onChange = null;
     }
   }
-  return { state, dispose: dispose2 };
+  return { state: state2, dispose: dispose2 };
 }
 
 // src/browser/clipboard.ts
@@ -2807,20 +3165,25 @@ function clipboard() {
   const [text2, setText] = signal("");
   const [copied, setCopied] = signal(false);
   let copiedTimer = null;
+  let disposed = false;
   async function copy(value) {
+    if (disposed) return;
     if (typeof navigator === "undefined" || !navigator.clipboard) {
       return;
     }
     await navigator.clipboard.writeText(value);
+    if (disposed) return;
     setText(value);
     setCopied(true);
     if (copiedTimer !== null) clearTimeout(copiedTimer);
     copiedTimer = setTimeout(() => {
+      if (disposed) return;
       setCopied(false);
       copiedTimer = null;
     }, 2e3);
   }
   function dispose2() {
+    disposed = true;
     if (copiedTimer !== null) {
       clearTimeout(copiedTimer);
       copiedTimer = null;
@@ -2953,26 +3316,141 @@ function dropZone(element, options) {
   return { isOver, dispose: dispose2 };
 }
 
+// src/utils/singletonResource.ts
+function singletonResource(io) {
+  let original = null;
+  let captured = false;
+  const stack = [];
+  function apply() {
+    if (stack.length > 0) {
+      io.write(stack[stack.length - 1].value);
+      return;
+    }
+    if (captured) {
+      io.write(original);
+      captured = false;
+      original = null;
+    }
+  }
+  return {
+    acquire(value) {
+      if (!captured) {
+        original = io.read();
+        captured = true;
+      }
+      const entry = { value, released: false };
+      stack.push(entry);
+      apply();
+      return {
+        set(next) {
+          if (entry.released) return;
+          entry.value = next;
+          apply();
+        },
+        release() {
+          if (entry.released) return;
+          entry.released = true;
+          const index = stack.indexOf(entry);
+          if (index !== -1) stack.splice(index, 1);
+          apply();
+        }
+      };
+    },
+    ownerCount() {
+      return stack.length;
+    }
+  };
+}
+
+// src/utils/documentResources.ts
+var INERT_LEASE = {
+  set() {
+  },
+  release() {
+  }
+};
+function inertLease() {
+  return INERT_LEASE;
+}
+var titleResource = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.documentTitle.v1"),
+  () => singletonResource({
+    read: () => document.title,
+    write: (value) => {
+      document.title = value;
+    }
+  })
+);
+var baseResource = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.documentBase.v1"),
+  () => singletonResource({
+    read: () => {
+      const el = document.head.querySelector("base");
+      if (!el) return null;
+      return {
+        href: el.getAttribute("href") ?? void 0,
+        target: el.getAttribute("target") ?? void 0
+      };
+    },
+    write: (spec) => {
+      const existing = document.head.querySelector("base");
+      if (spec === null) {
+        existing?.remove();
+        return;
+      }
+      const el = existing ?? document.head.appendChild(document.createElement("base"));
+      if (spec.href === void 0) el.removeAttribute("href");
+      else el.setAttribute("href", spec.href);
+      if (spec.target === void 0) el.removeAttribute("target");
+      else el.setAttribute("target", spec.target);
+    }
+  })
+);
+var scrollRestorationResource = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.historyScrollRestoration.v1"),
+  () => singletonResource({
+    read: () => history.scrollRestoration,
+    write: (mode) => {
+      history.scrollRestoration = mode;
+    }
+  })
+);
+function acquireScrollRestorationMode(mode) {
+  if (typeof history === "undefined" || !("scrollRestoration" in history)) {
+    return inertLease();
+  }
+  return scrollRestorationResource.acquire(mode);
+}
+function acquireTitle(value) {
+  if (typeof document === "undefined") return inertLease();
+  return titleResource.acquire(value);
+}
+function acquireBase(spec) {
+  if (typeof document === "undefined") return inertLease();
+  return baseResource.acquire(spec);
+}
+
 // src/browser/title.ts
 function title(value) {
   if (typeof document === "undefined") {
     return () => {
     };
   }
-  const previousTitle = document.title;
   if (typeof value === "function") {
+    let lease2 = null;
     const cleanup3 = effect(() => {
-      document.title = value();
+      const next = value();
+      if (lease2) lease2.set(next);
+      else lease2 = acquireTitle(next);
     });
     return () => {
       cleanup3();
-      document.title = previousTitle;
+      lease2?.release();
+      lease2 = null;
     };
   }
-  document.title = value;
-  return () => {
-    document.title = previousTitle;
-  };
+  const lease = acquireTitle(value);
+  return () => lease.release();
 }
 
 // src/browser/colorScheme.ts
@@ -3286,51 +3764,112 @@ function wakeLock() {
     };
   }
   const api = navigator.wakeLock;
-  let sentinel = null;
+  let current = null;
+  let desire = false;
+  let generation = 0;
+  let inflight = null;
   let disposed = false;
-  async function request() {
+  function publishActive(value) {
     if (disposed) return;
-    try {
-      const s2 = await api.request("screen");
-      if (disposed) {
-        s2.release().catch(() => {
-        });
-        return;
-      }
-      sentinel = s2;
-      setActive(true);
-      sentinel.addEventListener("release", () => {
-        setActive(false);
-      });
-    } catch {
-      setActive(false);
+    setActive(value);
+  }
+  function syncReleasedState() {
+    if (current?.released) {
+      current = null;
+      publishActive(false);
+    }
+  }
+  function discard(sentinel) {
+    if (sentinel.released) return;
+    sentinel.release().catch((err) => {
+      reportError(err, { phase: "async", name: "wakeLock(discard)" });
+    });
+  }
+  async function request() {
+    if (disposed) return;
+    desire = true;
+    syncReleasedState();
+    if (current && !current.released) {
+      publishActive(true);
+      return;
     }
+    if (inflight) return inflight;
+    const myGeneration = ++generation;
+    const attempt = (async () => {
+      try {
+        const sentinel = await api.request("screen");
+        if (disposed || !desire || generation !== myGeneration) {
+          discard(sentinel);
+          return;
+        }
+        if (sentinel.released) {
+          publishActive(false);
+          return;
+        }
+        try {
+          sentinel.addEventListener("release", () => {
+            if (current !== sentinel) return;
+            current = null;
+            publishActive(false);
+          });
+        } catch (listenerError) {
+          discard(sentinel);
+          publishActive(false);
+          reportError(listenerError, { phase: "async", name: "wakeLock(listener registration)" });
+          return;
+        }
+        if (sentinel.released) {
+          publishActive(false);
+          return;
+        }
+        current = sentinel;
+        publishActive(true);
+      } catch (err) {
+        if (generation === myGeneration) publishActive(false);
+        reportError(err, { phase: "async", name: "wakeLock(request)" });
+      }
+    })();
+    inflight = attempt;
+    void attempt.finally(() => {
+      if (inflight === attempt) inflight = null;
+    }).catch(() => {
+    });
+    return attempt;
   }
   async function release() {
-    if (sentinel && !sentinel.released) {
-      await sentinel.release();
+    desire = false;
+    generation++;
+    inflight = null;
+    const held = current;
+    current = null;
+    publishActive(false);
+    if (held && !held.released) {
+      await held.release();
     }
-    sentinel = null;
-    setActive(false);
   }
   const onVisibility = () => {
-    if (sentinel?.released && !document.hidden) {
-      request().catch((err) => {
-        if (typeof console !== "undefined") {
-          console.warn("[SibuJS wakeLock] re-acquire failed:", err);
-        }
-      });
-    }
+    syncReleasedState();
+    if (!desire || current || document.hidden) return;
+    request().catch((err) => {
+      reportError(err, { phase: "async", name: "wakeLock(visibility re-acquire)" });
+    });
   };
   document.addEventListener("visibilitychange", onVisibility);
   function dispose2() {
-    disposed = true;
+    if (disposed) return;
+    desire = false;
+    generation++;
+    inflight = null;
     document.removeEventListener("visibilitychange", onVisibility);
-    release().catch((err) => {
-      if (typeof console !== "undefined") {
-        console.warn("[SibuJS wakeLock] release failed:", err);
-      }
-    });
+    const held = current;
+    current = null;
+    setActive(false);
+    disposed = true;
+    if (held && !held.released) {
+      held.release().catch((err) => {
+        reportError(err, { phase: "async", name: "wakeLock(dispose release)" });
+      });
+    }
   }
   return { active, request, release, dispose: dispose2 };
 }
@@ -3845,14 +4384,14 @@ function imageLoader(src) {
 
 // src/patterns/machine.ts
 function machine(config) {
-  const [state, setState] = signal(config.initial);
+  const [state2, setState] = signal(config.initial);
   const [context2, setContext] = signal(config.context || {});
   const initialDef = config.states[config.initial];
   if (initialDef?.entry) {
     initialDef.entry(context2());
   }
   function send(event) {
-    const currentState = state();
+    const currentState = state2();
     const stateDef = config.states[currentState];
     if (!stateDef?.on) return;
     const transition2 = stateDef.on[event];
@@ -3884,10 +4423,10 @@ function machine(config) {
     }
   }
   function matches(s2) {
-    return state() === s2;
+    return state2() === s2;
   }
   function can(event) {
-    const currentState = state();
+    const currentState = state2();
     const stateDef = config.states[currentState];
     if (!stateDef?.on) return false;
     const transition2 = stateDef.on[event];
@@ -3898,7 +4437,7 @@ function machine(config) {
     }
     return true;
   }
-  return { state, context: context2, send, matches, can };
+  return { state: state2, context: context2, send, matches, can };
 }
 
 // src/patterns/persist.ts
@@ -4007,116 +4546,258 @@ function optimistic(initialValue) {
       }
     } finally {
       inflightCount--;
-      if (inflightCount === 0) setPending(false);
+      if (inflightCount <= 0) {
+        inflightCount = 0;
+        setPending(false);
+      }
     }
   }
   return { value, pending, update };
 }
 function optimisticList(initialValue) {
-  const [items, setItems] = signal([...initialValue]);
+  let nextRowId = 0;
+  let nextKey = 0;
+  let nextOpId = 0;
+  const records = /* @__PURE__ */ new Map();
+  let order = [];
+  for (const value of initialValue) {
+    const row = { id: nextRowId++, key: nextKey++, base: value, claims: [], visible: true, refs: 0 };
+    records.set(row.id, row);
+    order.push(row.id);
+  }
+  function effectiveValue(row) {
+    const claims = row.claims;
+    return claims.length > 0 ? claims[claims.length - 1].value : row.base;
+  }
+  function valueBelow(row, opId) {
+    const claims = row.claims;
+    for (let i2 = claims.length - 1; i2 >= 0; i2--) {
+      if (claims[i2].opId < opId) return claims[i2].value;
+    }
+    return row.base;
+  }
+  function stake(row, opId, value) {
+    const claim = { opId, value, settled: false };
+    const claims = row.claims;
+    let at = claims.length;
+    while (at > 0 && claims[at - 1].opId > opId) at--;
+    claims.splice(at, 0, claim);
+    return claim;
+  }
+  function dropClaim(row, claim) {
+    const at = row.claims.indexOf(claim);
+    if (at !== -1) row.claims.splice(at, 1);
+  }
+  function collapse(row) {
+    const claims = row.claims;
+    let i2 = 0;
+    while (i2 < claims.length && claims[i2].settled) {
+      row.base = claims[i2].value;
+      i2++;
+    }
+    if (i2 > 0) claims.splice(0, i2);
+  }
+  const [items, setItems] = signal(order.map((id) => effectiveValue(records.get(id))));
   const [pending, setPending] = signal(false);
-  let inflightCount = 0;
-  let version = 0;
-  let tempIdCounter = 0;
-  const itemIds = /* @__PURE__ */ new WeakMap();
-  const idToItem = /* @__PURE__ */ new Map();
-  function tagItem(item) {
-    const id = ++tempIdCounter;
-    if (item !== null && typeof item === "object") {
-      itemIds.set(item, id);
-    }
-    idToItem.set(id, item);
-    return id;
+  let inflight = 0;
+  const retiredRowIds = /* @__PURE__ */ new Set();
+  function project() {
+    const out = new Array(order.length);
+    for (let i2 = 0; i2 < order.length; i2++) out[i2] = effectiveValue(records.get(order[i2]));
+    return out;
   }
-  function findIndexById(list, id) {
-    for (let i2 = 0; i2 < list.length; i2++) {
-      const it = list[i2];
-      if (it !== null && typeof it === "object" && itemIds.get(it) === id) {
-        return i2;
+  function commit(mutate) {
+    batch(() => {
+      let visibleChanged = false;
+      try {
+        visibleChanged = mutate();
+      } finally {
+        setPending(inflight > 0);
+        if (visibleChanged) setItems(project());
       }
-      if (Object.is(it, idToItem.get(id))) return i2;
+    });
+  }
+  function hide(id) {
+    const row = records.get(id);
+    if (!row || !row.visible) return false;
+    row.visible = false;
+    order = order.filter((x) => x !== id);
+    return true;
+  }
+  function restore(ids) {
+    const restorable = [];
+    for (const id of ids) {
+      const row = records.get(id);
+      if (!row || row.visible || retiredRowIds.has(id)) continue;
+      restorable.push(id);
+    }
+    if (restorable.length === 0) return false;
+    const merged = new Array(order.length + restorable.length);
+    let i2 = 0;
+    let j = 0;
+    let w = 0;
+    while (i2 < order.length && j < restorable.length) {
+      const a2 = records.get(order[i2]).key;
+      const b2 = records.get(restorable[j]).key;
+      merged[w++] = a2 <= b2 ? order[i2++] : restorable[j++];
+    }
+    while (i2 < order.length) merged[w++] = order[i2++];
+    while (j < restorable.length) merged[w++] = restorable[j++];
+    for (const id of restorable) records.get(id).visible = true;
+    order = merged;
+    return true;
+  }
+  function retain(ids) {
+    for (const id of ids) {
+      const row = records.get(id);
+      if (row) row.refs++;
     }
-    return -1;
   }
-  function begin() {
-    const v = ++version;
-    inflightCount++;
-    setPending(true);
-    return v;
+  function release(ids) {
+    for (const id of ids) {
+      const row = records.get(id);
+      if (!row) continue;
+      row.refs--;
+      if (row.refs <= 0 && !row.visible) {
+        records.delete(id);
+        retiredRowIds.delete(id);
+      }
+    }
   }
-  function end(myVersion, revertFn) {
-    if (revertFn && version === myVersion) {
-      revertFn();
+  function settle(heldIds) {
+    release(heldIds);
+    inflight--;
+    if (inflight <= 0) {
+      inflight = 0;
+      retiredRowIds.clear();
+      if (records.size !== order.length) {
+        for (const [id, row] of records) {
+          if (!row.visible) records.delete(id);
+        }
+      }
     }
-    inflightCount--;
-    if (inflightCount === 0) setPending(false);
   }
   async function add(item, asyncAction) {
-    const prev = items();
-    const id = tagItem(item);
-    setItems([...prev, item]);
-    const myVersion = begin();
+    const opId = ++nextOpId;
+    const row = { id: nextRowId++, key: nextKey++, base: item, claims: [], visible: false, refs: 1 };
+    const claim = stake(row, opId, item);
+    commit(() => {
+      records.set(row.id, row);
+      row.visible = true;
+      order = [...order, row.id];
+      inflight++;
+      return true;
+    });
+    let result;
+    let failed = false;
     try {
-      const result = await asyncAction();
-      setItems((current) => {
-        const idx = findIndexById(current, id);
-        if (idx >= 0) {
-          const next = [...current];
-          next[idx] = result;
-          return next;
-        }
-        return [...current, result];
-      });
-      idToItem.delete(id);
-      end(myVersion);
+      result = await asyncAction();
     } catch {
-      idToItem.delete(id);
-      end(myVersion, () => setItems(prev));
+      failed = true;
     }
+    commit(() => {
+      try {
+        if (failed) {
+          retiredRowIds.add(row.id);
+          dropClaim(row, claim);
+          return hide(row.id);
+        }
+        const before = effectiveValue(row);
+        claim.value = result;
+        claim.settled = true;
+        collapse(row);
+        return row.visible && !Object.is(before, effectiveValue(row));
+      } finally {
+        settle([row.id]);
+      }
+    });
   }
   async function remove(predicate, asyncAction) {
-    const prev = items();
-    setItems(prev.filter((item) => !predicate(item)));
-    const myVersion = begin();
+    const opId = ++nextOpId;
+    const matchedIds = [];
+    for (const id of order) {
+      if (predicate(valueBelow(records.get(id), opId))) matchedIds.push(id);
+    }
+    commit(() => {
+      retain(matchedIds);
+      inflight++;
+      if (matchedIds.length === 0) return false;
+      const removing = new Set(matchedIds);
+      for (const id of matchedIds) {
+        const row = records.get(id);
+        if (row) row.visible = false;
+      }
+      order = order.filter((id) => !removing.has(id));
+      return true;
+    });
+    let failed = false;
     try {
       await asyncAction();
-      end(myVersion);
     } catch {
-      end(myVersion, () => setItems(prev));
+      failed = true;
     }
+    commit(() => {
+      try {
+        if (!failed) {
+          for (const id of matchedIds) retiredRowIds.add(id);
+          return false;
+        }
+        return restore(matchedIds);
+      } finally {
+        settle(matchedIds);
+      }
+    });
   }
   async function updateItem(predicate, patch, asyncAction) {
-    const prev = items();
-    const patchedIds = [];
-    setItems(
-      prev.map((item) => {
-        if (predicate(item)) {
-          const patched = { ...item, ...patch };
-          const id = tagItem(patched);
-          patchedIds.push(id);
-          return patched;
-        }
-        return item;
-      })
-    );
-    const myVersion = begin();
+    const opId = ++nextOpId;
+    const prepared = [];
+    for (const id of order) {
+      const row = records.get(id);
+      const seen = valueBelow(row, opId);
+      if (!predicate(seen)) continue;
+      prepared.push({ row, nextValue: { ...seen, ...patch } });
+    }
+    const preparedIds = prepared.map((p2) => p2.row.id);
+    const claims = [];
+    commit(() => {
+      retain(preparedIds);
+      inflight++;
+      let visibleChanged = false;
+      for (const p2 of prepared) {
+        const before = effectiveValue(p2.row);
+        claims.push(stake(p2.row, opId, p2.nextValue));
+        if (p2.row.visible && !Object.is(before, effectiveValue(p2.row))) visibleChanged = true;
+      }
+      return visibleChanged;
+    });
+    let result;
+    let failed = false;
     try {
-      const result = await asyncAction();
-      setItems(
-        (current) => current.map((item) => {
-          if (item !== null && typeof item === "object") {
-            const existingId = itemIds.get(item);
-            if (existingId !== void 0 && patchedIds.includes(existingId)) return result;
-          }
-          return item;
-        })
-      );
-      for (const id of patchedIds) idToItem.delete(id);
-      end(myVersion);
+      result = await asyncAction();
     } catch {
-      for (const id of patchedIds) idToItem.delete(id);
-      end(myVersion, () => setItems(prev));
+      failed = true;
     }
+    commit(() => {
+      try {
+        let visibleChanged = false;
+        for (let i2 = 0; i2 < claims.length; i2++) {
+          const row = prepared[i2].row;
+          const claim = claims[i2];
+          const before = effectiveValue(row);
+          if (failed) {
+            dropClaim(row, claim);
+          } else {
+            claim.value = result;
+            claim.settled = true;
+          }
+          collapse(row);
+          if (row.visible && !Object.is(before, effectiveValue(row))) visibleChanged = true;
+        }
+        return visibleChanged;
+      } finally {
+        settle(preparedIds);
+      }
+    });
   }
   return {
     items,
@@ -4129,16 +4810,16 @@ function optimisticList(initialValue) {
 
 // src/patterns/timeTravel.ts
 function timeline(initial, maxHistory = 100) {
-  const [history, setHistory] = signal([initial]);
+  const [history2, setHistory] = signal([initial]);
   const [index, setIndex] = signal(0);
-  const value = derived(() => history()[index()]);
+  const value = derived(() => history2()[index()]);
   const canUndo = derived(() => index() > 0);
-  const canRedo = derived(() => index() < history().length - 1);
+  const canRedo = derived(() => index() < history2().length - 1);
   function set(next) {
     const current = value();
     const newValue = typeof next === "function" ? next(current) : next;
     if (Object.is(newValue, current)) return;
-    const hist = history();
+    const hist = history2();
     const idx = index();
     const newHistory = hist.slice(0, idx + 1);
     newHistory.push(newValue);
@@ -4170,12 +4851,12 @@ function timeline(initial, maxHistory = 100) {
     });
   }
   function jumpTo(targetIndex) {
-    const hist = history();
+    const hist = history2();
     if (targetIndex >= 0 && targetIndex < hist.length) {
       setIndex(targetIndex);
     }
   }
-  return { value, set, undo, redo, canUndo, canRedo, history, index, reset, jumpTo };
+  return { value, set, undo, redo, canUndo, canRedo, history: history2, index, reset, jumpTo };
 }
 
 // src/patterns/globalStore.ts
@@ -4422,6 +5103,14 @@ function createGuard(validator) {
 
 // src/core/rendering/dispose.ts
 var elementDisposers = /* @__PURE__ */ new WeakMap();
+var MAX_DRAIN_TEARDOWNS = 1e4;
+function reportDrainRunaway(label2, executed, remaining) {
+  if (typeof console === "undefined") return;
+  console.error(
+    `[SibuJS ${label2}] runaway cleanup: stopped after running ${executed} teardowns with ${remaining} still queued. Cleanup production did not stabilize before the teardown safety ceiling was reached \u2014 the remaining work was NOT run.`,
+    { executed, remaining }
+  );
+}
 var _isDev5 = isDev();
 var activeBindingCount = 0;
 function registerDisposer(node, teardown) {
@@ -4446,40 +5135,47 @@ function dispose(node) {
   }
   for (let i2 = order.length - 1; i2 >= 0; i2--) {
     const current = order[i2];
-    const disposers = elementDisposers.get(current);
-    if (disposers) {
-      const snapshot = disposers.slice();
-      elementDisposers.delete(current);
-      if (_isDev5) activeBindingCount -= snapshot.length;
-      for (const d of snapshot) {
-        try {
-          d();
-        } catch (err) {
-          if (_isDev5 && typeof console !== "undefined") {
-            console.warn("[SibuJS] Disposer threw during cleanup:", err);
-          }
-        }
-      }
-      let extraPasses = 0;
-      while (extraPasses++ < 8) {
-        const added = elementDisposers.get(current);
-        if (!added || added.length === 0) break;
-        const moreSnapshot = added.slice();
+    if (elementDisposers.has(current)) {
+      let executed = 0;
+      let runaway = false;
+      while (!runaway) {
+        const pending = elementDisposers.get(current);
+        if (!pending || pending.length === 0) break;
+        const snapshot = pending.slice();
         elementDisposers.delete(current);
-        if (_isDev5) activeBindingCount -= moreSnapshot.length;
-        for (const d of moreSnapshot) {
+        if (_isDev5) activeBindingCount -= snapshot.length;
+        for (let i3 = 0; i3 < snapshot.length; i3++) {
+          if (executed >= MAX_DRAIN_TEARDOWNS) {
+            const rest = snapshot.slice(i3);
+            const added = elementDisposers.get(current);
+            elementDisposers.set(current, added ? rest.concat(added) : rest);
+            if (_isDev5) activeBindingCount += rest.length;
+            reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
+            runaway = true;
+            break;
+          }
+          executed++;
           try {
-            d();
+            snapshot[i3]();
           } catch (err) {
-            if (_isDev5 && typeof console !== "undefined") {
-              console.warn("[SibuJS] Disposer threw during cleanup:", err);
-            }
+            reportError(err, { phase: "cleanup", name: "disposer" });
           }
         }
       }
     }
   }
 }
+function replaceChildrenSafely(parent, ...next) {
+  for (let i2 = 0; i2 < next.length; i2++) {
+    const node = next[i2];
+    node.parentNode?.removeChild(node);
+  }
+  const current = Array.from(parent.childNodes);
+  for (let i2 = 0; i2 < current.length; i2++) {
+    dispose(current[i2]);
+  }
+  parent.replaceChildren(...next);
+}
 
 // src/ui/transition.ts
 function transition(element, options = {}) {
@@ -4811,7 +5507,9 @@ function TransitionGroup(options) {
 // src/ui/viewTransition.ts
 function viewTransition(callback) {
   const [isTransitioning, setIsTransitioning] = signal(false);
+  let inflight = 0;
   async function start() {
+    inflight++;
     setIsTransitioning(true);
     try {
       if (typeof document !== "undefined" && "startViewTransition" in document && typeof document.startViewTransition === "function") {
@@ -4821,7 +5519,11 @@ function viewTransition(callback) {
         await callback();
       }
     } finally {
-      setIsTransitioning(false);
+      inflight--;
+      if (inflight <= 0) {
+        inflight = 0;
+        setIsTransitioning(false);
+      }
     }
   }
   return { start, isTransitioning };
@@ -4982,6 +5684,8 @@ function bindField(field, extras) {
     }
   };
   return {
+    // The field's own getter, no longer widened to `unknown` — that widening is
+    // what forced every consumer to cast. (TYPE-010)
     value: field.value,
     on: mergedOn,
     onElement,
@@ -5534,7 +6238,7 @@ function announce(message, priority = "polite") {
 
 // src/ui/scopedStyle.ts
 var _scope = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.scopedStyle.v1"), () => ({ n: 0 }));
-function decodeCssEscapes(css) {
+function decodeCssEscapes2(css) {
   return css.replace(/\\([0-9a-f]{1,6})[ \t\n\r\f]?|\\([^\n])/gi, (_match, hex, ch) => {
     if (hex) {
       const code2 = Number.parseInt(hex, 16);
@@ -5551,7 +6255,7 @@ function decodeCssEscapes(css) {
   });
 }
 function sanitizeCSS(css) {
-  let sanitized = decodeCssEscapes(css);
+  let sanitized = decodeCssEscapes2(css);
   sanitized = sanitized.replace(/@import\s+[^;]+;/gi, "/* @import removed */");
   sanitized = sanitized.replace(/url\s*\(\s*(?:"[^"]*"|'[^']*'|[^)]*)\s*\)/gi, "/* url() removed */");
   sanitized = sanitized.replace(/expression\s*\(\s*(?:"[^"]*"|'[^']*'|[^)]*)\s*\)/gi, "/* expression() removed */");
@@ -5559,21 +6263,169 @@ function sanitizeCSS(css) {
   sanitized = sanitized.replace(/behavior\s*:[^;]+;/gi, "/* behavior removed */");
   return sanitized;
 }
+function firstCompoundEnd(selector) {
+  let parens = 0;
+  let brackets = 0;
+  let quote = null;
+  for (let i2 = 0; i2 < selector.length; i2++) {
+    const ch = selector[i2];
+    if (quote) {
+      if (ch === "\\") i2++;
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "\\") {
+      i2++;
+      continue;
+    }
+    if (ch === "(") parens++;
+    else if (ch === ")") parens--;
+    else if (ch === "[") brackets++;
+    else if (ch === "]") brackets--;
+    if (parens > 0 || brackets > 0) continue;
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f") return i2;
+    if (ch === ">" || ch === "+" || ch === "~") return i2;
+    if (ch === ":" && selector[i2 + 1] === ":") return i2;
+  }
+  return selector.length;
+}
+function scopeSelector(selector, attr) {
+  const end = firstCompoundEnd(selector);
+  const selfForm = `${selector.slice(0, end)}[${attr}]${selector.slice(end)}`;
+  const descendantForm = `[${attr}] ${selector}`;
+  return `${descendantForm}, ${selfForm}`;
+}
+function skipNonCode(text2, i2) {
+  const ch = text2[i2];
+  if (ch === "\\") return i2 + 2;
+  if (ch === '"' || ch === "'") {
+    let j = i2 + 1;
+    while (j < text2.length) {
+      if (text2[j] === "\\") {
+        j += 2;
+        continue;
+      }
+      if (text2[j] === ch) return j + 1;
+      j++;
+    }
+    return text2.length;
+  }
+  if (ch === "/" && text2[i2 + 1] === "*") {
+    const end = text2.indexOf("*/", i2 + 2);
+    return end === -1 ? text2.length : end + 2;
+  }
+  return -1;
+}
+function splitSelectorList(prelude) {
+  const parts = [];
+  let parens = 0;
+  let brackets = 0;
+  let start = 0;
+  for (let i2 = 0; i2 < prelude.length; i2++) {
+    const skip = skipNonCode(prelude, i2);
+    if (skip !== -1) {
+      i2 = skip - 1;
+      continue;
+    }
+    const ch = prelude[i2];
+    if (ch === "(") parens++;
+    else if (ch === ")") parens--;
+    else if (ch === "[") brackets++;
+    else if (ch === "]") brackets--;
+    else if (ch === "," && parens === 0 && brackets === 0) {
+      parts.push(prelude.slice(start, i2));
+      start = i2 + 1;
+    }
+  }
+  parts.push(prelude.slice(start));
+  return parts;
+}
+function findBlockEnd(css, openBrace) {
+  let depth = 0;
+  for (let i2 = openBrace; i2 < css.length; i2++) {
+    const skip = skipNonCode(css, i2);
+    if (skip !== -1) {
+      i2 = skip - 1;
+      continue;
+    }
+    const ch = css[i2];
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return i2;
+    }
+  }
+  return css.length;
+}
+var NESTED_AT_RULE = /^@(media|supports|layer|container|scope|document)\b/i;
+function scopeStylesheet(css, attr) {
+  let out = "";
+  let preludeStart = 0;
+  let parens = 0;
+  let brackets = 0;
+  let i2 = 0;
+  while (i2 < css.length) {
+    const skip = skipNonCode(css, i2);
+    if (skip !== -1) {
+      i2 = skip;
+      continue;
+    }
+    const ch = css[i2];
+    if (ch === "(") {
+      parens++;
+      i2++;
+      continue;
+    }
+    if (ch === ")") {
+      parens--;
+      i2++;
+      continue;
+    }
+    if (ch === "[") {
+      brackets++;
+      i2++;
+      continue;
+    }
+    if (ch === "]") {
+      brackets--;
+      i2++;
+      continue;
+    }
+    if (ch === "{" && parens === 0 && brackets === 0) {
+      const prelude = css.slice(preludeStart, i2);
+      const bodyEnd = findBlockEnd(css, i2);
+      const body2 = css.slice(i2 + 1, bodyEnd);
+      const trimmed = prelude.trim();
+      const lead = prelude.slice(0, prelude.length - prelude.trimStart().length);
+      if (trimmed === "") {
+        out += `${prelude}{${body2}}`;
+      } else if (trimmed.startsWith("@")) {
+        out += NESTED_AT_RULE.test(trimmed) ? `${prelude}{${scopeStylesheet(body2, attr)}}` : `${prelude}{${body2}}`;
+      } else {
+        const scoped = splitSelectorList(trimmed).map((part) => {
+          const selector = part.trim();
+          return selector ? scopeSelector(selector, attr) : part;
+        }).join(", ");
+        out += `${lead}${scoped}{${body2}}`;
+      }
+      i2 = bodyEnd + 1;
+      preludeStart = i2;
+      continue;
+    }
+    i2++;
+  }
+  out += css.slice(preludeStart);
+  return out;
+}
 function scopedStyle(css) {
   const id = `sibu-s${_scope.n++}`;
   const attr = `data-${id}`;
   const safeCss = sanitizeCSS(css);
-  const scopedCSS = safeCss.replace(/([^\r\n,{}]+)(,(?=[^}]*{)|\s*{)/g, (match, selector, delimiter) => {
-    const trimmed = selector.trim();
-    if (trimmed.startsWith("@") || trimmed.startsWith("from") || trimmed.startsWith("to") || /^\d+%$/.test(trimmed)) {
-      return match;
-    }
-    const pseudoIdx = trimmed.indexOf("::");
-    if (pseudoIdx >= 0) {
-      return `${trimmed.slice(0, pseudoIdx)}[${attr}]${trimmed.slice(pseudoIdx)}${delimiter}`;
-    }
-    return `${trimmed}[${attr}]${delimiter}`;
-  });
+  const scopedCSS = scopeStylesheet(safeCss, attr);
   if (typeof document !== "undefined") {
     const styleEl = document.createElement("style");
     styleEl.setAttribute("data-sibu-scope", id);
@@ -5589,34 +6441,95 @@ function withScopedStyle(css, component) {
       style2 = scopedStyle(css);
     }
     const el = component(props);
-    applyScopeRecursive(el, style2.attr);
+    el.setAttribute(style2.attr, "");
     return el;
   };
 }
-function applyScopeRecursive(element, attr) {
-  element.setAttribute(attr, "");
-  for (const child of Array.from(element.children)) {
-    if (child instanceof HTMLElement) {
-      applyScopeRecursive(child, attr);
-    }
-  }
-}
 function removeScopedStyle(scopeId) {
   const el = document.head.querySelector(`style[data-sibu-scope="${scopeId}"]`);
   if (el) el.remove();
 }
 
-// src/reactivity/bindAttribute.ts
+// src/utils/setSafeAttribute.ts
 var _isDev6 = isDev();
+var HTML_NS = "http://www.w3.org/1999/xhtml";
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+var XML_NS = "http://www.w3.org/XML/1998/namespace";
+var BOOLEAN_IDL_ATTRS = /* @__PURE__ */ new Set(["checked", "disabled", "selected"]);
+function isHtmlElement(el) {
+  return el.namespaceURI === null || el.namespaceURI === HTML_NS;
+}
 function setProp(el, key, val) {
   el[key] = val;
 }
-function bindAttribute(el, attr, getter) {
-  if (isEventHandlerAttr(attr)) {
-    if (_isDev6)
+function namespaceFor(el, name) {
+  if (el.namespaceURI !== SVG_NS) return null;
+  const lower = name.toLowerCase();
+  if (lower.startsWith("xlink:")) return XLINK_NS;
+  if (lower.startsWith("xml:")) return XML_NS;
+  return null;
+}
+function setSafeAttribute(el, name, value, options = {}) {
+  const ns = namespaceFor(el, name);
+  const localName = ns ? name.slice(name.indexOf(":") + 1) : name;
+  if (isEventHandlerAttr(name)) {
+    if (_isDev6) {
+      devWarn(
+        `${options.label ?? "setSafeAttribute"}: refusing to set event-handler attribute "${name}". Its value would be evaluated as JavaScript. Use on:{ ${name.slice(2)}: fn } instead.`
+      );
+    }
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
+  if (value == null) {
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return true;
+  }
+  if (isHtmlContentAttribute(name)) {
+    if (_isDev6) {
       devWarn(
-        `bindAttribute: refusing to bind event-handler attribute "${attr}". Use on:{ ${attr.slice(2)}: fn } instead.`
+        `${options.label ?? "setSafeAttribute"}: refusing to set "${name}". The browser parses this attribute as a nested HTML document, so a generic string value cannot be made safe \u2014 attribute escaping is undone before the parse. Build the frame's content another way.`
       );
+    }
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
+  const html2 = isHtmlElement(el);
+  const idlName = html2 ? name.toLowerCase() : name;
+  if (typeof value === "boolean") {
+    if (html2 && BOOLEAN_IDL_ATTRS.has(idlName) && idlName in el) {
+      setProp(el, idlName, value);
+    } else if (value) {
+      if (ns) el.setAttributeNS(ns, name, "");
+      else el.setAttribute(name, "");
+    } else if (ns) {
+      el.removeAttributeNS(ns, localName);
+    } else {
+      el.removeAttribute(name);
+    }
+    return true;
+  }
+  const str = String(value);
+  if (options.syncValueProperty !== false && html2 && (idlName === "value" || idlName === "checked") && idlName in el) {
+    setProp(el, idlName, idlName === "checked" ? Boolean(value) : str);
+    return true;
+  }
+  const safe = sanitizeAttributeString(name, str);
+  const current = ns ? el.getAttributeNS(ns, localName) : el.getAttribute(name);
+  if (current === safe) return true;
+  if (ns) el.setAttributeNS(ns, name, safe);
+  else el.setAttribute(name, safe);
+  return true;
+}
+
+// src/reactivity/bindAttribute.ts
+function bindAttribute(el, attr, getter) {
+  if (isEventHandlerAttr(attr)) {
+    setSafeAttribute(el, attr, "", { label: `bindAttribute("${attr}")` });
     return () => {
     };
   }
@@ -5625,28 +6538,12 @@ function bindAttribute(el, attr, getter) {
     try {
       value = getter();
     } catch (err) {
-      if (_isDev6)
-        devWarn(`bindAttribute: getter for "${attr}" threw: ${err instanceof Error ? err.message : String(err)}`);
+      reportError(err, { phase: "binding", name: `bindAttribute("${attr}")`, node: el });
       return;
     }
-    if (typeof value === "boolean") {
-      if (attr in el && (attr === "checked" || attr === "disabled" || attr === "selected")) {
-        setProp(el, attr, value);
-      } else if (value) {
-        el.setAttribute(attr, "");
-      } else {
-        el.removeAttribute(attr);
-      }
-      return;
-    }
-    const str = String(value);
-    if ((attr === "value" || attr === "checked") && attr in el) {
-      setProp(el, attr, attr === "checked" ? Boolean(value) : str);
-    } else {
-      el.setAttribute(attr, sanitizeAttributeString(attr, str));
-    }
+    setSafeAttribute(el, attr, value, { label: `bindAttribute("${attr}")` });
   }
-  return reactiveBinding2(commit);
+  return reactiveBinding2(commit, el);
 }
 
 // src/ui/reactiveAttr.ts
@@ -5656,14 +6553,8 @@ function bindAttrs(el, attrs) {
     if (typeof value === "function") {
       const teardown = bindAttribute(el, attr, value);
       teardowns.push(teardown);
-    } else if (typeof value === "boolean") {
-      if (value) {
-        el.setAttribute(attr, "");
-      } else {
-        el.removeAttribute(attr);
-      }
     } else {
-      el.setAttribute(attr, String(value));
+      setSafeAttribute(el, attr, value, { label: "bindAttrs" });
     }
   }
   return () => {
@@ -5674,11 +6565,7 @@ function bindAttrs(el, attrs) {
 }
 function bindBoolAttr(el, attr, getter) {
   if (typeof getter !== "function") {
-    if (getter) {
-      el.setAttribute(attr, "");
-    } else {
-      el.removeAttribute(attr);
-    }
+    setSafeAttribute(el, attr, getter, { label: "bindBoolAttr" });
     return () => {
     };
   }
@@ -5690,11 +6577,7 @@ function bindBoolAttr(el, attr, getter) {
     } catch {
       return;
     }
-    if (value) {
-      el.setAttribute(attr, "");
-    } else {
-      el.removeAttribute(attr);
-    }
+    setSafeAttribute(el, attr, Boolean(value), { label: "bindBoolAttr" });
   }
   const teardown = track2(commit);
   return teardown;
@@ -5702,7 +6585,7 @@ function bindBoolAttr(el, attr, getter) {
 function bindData(el, key, getter) {
   const dataAttr = `data-${key}`;
   if (typeof getter !== "function") {
-    el.setAttribute(dataAttr, String(getter));
+    setSafeAttribute(el, dataAttr, getter, { label: "bindData" });
     return () => {
     };
   }
@@ -5842,31 +6725,58 @@ function infiniteScroll(options) {
   const sentinelRef = { current: null };
   let observer = null;
   let disposed = false;
+  let generation = 0;
+  function safeHasMore() {
+    try {
+      return hasMore();
+    } catch (err) {
+      reportError(err, { phase: "async", name: "infiniteScroll(hasMore)" });
+      return false;
+    }
+  }
+  function ownsAttachment(owner) {
+    return !disposed && generation === owner.generation && observer === owner.observer && _current === owner.sentinel;
+  }
   function createObserver() {
     if (typeof IntersectionObserver === "undefined") return;
-    observer = new IntersectionObserver(
+    let createdObserver;
+    createdObserver = new IntersectionObserver(
       (entries) => {
         const entry = entries[0];
-        if (entry?.isIntersecting && !loading() && hasMore() && !disposed) {
-          loadMore();
-        }
+        if (!entry?.isIntersecting) return;
+        const sentinel = _current;
+        if (!sentinel) return;
+        const owner = { generation, observer: createdObserver, sentinel };
+        if (!ownsAttachment(owner) || loading()) return;
+        const shouldLoad = safeHasMore();
+        if (!shouldLoad || !ownsAttachment(owner)) return;
+        void loadMore(owner);
       },
       { threshold }
     );
+    observer = createdObserver;
     if (sentinelRef.current) {
-      observer.observe(sentinelRef.current);
+      createdObserver.observe(sentinelRef.current);
     }
   }
-  async function loadMore() {
-    setLoading(true);
+  async function loadMore(owner) {
     try {
-      await onLoadMore();
-    } finally {
-      setLoading(false);
-      if (!disposed && observer && _current && hasMore()) {
-        observer.unobserve(_current);
-        observer.observe(_current);
+      setLoading(true);
+      if (!ownsAttachment(owner)) return;
+      try {
+        await onLoadMore();
+      } catch (err) {
+        reportError(err, { phase: "async", name: "infiniteScroll(onLoadMore)" });
       }
+      if (!ownsAttachment(owner)) return;
+      setLoading(false);
+      if (!ownsAttachment(owner)) return;
+      const shouldContinue = safeHasMore();
+      if (!shouldContinue || !ownsAttachment(owner)) return;
+      owner.observer.unobserve(owner.sentinel);
+      owner.observer.observe(owner.sentinel);
+    } catch (err) {
+      reportError(err, { phase: "async", name: "infiniteScroll(loadMore)" });
     }
   }
   const originalRef = sentinelRef;
@@ -5876,7 +6786,10 @@ function infiniteScroll(options) {
       return _current;
     },
     set(el) {
+      if (el === _current) return;
       _current = el;
+      generation++;
+      setLoading(false);
       if (observer) {
         observer.disconnect();
         observer = null;
@@ -5889,10 +6802,12 @@ function infiniteScroll(options) {
   });
   function dispose2() {
     disposed = true;
+    generation++;
     if (observer) {
       observer.disconnect();
       observer = null;
     }
+    setLoading(false);
   }
   return { sentinelRef: originalRef, loading, dispose: dispose2 };
 }
@@ -6214,7 +7129,7 @@ var DOMPool = class {
       this.pools.set(tag, pool);
     }
     if (pool.length >= this.maxSize) return;
-    element.innerHTML = "";
+    replaceChildrenSafely(element);
     element.className = "";
     element.removeAttribute("style");
     element.removeAttribute("id");
@@ -6313,29 +7228,178 @@ function noSideEffect(fn) {
   return fn;
 }
 
+// src/utils/metaRefresh.ts
+function isAsciiWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f";
+}
+function trimAsciiWhitespace(value) {
+  let start = 0;
+  let end = value.length;
+  while (start < end && isAsciiWhitespace(value[start])) start++;
+  while (end > start && isAsciiWhitespace(value[end - 1])) end--;
+  return value.slice(start, end);
+}
+var forbidden = (reason) => ({ kind: "forbidden", reason });
+function parseMetaRefreshContent(content) {
+  const raw = trimAsciiWhitespace(stripControlChars(content));
+  if (raw === "") return forbidden("empty content");
+  let i2 = 0;
+  while (i2 < raw.length && raw[i2] >= "0" && raw[i2] <= "9") i2++;
+  if (i2 === 0) return forbidden("missing or non-numeric delay");
+  const delay = Number.parseInt(raw.slice(0, i2), 10);
+  if (!Number.isFinite(delay)) return forbidden("unparseable delay");
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  if (i2 === raw.length) return { kind: "delay-only", delay };
+  if (raw[i2] !== ";" && raw[i2] !== ",") return forbidden("unexpected text after delay");
+  i2++;
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  const keyStart = i2;
+  while (i2 < raw.length && !isAsciiWhitespace(raw[i2]) && raw[i2] !== "=") i2++;
+  const key = raw.slice(keyStart, i2).toLowerCase();
+  if (key !== "url") return forbidden(`unsupported refresh key ${JSON.stringify(key)}`);
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  if (raw[i2] !== "=") return forbidden("missing '=' after url");
+  i2++;
+  while (i2 < raw.length && isAsciiWhitespace(raw[i2])) i2++;
+  let destination;
+  const quote = raw[i2];
+  if (quote === '"' || quote === "'") {
+    const close = raw.indexOf(quote, i2 + 1);
+    if (close === -1) return forbidden("unterminated quoted destination");
+    destination = raw.slice(i2 + 1, close);
+    const rest = trimAsciiWhitespace(raw.slice(close + 1));
+    if (rest !== "") return forbidden("trailing text after quoted destination");
+  } else {
+    destination = trimAsciiWhitespace(raw.slice(i2));
+    if (/[;,]/.test(destination)) return forbidden("multiple refresh assignments");
+  }
+  if (destination === "") return forbidden("empty destination");
+  const sanitizedDestination = sanitizeUrl(destination);
+  if (sanitizedDestination === "") return forbidden("destination uses a disallowed protocol");
+  return { kind: "allowed", delay, destination, sanitizedDestination };
+}
+function resolveMetaRefreshPolicy(attributes) {
+  let httpEquiv;
+  let content;
+  let duplicateName;
+  const seen = /* @__PURE__ */ new Set();
+  for (const [key, value] of attributes) {
+    const canonical = canonicalAttrName(key);
+    if (seen.has(canonical)) duplicateName = canonical;
+    seen.add(canonical);
+    if (canonical === "http-equiv") httpEquiv = value;
+    else if (canonical === "content") content = value;
+  }
+  if (duplicateName !== void 0) {
+    return forbidden(`duplicate case-insensitive attribute ${JSON.stringify(duplicateName)}`);
+  }
+  if (typeof httpEquiv !== "string") return { kind: "not-refresh" };
+  if (trimAsciiWhitespace(stripControlChars(httpEquiv)).toLowerCase() !== "refresh") {
+    return { kind: "not-refresh" };
+  }
+  if (typeof content !== "string") return { kind: "not-refresh" };
+  return parseMetaRefreshContent(content);
+}
+function normalizeMetaAttributes(props) {
+  const out = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(props)) {
+    const canonical = canonicalAttrName(key);
+    if (seen.has(canonical)) return null;
+    seen.add(canonical);
+    out.set(key, props[key]);
+  }
+  return out;
+}
+function isForbiddenMetaEntry(props) {
+  const normalized = normalizeMetaAttributes(props);
+  if (normalized === null) return true;
+  return resolveMetaRefreshPolicy(normalized).kind === "forbidden";
+}
+
+// src/utils/headEntry.ts
+var SAFE_HEAD_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
+function isEmittableHeadAttrName(name) {
+  if (!SAFE_HEAD_ATTR_NAME.test(name)) return false;
+  const canonical = canonicalAttrName(name);
+  if (isEventHandlerAttr(canonical)) return false;
+  if (isHtmlContentAttribute(canonical)) return false;
+  return true;
+}
+function sanitizeHeadAttrValue(canonical, value) {
+  if (!isPolicyAttribute(canonical)) return value;
+  const safe = sanitizeAttributeString(canonical, value);
+  return safe === "" ? null : safe;
+}
+function findDuplicateAttributeName(names) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const canonical = canonicalAttrName(name);
+    if (seen.has(canonical)) return canonical;
+    seen.add(canonical);
+  }
+  return null;
+}
+function planEntry(props, resolver, applyRefreshPolicy) {
+  const rawNames = Object.keys(props);
+  const duplicate = findDuplicateAttributeName(rawNames);
+  if (duplicate !== null) {
+    return { kind: "drop", reason: `duplicate case-insensitive attribute ${JSON.stringify(duplicate)}` };
+  }
+  const attributes = /* @__PURE__ */ new Map();
+  let reactive = false;
+  for (const name of rawNames) {
+    if (!Object.hasOwn(props, name)) continue;
+    if (!isEmittableHeadAttrName(name)) continue;
+    const authored = props[name];
+    if (resolver.isReactiveValue?.(authored)) reactive = true;
+    const canonical = canonicalAttrName(name);
+    const sanitized = sanitizeHeadAttrValue(canonical, resolver.resolveValue(name, authored));
+    if (sanitized === null) continue;
+    attributes.set(canonical, sanitized);
+  }
+  if (attributes.size === 0) return { kind: "drop", reason: "no effective attributes remain" };
+  const refresh = applyRefreshPolicy ? resolveMetaRefreshPolicy(attributes) : { kind: "not-refresh" };
+  if (refresh.kind === "forbidden") return { kind: "drop", reason: refresh.reason };
+  if (reactive && (refresh.kind === "allowed" || refresh.kind === "delay-only")) {
+    return { kind: "drop", reason: "a reactive meta entry may not publish a native refresh directive" };
+  }
+  return { kind: "publish", attributes, refresh };
+}
+function planMetaEntry(props, resolver) {
+  return planEntry(props, resolver, true);
+}
+function planHeadElementEntry(props, resolver) {
+  return planEntry(props, resolver, false);
+}
+var STATIC_VALUE_RESOLVER = {
+  resolveValue: (_name, value) => String(value)
+};
+function escapeHeadAttrValue(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function serializeHeadEntry(tag, attrs) {
+  const plan = tag === "meta" ? planMetaEntry(attrs, STATIC_VALUE_RESOLVER) : planHeadElementEntry(attrs, STATIC_VALUE_RESOLVER);
+  if (plan.kind === "drop") return "";
+  const pairs = Array.from(plan.attributes, ([name, value]) => `${name}="${escapeHeadAttrValue(value)}"`).join(" ");
+  return `<${tag} ${pairs} />`;
+}
+
 // src/platform/ssr.ts
-function sanitizeUrlAttr(name, value) {
-  return name === "srcset" ? sanitizeSrcset(value) : sanitizeUrl(value);
+function isPolicyAttr(lowerName) {
+  return isPolicyAttribute(lowerName);
+}
+function isForbiddenSsrAttr(lowerName) {
+  return isHtmlContentAttribute(lowerName);
+}
+function sanitizeSsrAttributeValue(lowerName, value) {
+  return sanitizeAttributeString(lowerName, value);
 }
 var _isDev8 = isDev();
 var SAFE_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
 function isSafeAttrName(name) {
   return SAFE_ATTR_NAME.test(name);
 }
-var URL_ATTRS = /* @__PURE__ */ new Set([
-  "href",
-  "src",
-  "action",
-  "formaction",
-  "cite",
-  "poster",
-  "background",
-  "srcset",
-  "ping",
-  "manifest",
-  "data",
-  "xlink:href"
-]);
 function ssrErrorComment(err) {
   if (_isDev8) {
     const msg = escapeHtml(err instanceof Error ? err.message : String(err));
@@ -6393,10 +7457,11 @@ function renderToString(element) {
     const rawName = attr.name;
     if (!isSafeAttrName(rawName)) continue;
     if (isEventHandlerAttr(rawName)) continue;
+    if (isForbiddenSsrAttr(rawName)) continue;
     const lowerName = rawName.toLowerCase();
     let value = attr.value;
-    if (URL_ATTRS.has(lowerName)) {
-      value = sanitizeUrlAttr(lowerName, value);
+    if (isPolicyAttr(lowerName)) {
+      value = sanitizeSsrAttributeValue(lowerName, value);
       if (!value) continue;
     }
     html2 += ` ${rawName}="${escapeAttr(value)}"`;
@@ -6437,9 +7502,20 @@ function hydrate(component, container, options = {}) {
       }
     }
   }
-  container.replaceChildren(clientTree);
+  replaceChildrenSafely(container, clientTree);
   container.setAttribute("data-sibu-hydrated", "true");
 }
+function directTextOf(node) {
+  let out = "";
+  for (const child of Array.from(node.childNodes)) {
+    if (child.nodeType === 3) out += child.nodeValue ?? "";
+  }
+  return out.replace(/\s+/g, " ").trim();
+}
+function disposeAndReplace(outgoing, next) {
+  dispose(outgoing);
+  outgoing.replaceWith(next);
+}
 function collectMismatches(serverNode, clientNode, path2, out, max2 = 5) {
   if (out.length >= max2) return;
   const nodePath = path2 || clientNode?.tagName?.toLowerCase() || "(root)";
@@ -6515,6 +7591,18 @@ function collectMismatches(serverNode, clientNode, path2, out, max2 = 5) {
       });
     }
   }
+  const serverText = directTextOf(serverNode);
+  const clientText = directTextOf(clientNode);
+  if (serverText !== clientText) {
+    out.push({
+      kind: "text",
+      path: nodePath,
+      serverValue: serverText,
+      clientValue: clientText,
+      message: "Text content differs between server and client."
+    });
+    if (out.length >= max2) return;
+  }
   const serverChildren = Array.from(serverNode.children);
   const clientChildren = Array.from(clientNode.children);
   const max22 = Math.max(serverChildren.length, clientChildren.length);
@@ -6534,10 +7622,11 @@ function buildAttrString(attrs, { allowEventHandlers = false } = {}) {
     if (!Object.hasOwn(attrs, rawKey)) continue;
     if (!isSafeAttrName(rawKey)) continue;
     if (!allowEventHandlers && isEventHandlerAttr(rawKey)) continue;
+    if (isForbiddenSsrAttr(rawKey)) continue;
     const lowerKey = rawKey.toLowerCase();
     let value = String(attrs[rawKey]);
-    if (URL_ATTRS.has(lowerKey)) {
-      value = sanitizeUrlAttr(lowerKey, value);
+    if (isPolicyAttr(lowerKey)) {
+      value = sanitizeSsrAttributeValue(lowerKey, value);
       if (!value) continue;
     }
     out.push(`${rawKey}="${escapeAttr(value)}"`);
@@ -6545,18 +7634,7 @@ function buildAttrString(attrs, { allowEventHandlers = false } = {}) {
   return out.join(" ");
 }
 function isDangerousMetaRefresh(metaProps) {
-  let httpEquiv;
-  let content;
-  for (const k in metaProps) {
-    const lk = k.toLowerCase();
-    if (lk === "http-equiv") httpEquiv = metaProps[k];
-    else if (lk === "content") content = metaProps[k];
-  }
-  if (typeof httpEquiv !== "string") return false;
-  if (httpEquiv.toLowerCase() !== "refresh") return false;
-  if (typeof content !== "string") return false;
-  const normalized = stripControlChars(content).toLowerCase();
-  return normalized.includes("url=javascript:") || normalized.includes("url=data:") || normalized.includes("url=vbscript:") || normalized.includes("url=blob:");
+  return isForbiddenMetaEntry(metaProps);
 }
 function renderToDocument(component, options = {}) {
   let content;
@@ -6565,15 +7643,8 @@ function renderToDocument(component, options = {}) {
   } catch (err) {
     content = ssrErrorComment(err);
   }
-  const metaTags = (options.meta || []).map((attrs) => {
-    if (isDangerousMetaRefresh(attrs)) return "";
-    const pairs = buildAttrString(attrs);
-    return pairs ? `<meta ${pairs} />` : "";
-  }).filter(Boolean).join("\n    ");
-  const linkTags = (options.links || []).map((attrs) => {
-    const pairs = buildAttrString(attrs);
-    return pairs ? `<link ${pairs} />` : "";
-  }).filter(Boolean).join("\n    ");
+  const metaTags = (options.meta || []).map((attrs) => serializeHeadEntry("meta", attrs)).filter(Boolean).join("\n    ");
+  const linkTags = (options.links || []).map((attrs) => serializeHeadEntry("link", attrs)).filter(Boolean).join("\n    ");
   const scriptTags = (options.scripts || []).map((src) => {
     const safe = sanitizeUrl(String(src));
     if (!safe) return "";
@@ -6634,14 +7705,18 @@ async function* renderToStream(element) {
     const rawName = attr.name;
     if (!isSafeAttrName(rawName)) continue;
     if (isEventHandlerAttr(rawName)) continue;
+    if (isForbiddenSsrAttr(rawName)) continue;
     const lowerName = rawName.toLowerCase();
     let value = attr.value;
-    if (URL_ATTRS.has(lowerName)) {
-      value = sanitizeUrlAttr(lowerName, value);
+    if (isPolicyAttr(lowerName)) {
+      value = sanitizeSsrAttributeValue(lowerName, value);
       if (!value) continue;
     }
     openTag += ` ${rawName}="${escapeAttr(value)}"`;
   }
+  if (element.dataset && !element.dataset.sibuHydrate) {
+    openTag += ` data-sibu-ssr="true"`;
+  }
   if (VOID_ELEMENTS.has(tag)) {
     yield `${openTag} />`;
     return;
@@ -6688,9 +7763,13 @@ function island(id, component) {
   el.setAttribute("data-sibu-island", id);
   return el;
 }
+function isAlreadyHydrated(element) {
+  return element.hasAttribute("data-sibu-hydrated");
+}
 function hydrateIslands(container, islands) {
   const markers = container.querySelectorAll("[data-sibu-island]");
   for (const marker2 of Array.from(markers)) {
+    if (isAlreadyHydrated(marker2)) continue;
     const id = marker2.getAttribute("data-sibu-island") ?? "";
     if (!Object.hasOwn(islands, id)) continue;
     const factory = islands[id];
@@ -6698,7 +7777,7 @@ function hydrateIslands(container, islands) {
     const clientTree = factory();
     clientTree.setAttribute("data-sibu-island", id);
     clientTree.setAttribute("data-sibu-hydrated", "true");
-    marker2.replaceWith(clientTree);
+    disposeAndReplace(marker2, clientTree);
   }
   container.setAttribute("data-sibu-hydrated", "partial");
 }
@@ -6706,6 +7785,7 @@ function hydrateProgressively(container, islands, options) {
   const markers = container.querySelectorAll("[data-sibu-island]");
   const cleanups = [];
   for (const marker2 of Array.from(markers)) {
+    if (isAlreadyHydrated(marker2)) continue;
     const id = marker2.getAttribute("data-sibu-island") ?? "";
     if (!Object.hasOwn(islands, id)) continue;
     const factory = islands[id];
@@ -6715,10 +7795,11 @@ function hydrateProgressively(container, islands, options) {
         for (const entry of entries) {
           if (entry.isIntersecting) {
             observer.disconnect();
+            if (isAlreadyHydrated(marker2) || marker2.parentNode === null) break;
             const clientTree = factory();
             clientTree.setAttribute("data-sibu-island", id);
             clientTree.setAttribute("data-sibu-hydrated", "true");
-            marker2.replaceWith(clientTree);
+            disposeAndReplace(marker2, clientTree);
             break;
           }
         }
@@ -6774,7 +7855,7 @@ function suspenseSwapScript(id, nonce) {
     );
   }
   const nonceAttr = nonce ? ` nonce="${escapeAttr(nonce)}"` : "";
-  return `<script${nonceAttr}>(function(){var t=document.getElementById("sibu-resolved-${id}");var f=document.querySelector('[data-sibu-suspense-id="${id}"]');if(t&&f){while(t.firstChild)f.appendChild(t.firstChild);t.remove();f.removeAttribute("data-sibu-suspense-id");}})()</script>`;
+  return `<script${nonceAttr}>(function(){var t=document.getElementById("sibu-resolved-${id}");var f=document.querySelector('[data-sibu-suspense-id="${id}"]');if(t&&f){while(f.firstChild)f.removeChild(f.firstChild);while(t.firstChild)f.appendChild(t.firstChild);t.remove();f.removeAttribute("data-sibu-suspense-id");}})()</script>`;
 }
 async function* renderToSuspenseStream(element, pendingBoundaries = [], options) {
   yield* renderToStream(element);
@@ -6792,8 +7873,8 @@ function escapeScriptJson(json) {
   return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
 var DEFAULT_MAX_SSR_BYTES = 1024 * 1024;
-function serializeState(state, nonce, options) {
-  const rawJson = JSON.stringify(state);
+function serializeState(state2, nonce, options) {
+  const rawJson = JSON.stringify(state2);
   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) {
@@ -6855,8 +7936,9 @@ function normalizedStore(schema) {
     ids: [],
     entities: {}
   });
+  const idOf = (entity) => String(entity[idKey]);
   function add(entity) {
-    const id = String(entity[idKey]);
+    const id = idOf(entity);
     setState((prev) => {
       const ids = prev.ids.includes(id) ? prev.ids : [...prev.ids, id];
       return {
@@ -6870,7 +7952,7 @@ function normalizedStore(schema) {
       const nextIds = [...prev.ids];
       const nextEntities = { ...prev.entities };
       for (const entity of entities) {
-        const id = String(entity[idKey]);
+        const id = idOf(entity);
         if (!nextIds.includes(id)) {
           nextIds.push(id);
         }
@@ -6880,12 +7962,12 @@ function normalizedStore(schema) {
     });
   }
   function get(id) {
-    const state = getState();
-    return state.entities[id];
+    const state2 = getState();
+    return state2.entities[id];
   }
   function getAll() {
-    const state = getState();
-    return state.ids.map((id) => state.entities[id]);
+    const state2 = getState();
+    return state2.ids.map((id) => state2.entities[id]);
   }
   function update(id, partial) {
     setState((prev) => {
@@ -6911,8 +7993,8 @@ function normalizedStore(schema) {
     });
   }
   function select3(predicate) {
-    const state = getState();
-    return state.ids.map((id) => state.entities[id]).filter(predicate);
+    const state2 = getState();
+    return state2.ids.map((id) => state2.entities[id]).filter(predicate);
   }
   return { add, addMany, get, getAll, update, remove, select: select3, getState };
 }
@@ -6992,7 +8074,14 @@ function createChunkRegistry(config = {}) {
   } = config;
   const cache = /* @__PURE__ */ new Map();
   const pending = /* @__PURE__ */ new Map();
-  const preloaded = /* @__PURE__ */ new Set();
+  const preloaded = /* @__PURE__ */ new Map();
+  function notify(name, run) {
+    try {
+      run();
+    } catch (err) {
+      reportError(err, { phase: "async", name: `chunkRegistry(${name})` });
+    }
+  }
   function evict() {
     while (cache.size >= maxCacheSize) {
       let lru = null;
@@ -7047,30 +8136,47 @@ function createChunkRegistry(config = {}) {
       cached.lastAccess = Date.now();
       return cached.value;
     }
-    const pendingLoad = pending.get(id);
-    if (pendingLoad) return pendingLoad;
-    onLoadStart?.(id);
-    const loadPromise = loadWithRetry(id, loader).then((value) => {
-      evict();
-      const now = Date.now();
-      cache.set(id, { value, timestamp: now, lastAccess: now, accessCount: 1 });
-      pending.delete(id);
-      onLoadEnd?.(id);
-      return value;
-    }).catch((err) => {
-      pending.delete(id);
-      const error = err instanceof Error ? err : new Error(String(err));
-      onLoadError?.(id, error);
-      throw error;
+    const existing = pending.get(id);
+    if (existing) return existing.promise;
+    let resolveOuter;
+    let rejectOuter;
+    const outcome = new Promise((resolve, reject) => {
+      resolveOuter = resolve;
+      rejectOuter = reject;
     });
-    pending.set(id, loadPromise);
-    return loadPromise;
+    const entry = { promise: outcome };
+    pending.set(id, entry);
+    const owns = () => pending.get(id) === entry;
+    notify("onLoadStart", () => onLoadStart?.(id));
+    void loadWithRetry(id, loader).then(
+      (value) => {
+        if (owns()) {
+          pending.delete(id);
+          evict();
+          const now = Date.now();
+          cache.set(id, { value, timestamp: now, lastAccess: now, accessCount: 1 });
+        }
+        notify("onLoadEnd", () => onLoadEnd?.(id));
+        resolveOuter(value);
+      },
+      (err) => {
+        if (owns()) pending.delete(id);
+        const error = err instanceof Error ? err : new Error(String(err));
+        notify("onLoadError", () => onLoadError?.(id, error));
+        rejectOuter(error);
+      }
+    ).catch((internal) => {
+      reportError(internal, { phase: "async", name: "chunkRegistry(settlement)" });
+      rejectOuter(internal);
+    });
+    return outcome;
   }
   function preloadFn(id, loader) {
     if (cache.has(id) || pending.has(id) || preloaded.has(id)) return;
-    preloaded.add(id);
+    const marker2 = {};
+    preloaded.set(id, marker2);
     loadFn(id, loader).catch(() => {
-      preloaded.delete(id);
+      if (preloaded.get(id) === marker2) preloaded.delete(id);
     });
   }
   return {
@@ -7104,21 +8210,33 @@ function createChunkRegistry(config = {}) {
       return void 0;
     },
     /**
-     * Invalidate a cached chunk.
+     * Invalidate a cached chunk, and supersede any load still in flight for it.
+     *
+     * In-flight work is not cancelled — the loader API takes no abort signal, so
+     * claiming cancellation would be a lie. It is *superseded*: it still settles
+     * for whoever called `load()`, but it can no longer write to the cache, and
+     * a subsequent `load(id, …)` starts fresh work rather than adopting it.
      */
     invalidate(id) {
       cache.delete(id);
       preloaded.delete(id);
+      pending.delete(id);
     },
     /**
-     * Clear all cached chunks.
+     * Clear all cached chunks, and supersede every load still in flight.
+     *
+     * Same barrier as `invalidate`, applied to every key at once.
      */
     clear() {
       cache.clear();
       preloaded.clear();
+      pending.clear();
     },
     /**
      * Get cache statistics.
+     *
+     * Describes currently OWNED state: superseded loads are already absent from
+     * `pending`, so the counts never include work whose result will be discarded.
      */
     stats() {
       return {
@@ -7171,38 +8289,57 @@ function preloadModules(urls) {
 }
 
 // src/platform/head.ts
-var HEAD_URL_ATTRS = /* @__PURE__ */ new Set(["href", "src"]);
-function sanitizeHeadAttr(key, value) {
-  if (HEAD_URL_ATTRS.has(key)) return sanitizeUrl(value);
-  return value;
-}
-function isDangerousRefreshContent(content) {
-  const normalized = stripControlChars(content).toLowerCase();
-  return normalized.includes("url=javascript:") || normalized.includes("url=data:") || normalized.includes("url=vbscript:") || normalized.includes("url=blob:");
-}
-function getMetaAttr(metaProps, name) {
-  for (const k in metaProps) {
-    if (k.toLowerCase() === name) return metaProps[k];
-  }
-  return void 0;
-}
-function isDangerousMetaRefresh2(metaProps) {
-  const httpEquiv = getMetaAttr(metaProps, "http-equiv");
-  if (typeof httpEquiv !== "string") return false;
-  if (httpEquiv.toLowerCase() !== "refresh") return false;
-  const content = getMetaAttr(metaProps, "content");
-  if (typeof content !== "string") return false;
-  return isDangerousRefreshContent(content);
-}
-var SAFE_HEAD_ATTR_NAME = /^[A-Za-z_:][-A-Za-z0-9_.:]*$/;
-function isSafeHeadAttr(name) {
-  if (!SAFE_HEAD_ATTR_NAME.test(name)) return false;
-  if (isEventHandlerAttr(name)) return false;
-  return true;
-}
 function escapeScriptJsonLocal(json) {
   return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
+var CLIENT_RESOLVER = {
+  resolveValue: (_name, value) => typeof value === "function" ? String(value()) : String(value),
+  isReactiveValue: (value) => typeof value === "function"
+};
+function applyMetaEntry(metaProps, managedElements) {
+  let current = null;
+  const retract = () => {
+    if (!current) return;
+    const index = managedElements.indexOf(current);
+    if (index !== -1) managedElements.splice(index, 1);
+    current.remove();
+    current = null;
+  };
+  const alreadyPublished = (attributes) => {
+    if (!current || current.attributes.length !== attributes.size) return false;
+    for (const [name, value] of attributes) {
+      if (current.getAttribute(name) !== value) return false;
+    }
+    return true;
+  };
+  const publish = (attributes) => {
+    if (alreadyPublished(attributes)) return;
+    const next = document.createElement("meta");
+    for (const [name, value] of attributes) next.setAttribute(name, value);
+    const index = current ? managedElements.indexOf(current) : -1;
+    if (current?.parentNode) {
+      current.replaceWith(next);
+    } else {
+      current?.remove();
+      document.head.appendChild(next);
+    }
+    if (index !== -1) managedElements[index] = next;
+    else managedElements.push(next);
+    current = next;
+  };
+  const stopEffect = effect(() => {
+    const plan = planMetaEntry(metaProps, CLIENT_RESOLVER);
+    if (plan.kind === "drop") {
+      retract();
+      return;
+    }
+    publish(plan.attributes);
+  });
+  return () => {
+    stopEffect();
+    retract();
+  };
+}
 function Head(props) {
   const anchor = document.createComment("sibu-head");
   const managedElements = [];
@@ -7219,78 +8356,52 @@ function Head(props) {
     cleanup3();
     if (props.title) {
       if (typeof props.title === "function") {
-        const cleanupFn = effect(() => {
-          document.title = props.title();
+        const getter = props.title;
+        let lease = null;
+        const stopEffect = effect(() => {
+          const next = getter();
+          if (lease) lease.set(next);
+          else lease = acquireTitle(next);
+        });
+        effectCleanups.push(() => {
+          stopEffect();
+          lease?.release();
+          lease = null;
         });
-        effectCleanups.push(cleanupFn);
       } else {
-        document.title = props.title;
+        const lease = acquireTitle(props.title);
+        effectCleanups.push(() => lease.release());
       }
     }
     if (props.meta) {
       for (const metaProps of props.meta) {
-        if (isDangerousMetaRefresh2(metaProps)) continue;
-        const httpEquiv = getMetaAttr(metaProps, "http-equiv");
-        const isRefreshNow = () => {
-          const eq = typeof httpEquiv === "function" ? httpEquiv() : httpEquiv;
-          return typeof eq === "string" && eq.toLowerCase() === "refresh";
-        };
-        const el = document.createElement("meta");
-        for (const [key, value] of Object.entries(metaProps)) {
-          if (!isSafeHeadAttr(key)) continue;
-          const isContent = key.toLowerCase() === "content";
-          if (typeof value === "function") {
-            const cleanupFn = effect(() => {
-              const resolved = value();
-              if (isContent && isRefreshNow() && isDangerousRefreshContent(resolved)) {
-                el.removeAttribute(key);
-                return;
-              }
-              el.setAttribute(key, sanitizeHeadAttr(key, resolved));
-            });
-            effectCleanups.push(cleanupFn);
-          } else {
-            if (isContent && isRefreshNow() && isDangerousRefreshContent(value)) continue;
-            el.setAttribute(key, sanitizeHeadAttr(key, value));
-          }
-        }
-        document.head.appendChild(el);
-        managedElements.push(el);
-      }
-    }
-    if (props.link) {
-      for (const linkProps of props.link) {
-        const el = document.createElement("link");
-        for (const [key, value] of Object.entries(linkProps)) {
-          if (!isSafeHeadAttr(key)) continue;
-          el.setAttribute(key, sanitizeHeadAttr(key, value));
-        }
-        document.head.appendChild(el);
-        managedElements.push(el);
-      }
-    }
-    if (props.script) {
-      for (const scriptProps of props.script) {
-        const el = document.createElement("script");
-        for (const [key, value] of Object.entries(scriptProps)) {
-          if (!isSafeHeadAttr(key)) continue;
-          el.setAttribute(key, sanitizeHeadAttr(key, value));
-        }
+        const stop2 = applyMetaEntry(metaProps, managedElements);
+        effectCleanups.push(stop2);
+      }
+    }
+    for (const [tag, entries] of [
+      ["link", props.link],
+      ["script", props.script]
+    ]) {
+      if (!entries) continue;
+      for (const entryProps of entries) {
+        const plan = planHeadElementEntry(entryProps, STATIC_VALUE_RESOLVER);
+        if (plan.kind === "drop") continue;
+        const el = document.createElement(tag);
+        for (const [name, value] of plan.attributes) el.setAttribute(name, value);
         document.head.appendChild(el);
         managedElements.push(el);
       }
     }
     if (props.base) {
-      const existing = document.head.querySelector("base");
-      if (existing) existing.remove();
-      const el = document.createElement("base");
+      const spec = {};
       if (props.base.href) {
         const safeHref = sanitizeUrl(props.base.href);
-        if (safeHref) el.href = safeHref;
+        if (safeHref) spec.href = safeHref;
       }
-      if (props.base.target) el.target = props.base.target;
-      document.head.appendChild(el);
-      managedElements.push(el);
+      if (props.base.target) spec.target = props.base.target;
+      const lease = acquireBase(spec);
+      effectCleanups.push(() => lease.release());
     }
   };
   apply();
@@ -7313,10 +8424,13 @@ function setCanonical(url) {
     link2.rel = "canonical";
     document.head.appendChild(link2);
   }
-  link2.href = sanitizeUrl(url);
+  const safe = sanitizeUrl(url);
+  if (safe) link2.setAttribute("href", safe);
+  else link2.removeAttribute("href");
 }
 
 // src/platform/customElement.ts
+var SVG_NS2 = "http://www.w3.org/2000/svg";
 function defineElement(name, component, options = {}) {
   if (customElements.get(name)) return;
   const observed = options.observedAttributes || [];
@@ -7345,11 +8459,8 @@ function defineElement(name, component, options = {}) {
       }
     }
     _teardown() {
-      if (this._rendered) {
-        dispose(this._rendered);
-        this._rendered = null;
-      }
-      this._root.replaceChildren();
+      this._rendered = null;
+      replaceChildrenSafely(this._root);
     }
     _render() {
       this._teardown();
@@ -7374,14 +8485,13 @@ function defineElement(name, component, options = {}) {
   customElements.define(name, SibuElement);
 }
 function svgElement(tag, props = {}, ...nodes) {
-  const SVG_NS2 = "http://www.w3.org/2000/svg";
   const el = document.createElementNS(SVG_NS2, tag);
   for (const [key, value] of Object.entries(props)) {
     if (key === "nodes") continue;
-    if (typeof value === "function" && key.startsWith("on")) {
+    if (typeof value === "function" && isEventHandlerAttr(key)) {
       el.addEventListener(key.slice(2).toLowerCase(), value);
     } else if (value != null) {
-      el.setAttribute(key, String(value));
+      setSafeAttribute(el, key, value, { label: "svgElement" });
     }
   }
   for (const child of nodes) {
@@ -7617,22 +8727,34 @@ var instanceCache = globalSingleton(
   /* @__PURE__ */ Symbol.for("sibujs.wasm.instanceCache.v1"),
   () => /* @__PURE__ */ new Map()
 );
+var inFlightCache = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.wasm.inFlightCache.v1"),
+  () => /* @__PURE__ */ new Map()
+);
+var cacheState = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.wasm.cacheState.v1"), () => ({ generation: 0 }));
+function isCurrentGeneration(generation) {
+  return generation === cacheState.generation;
+}
 function wasm(source2, config = {}) {
   const [instance, setInstance] = signal(null);
   const [loading, setLoading] = signal(true);
   const [error, setError] = signal(null);
   const cacheKey = config.cacheKey || (typeof source2 === "string" ? source2 : void 0);
+  let runId = 0;
   async function load() {
+    const myRun = ++runId;
     setLoading(true);
     setError(null);
     setInstance(null);
     try {
-      const wasmInstance = await loadWasmModule(source2, config.imports, cacheKey);
+      const wasmInstance = await loadWasmModuleWithOptions(source2, { ...config, cacheKey });
+      if (myRun !== runId) return;
       setInstance(wasmInstance.exports);
     } catch (err) {
+      if (myRun !== runId) return;
       setError(err instanceof Error ? err : new Error(String(err)));
     } finally {
-      setLoading(false);
+      if (myRun === runId) setLoading(false);
     }
   }
   load();
@@ -7645,9 +8767,9 @@ function wasm(source2, config = {}) {
   };
 }
 async function loadWasmModule(source2, imports, cacheKey) {
-  const isOptionsBag = !!(imports && ("allowedOrigins" in imports || "unsafelyAllowAnyOrigin" in imports));
-  const opts = isOptionsBag ? imports : { imports, cacheKey };
-  const wasmImports = opts.imports;
+  return loadWasmModuleWithOptions(source2, { imports, cacheKey });
+}
+async function loadWasmModuleWithOptions(source2, opts = {}) {
   const key = opts.cacheKey || (typeof source2 === "string" ? source2 : void 0);
   if (typeof source2 === "string") {
     const allowed = opts.allowedOrigins ?? [];
@@ -7667,44 +8789,50 @@ async function loadWasmModule(source2, imports, cacheKey) {
       );
     }
   }
-  if (key) {
-    const cachedInstance = instanceCache.get(key);
-    if (cachedInstance) {
-      return cachedInstance;
-    }
-  }
-  let module2;
+  const generation = cacheState.generation;
+  if (!key) return instantiateWasm(source2, opts.imports, void 0, generation);
+  const cachedInstance = instanceCache.get(key);
+  if (cachedInstance) return cachedInstance;
+  const inFlight = inFlightCache.get(key);
+  if (inFlight) return inFlight;
+  const pending = instantiateWasm(source2, opts.imports, key, generation).then((instance) => {
+    if (isCurrentGeneration(generation)) instanceCache.set(key, instance);
+    return instance;
+  });
+  inFlightCache.set(key, pending);
+  void pending.catch(() => {
+  }).then(() => {
+    if (inFlightCache.get(key) === pending) inFlightCache.delete(key);
+  });
+  return pending;
+}
+async function instantiateWasm(source2, wasmImports, key, generation) {
   const cachedModule = key ? moduleCache.get(key) : void 0;
   if (cachedModule) {
-    module2 = cachedModule;
+    return WebAssembly.instantiate(cachedModule, wasmImports || {});
+  }
+  let bytes;
+  if (typeof source2 === "string") {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      const response2 = fetch(source2);
+      const result = await WebAssembly.instantiateStreaming(response2, wasmImports || {});
+      if (key && isCurrentGeneration(generation)) moduleCache.set(key, result.module);
+      return result.instance;
+    }
+    const response = await fetch(source2);
+    bytes = await response.arrayBuffer();
+  } else if (source2 instanceof Uint8Array) {
+    bytes = source2.buffer.slice(source2.byteOffset, source2.byteOffset + source2.byteLength);
   } else {
-    let bytes;
-    if (typeof source2 === "string") {
-      if (typeof WebAssembly.instantiateStreaming === "function") {
-        const response2 = fetch(source2);
-        const result = await WebAssembly.instantiateStreaming(response2, wasmImports || {});
-        if (key) {
-          moduleCache.set(key, result.module);
-          instanceCache.set(key, result.instance);
-        }
-        return result.instance;
-      }
-      const response = await fetch(source2);
-      bytes = await response.arrayBuffer();
-    } else if (source2 instanceof Uint8Array) {
-      bytes = source2.buffer.slice(source2.byteOffset, source2.byteOffset + source2.byteLength);
-    } else {
-      bytes = source2;
-    }
-    module2 = await WebAssembly.compile(bytes);
-    if (key) moduleCache.set(key, module2);
+    bytes = source2;
   }
-  const instance = await WebAssembly.instantiate(module2, wasmImports || {});
-  if (key) instanceCache.set(key, instance);
-  return instance;
+  const module2 = await WebAssembly.compile(bytes);
+  if (key && isCurrentGeneration(generation)) moduleCache.set(key, module2);
+  return WebAssembly.instantiate(module2, wasmImports || {});
 }
 async function preloadWasm(url, options = {}) {
   if (moduleCache.has(url)) return;
+  const generation = cacheState.generation;
   const allowed = options.allowedOrigins ?? [];
   if (allowed.length > 0) {
     let parsed;
@@ -7729,7 +8857,7 @@ async function preloadWasm(url, options = {}) {
     const bytes = await response.arrayBuffer();
     module2 = await WebAssembly.compile(bytes);
   }
-  moduleCache.set(url, module2);
+  if (isCurrentGeneration(generation)) moduleCache.set(url, module2);
 }
 function createWasmBridge(instance) {
   const exports2 = instance.exports;
@@ -7769,8 +8897,10 @@ function createWasmBridge(instance) {
   };
 }
 function clearWasmCache() {
+  cacheState.generation++;
   moduleCache.clear();
   instanceCache.clear();
+  inFlightCache.clear();
 }
 function isWasmCached(key) {
   return moduleCache.has(key);
@@ -7785,7 +8915,7 @@ function bindChildNode(placeholder, getter) {
     try {
       result = getter();
     } catch (err) {
-      if (_isDev9) devWarn(`bindChildNode: getter threw: ${err instanceof Error ? err.message : String(err)}`);
+      reportError(err, { phase: "binding", name: "bindChildNode", node: placeholder });
       return;
     }
     if (result == null || typeof result === "boolean") {
@@ -7846,11 +8976,11 @@ function bindChildNode(placeholder, getter) {
     }
     lastNodes = newNodes;
   }
-  return reactiveBinding2(commit);
+  return reactiveBinding2(commit, placeholder);
 }
 
 // src/core/rendering/tagFactory.ts
-var SVG_NS = "http://www.w3.org/2000/svg";
+var SVG_NS3 = "http://www.w3.org/2000/svg";
 var _isDev10 = isDev();
 var BLOCKED_TAGS = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed", "frame", "frameset"]);
 function isBlockedTag(tag) {
@@ -7869,9 +8999,6 @@ var CLOBBER_RISKY_IDS = /* @__PURE__ */ new Set([
   "self",
   "frames"
 ]);
-function setProp2(el, key, val) {
-  el[key] = val;
-}
 function looksLikeClassList(s2) {
   const t = s2.trim();
   if (!t) return false;
@@ -7895,13 +9022,13 @@ function toKebab(prop) {
 function applyStyle(el, style2) {
   if (typeof style2 === "function") {
     const teardown = track2(() => {
-      el.setAttribute("style", style2());
+      el.setAttribute("style", sanitizeStyleAttribute(String(style2())));
     });
     registerDisposer(el, teardown);
     return;
   }
   if (typeof style2 === "string") {
-    el.setAttribute("style", style2);
+    el.setAttribute("style", sanitizeStyleAttribute(style2));
     return;
   }
   const htmlEl = el;
@@ -8086,16 +9213,8 @@ var tagFactory = (tag, ns) => {
           if (isEventHandlerAttr(key)) continue;
           if (typeof value === "function") {
             registerDisposer(el, bindAttribute(el, key, value));
-          } else if (typeof value === "boolean") {
-            if (key in el && (key === "checked" || key === "disabled" || key === "selected")) {
-              setProp2(el, key, value);
-            } else if (value) {
-              el.setAttribute(key, "");
-            } else {
-              el.removeAttribute(key);
-            }
           } else {
-            el.setAttribute(key, sanitizeAttributeString(key, String(value)));
+            setSafeAttribute(el, key, value, { syncValueProperty: false, label: "tagFactory" });
           }
         }
       }
@@ -8180,7 +9299,7 @@ var param = tagFactory("param");
 var picture = tagFactory("picture");
 var portal = tagFactory("portal");
 var source = tagFactory("source");
-var svg = tagFactory("svg", SVG_NS);
+var svg = tagFactory("svg", SVG_NS3);
 var math = tagFactory("math");
 var canvas = tagFactory("canvas");
 var noscript = tagFactory("noscript");
@@ -8221,26 +9340,26 @@ var base = tagFactory("base");
 var link = tagFactory("link");
 var meta = tagFactory("meta");
 var style = tagFactory("style");
-var circle = tagFactory("circle", SVG_NS);
-var ellipse = tagFactory("ellipse", SVG_NS);
-var g = tagFactory("g", SVG_NS);
-var line = tagFactory("line", SVG_NS);
-var path = tagFactory("path", SVG_NS);
-var polygon = tagFactory("polygon", SVG_NS);
-var polyline = tagFactory("polyline", SVG_NS);
-var rect = tagFactory("rect", SVG_NS);
-var text = tagFactory("text", SVG_NS);
-var tspan = tagFactory("tspan", SVG_NS);
-var defs = tagFactory("defs", SVG_NS);
-var clipPath = tagFactory("clipPath", SVG_NS);
-var mask = tagFactory("mask", SVG_NS);
-var pattern = tagFactory("pattern", SVG_NS);
-var linearGradient = tagFactory("linearGradient", SVG_NS);
-var radialGradient = tagFactory("radialGradient", SVG_NS);
-var stop = tagFactory("stop", SVG_NS);
-var use = tagFactory("use", SVG_NS);
-var symbol = tagFactory("symbol", SVG_NS);
-var marker = tagFactory("marker", SVG_NS);
+var circle = tagFactory("circle", SVG_NS3);
+var ellipse = tagFactory("ellipse", SVG_NS3);
+var g = tagFactory("g", SVG_NS3);
+var line = tagFactory("line", SVG_NS3);
+var path = tagFactory("path", SVG_NS3);
+var polygon = tagFactory("polygon", SVG_NS3);
+var polyline = tagFactory("polyline", SVG_NS3);
+var rect = tagFactory("rect", SVG_NS3);
+var text = tagFactory("text", SVG_NS3);
+var tspan = tagFactory("tspan", SVG_NS3);
+var defs = tagFactory("defs", SVG_NS3);
+var clipPath = tagFactory("clipPath", SVG_NS3);
+var mask = tagFactory("mask", SVG_NS3);
+var pattern = tagFactory("pattern", SVG_NS3);
+var linearGradient = tagFactory("linearGradient", SVG_NS3);
+var radialGradient = tagFactory("radialGradient", SVG_NS3);
+var stop = tagFactory("stop", SVG_NS3);
+var use = tagFactory("use", SVG_NS3);
+var symbol = tagFactory("symbol", SVG_NS3);
+var marker = tagFactory("marker", SVG_NS3);
 var center = tagFactory("center");
 var font = tagFactory("font");
 var marquee = tagFactory("marquee");
@@ -8261,14 +9380,13 @@ function createMicroApp(config) {
   }
   let mounted = false;
   function mount(component) {
-    root.replaceChildren();
     const el = component();
-    root.appendChild(el);
+    replaceChildrenSafely(root, el);
     mounted = true;
   }
   function unmount() {
     if (!mounted) return;
-    root.replaceChildren();
+    replaceChildrenSafely(root);
     mounted = false;
   }
   return { mount, unmount, element: host };
@@ -8315,18 +9433,21 @@ function defineRemoteComponent(name, loader) {
       class: "sibu-remote",
       "data-remote-component": name
     });
-    container.appendChild(span({ class: "sibu-remote-loading", nodes: "Loading..." }));
+    container.appendChild(span({ class: "sibu-remote-loading" }, "Loading..."));
+    let disposed = false;
+    registerDisposer(container, () => {
+      disposed = true;
+    });
     loader().then((mod) => {
       cached = mod.default;
-      const rendered = cached();
-      container.replaceChildren(rendered);
+      if (disposed) return;
+      replaceChildrenSafely(container, cached());
     }).catch((err) => {
+      if (disposed) return;
       const message = err instanceof Error ? err.message : String(err);
-      container.replaceChildren(
-        div({
-          class: "sibu-remote-error",
-          nodes: `Failed to load remote component "${name}": ${message}`
-        })
+      replaceChildrenSafely(
+        container,
+        div({ class: "sibu-remote-error" }, `Failed to load remote component "${name}": ${message}`)
       );
     });
     return container;
@@ -8382,11 +9503,16 @@ function serviceWorker(scriptUrl, options) {
   const [isReady, setIsReady] = signal(false);
   const [isUpdateAvailable, setIsUpdateAvailable] = signal(false);
   const [error, setError] = signal(null);
-  let disposed = false;
+  let unregistered = false;
+  let unregisterRequested = false;
+  let registrationPromise = null;
+  let arrivedRegistration = null;
+  let pendingUnregister = null;
   let updateFoundHandler = null;
   let stateChangeHandler = null;
   let trackedWorker = null;
   let trackedReg = null;
+  const supported = typeof navigator !== "undefined" && !!navigator.serviceWorker;
   function detachListeners() {
     if (trackedReg && updateFoundHandler) {
       trackedReg.removeEventListener("updatefound", updateFoundHandler);
@@ -8399,33 +9525,53 @@ function serviceWorker(scriptUrl, options) {
     trackedWorker = null;
     trackedReg = null;
   }
-  if ("serviceWorker" in navigator) {
-    navigator.serviceWorker.register(scriptUrl, options).then((reg) => {
-      if (disposed) return;
-      setRegistration(reg);
-      setIsReady(true);
-      trackedReg = reg;
-      updateFoundHandler = () => {
-        if (disposed) return;
-        const newWorker = reg.installing;
-        if (newWorker) {
-          if (trackedWorker && stateChangeHandler) {
-            trackedWorker.removeEventListener("statechange", stateChangeHandler);
-          }
-          trackedWorker = newWorker;
-          stateChangeHandler = () => {
-            if (disposed) return;
-            if (newWorker.state === "installed" && navigator.serviceWorker.controller) {
-              setIsUpdateAvailable(true);
-            }
-          };
-          newWorker.addEventListener("statechange", stateChangeHandler);
+  function attachListeners(reg) {
+    trackedReg = reg;
+    updateFoundHandler = () => {
+      if (unregistered) return;
+      const newWorker = reg.installing;
+      if (newWorker) {
+        if (trackedWorker && stateChangeHandler) {
+          trackedWorker.removeEventListener("statechange", stateChangeHandler);
         }
-      };
-      reg.addEventListener("updatefound", updateFoundHandler);
-    }).catch((err) => {
-      if (disposed) return;
-      setError(err instanceof Error ? err : new Error(String(err)));
+        trackedWorker = newWorker;
+        stateChangeHandler = () => {
+          if (unregistered) return;
+          if (newWorker.state === "installed" && navigator.serviceWorker.controller) {
+            setIsUpdateAvailable(true);
+          }
+        };
+        newWorker.addEventListener("statechange", stateChangeHandler);
+      }
+    };
+    reg.addEventListener("updatefound", updateFoundHandler);
+  }
+  function activate(reg) {
+    setRegistration(reg);
+    setIsReady(true);
+    attachListeners(reg);
+  }
+  function recoverFailedUnregister() {
+    unregisterRequested = false;
+    if (!registration() && arrivedRegistration) {
+      activate(arrivedRegistration);
+      arrivedRegistration = null;
+    }
+  }
+  function adopt(reg) {
+    if (unregisterRequested) {
+      arrivedRegistration = reg;
+      return null;
+    }
+    activate(reg);
+    return reg;
+  }
+  if (supported) {
+    registrationPromise = navigator.serviceWorker.register(scriptUrl, options).then(adopt).catch((err) => {
+      if (!unregistered) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+      return null;
     });
   }
   async function update() {
@@ -8434,19 +9580,43 @@ function serviceWorker(scriptUrl, options) {
       await reg.update();
     }
   }
-  async function unregister() {
-    disposed = true;
-    detachListeners();
-    const reg = registration();
-    if (reg) {
-      const result = await reg.unregister();
-      if (result) {
-        setRegistration(null);
-        setIsReady(false);
-      }
-      return result;
+  async function performUnregister() {
+    unregisterRequested = true;
+    if (registrationPromise) await registrationPromise.catch(() => null);
+    const reg = registration() ?? arrivedRegistration;
+    if (!reg) {
+      unregisterRequested = false;
+      return false;
     }
-    return false;
+    let result;
+    try {
+      result = await reg.unregister();
+    } catch (err) {
+      recoverFailedUnregister();
+      throw err;
+    }
+    if (result) {
+      detachListeners();
+      setRegistration(null);
+      setIsReady(false);
+      setIsUpdateAvailable(false);
+      arrivedRegistration = null;
+      unregistered = true;
+    } else {
+      recoverFailedUnregister();
+    }
+    return result;
+  }
+  async function unregister() {
+    if (!supported || unregistered) return false;
+    if (pendingUnregister) return pendingUnregister;
+    const request = performUnregister();
+    pendingUnregister = request;
+    void request.catch(() => {
+    }).then(() => {
+      if (pendingUnregister === request) pendingUnregister = null;
+    });
+    return request;
   }
   return { registration, isReady, isUpdateAvailable, error, update, unregister };
 }
@@ -8551,17 +9721,39 @@ function createAction(actionFn) {
 }
 
 // src/platform/scrollRestoration.ts
+var DEFAULT_STATE_KEY = "__sibuScrollKey";
 function scrollRestoration(options) {
   const mode = options?.mode ?? "auto";
+  const stateKey = options?.stateKey ?? DEFAULT_STATE_KEY;
   const positions = /* @__PURE__ */ new Map();
   let popstateHandler = null;
   let currentKey = null;
-  const save = (key) => {
+  if (options?.getKey) {
+    try {
+      currentKey = options.getKey();
+    } catch {
+      currentKey = null;
+    }
+  }
+  const record = (key) => {
     if (typeof window !== "undefined") {
       positions.set(key, { x: window.scrollX, y: window.scrollY });
     }
     currentKey = key;
   };
+  const tagCurrentEntry = (key) => {
+    if (typeof window === "undefined" || typeof history === "undefined") return;
+    try {
+      const existing = history.state ?? {};
+      if (existing[stateKey] === key) return;
+      history.replaceState({ ...existing, [stateKey]: key }, "");
+    } catch {
+    }
+  };
+  const save = (key) => {
+    record(key);
+    if (mode === "auto") tagCurrentEntry(key);
+  };
   const restore = (key) => {
     const pos = positions.get(key);
     if (pos && typeof window !== "undefined") {
@@ -8572,11 +9764,32 @@ function scrollRestoration(options) {
   const getPosition = (key) => {
     return positions.get(key);
   };
+  const onNavigation = (key) => {
+    if (mode !== "auto") return;
+    if (currentKey !== null && currentKey !== key) record(currentKey);
+    currentKey = key;
+    tagCurrentEntry(key);
+  };
+  let nativeModeLease = null;
   if (mode === "auto" && typeof window !== "undefined") {
-    popstateHandler = () => {
-      if (currentKey) {
-        save(currentKey);
+    nativeModeLease = acquireScrollRestorationMode("manual");
+    if (currentKey !== null) tagCurrentEntry(currentKey);
+    popstateHandler = (event) => {
+      const state2 = event.state ?? null;
+      const rawDestination = state2 ? state2[stateKey] : void 0;
+      const destination = typeof rawDestination === "string" ? rawDestination : null;
+      let outgoing = currentKey;
+      if (outgoing === null && options?.getKey) {
+        try {
+          outgoing = options.getKey();
+        } catch {
+          outgoing = null;
+        }
+      }
+      if (outgoing !== null && outgoing !== destination) {
+        record(outgoing);
       }
+      if (destination !== null) restore(destination);
     };
     window.addEventListener("popstate", popstateHandler);
   }
@@ -8585,9 +9798,11 @@ function scrollRestoration(options) {
       window.removeEventListener("popstate", popstateHandler);
       popstateHandler = null;
     }
+    nativeModeLease?.release();
+    nativeModeLease = null;
     positions.clear();
   };
-  return { save, restore, getPosition, dispose: dispose2 };
+  return { save, restore, onNavigation, getPosition, dispose: dispose2 };
 }
 
 // src/platform/routeMiddleware.ts
@@ -9762,8 +10977,8 @@ function initDevTools(config) {
   function clearEvents() {
     eventLog.length = 0;
   }
-  function registerComponent(name, element, state) {
-    hook.components.set(name, { element, state });
+  function registerComponent(name, element, state2) {
+    hook.components.set(name, { element, state: state2 });
     emit();
   }
   function unregisterComponent(name) {
@@ -12114,9 +13329,9 @@ function zustandAdapter(options) {
   return createPlugin("sibu-zustand", (ctx) => {
     const { store } = options;
     const [getState, setSibuState] = signal(store.getState());
-    const unsubscribe = store.subscribe((state) => {
+    const unsubscribe = store.subscribe((state2) => {
       batch(() => {
-        setSibuState(state);
+        setSibuState(state2);
       });
     });
     function select3(selector) {
@@ -12548,6 +13763,7 @@ var materialAdapter = componentAdapter(materialConfig);
   lazyModule,
   loadRemoteModule,
   loadWasmModule,
+  loadWasmModuleWithOptions,
   loaderData,
   machine,
   matchesPattern,