sibujs 1.5.0 → 2.1.0

package/dist/data.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // data.ts
 var data_exports = {};
 __export(data_exports, {
+  __resetQueryCache: () => __resetQueryCache,
   calculateDelay: () => calculateDelay,
   clearQueryCache: () => clearQueryCache,
   debounce: () => debounce,
@@ -50,26 +51,39 @@ function isDev() {
 var _isDev = isDev();
 function devAssert(condition, message) {
   if (_isDev && !condition) {
-    throw new Error(`[Sibu] ${message}`);
+    throw new Error(`[SibuJS] ${message}`);
   }
 }
 function devWarn(message) {
   if (_isDev) {
-    console.warn(`[Sibu] ${message}`);
+    console.warn(`[SibuJS] ${message}`);
   }
 }
 
 // src/reactivity/track.ts
 var _isDev2 = isDev();
-var subscriberStack = new Array(32);
-var stackCapacity = 32;
+var STACK_INITIAL = 32;
+var STACK_SHRINK_THRESHOLD = 128;
+var subscriberStack = new Array(STACK_INITIAL);
+var stackCapacity = STACK_INITIAL;
 var stackTop = -1;
 var currentSubscriber = null;
-var signalSubscribers = /* @__PURE__ */ new WeakMap();
 var SUBS = "__s";
+function syncFastPath(signal2, subs) {
+  const size = subs.size;
+  if (size === 0) {
+    signal2.__f = void 0;
+    delete signal2[SUBS];
+  } else if (size === 1) {
+    signal2.__f = subs.values().next().value;
+  } else {
+    signal2.__f = void 0;
+  }
+}
 var notifyDepth = 0;
 var pendingQueue = [];
 var pendingSet = /* @__PURE__ */ new Set();
+var propagateStack = [];
 function safeInvoke(sub) {
   try {
     sub();
@@ -78,6 +92,47 @@ function safeInvoke(sub) {
   }
 }
 var trackingSuspended = false;
+var subscriberEpochCounter = 0;
+function retrack(effectFn, subscriber) {
+  const prev = currentSubscriber;
+  currentSubscriber = subscriber;
+  const sub = subscriber;
+  const epoch = ++subscriberEpochCounter;
+  sub._epoch = epoch;
+  try {
+    effectFn();
+  } finally {
+    currentSubscriber = prev;
+    pruneStaleDeps(sub, epoch);
+  }
+}
+function pruneStaleDeps(sub, currentEpoch) {
+  if (sub._dep !== void 0) {
+    if (sub._depEpoch !== currentEpoch) {
+      const sig = sub._dep;
+      const subs = sig[SUBS];
+      if (subs?.delete(sub)) syncFastPath(sig, subs);
+      sub._dep = void 0;
+      sub._depEpoch = void 0;
+    }
+    return;
+  }
+  const deps = sub._deps;
+  if (!deps || deps.size === 0) return;
+  let stales;
+  for (const [signal2, epoch] of deps) {
+    if (epoch !== currentEpoch) {
+      (stales ?? (stales = [])).push(signal2);
+    }
+  }
+  if (!stales) return;
+  for (const signal2 of stales) {
+    deps.delete(signal2);
+    const sig = signal2;
+    const subs = sig[SUBS];
+    if (subs?.delete(sub)) syncFastPath(sig, subs);
+  }
+}
 function track(effectFn, subscriber) {
   if (!subscriber) subscriber = effectFn;
   cleanup(subscriber);
@@ -93,37 +148,49 @@ function track(effectFn, subscriber) {
   } finally {
     stackTop--;
     currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
+    if (stackTop < 0 && stackCapacity > STACK_SHRINK_THRESHOLD) {
+      stackCapacity = Math.max(STACK_INITIAL, stackCapacity >>> 1);
+      subscriberStack.length = stackCapacity;
+    }
   }
   return () => cleanup(subscriber);
 }
 function recordDependency(signal2) {
   if (!currentSubscriber) return;
   const sub = currentSubscriber;
-  if (sub._dep === signal2) return;
+  const epoch = sub._epoch;
+  if (sub._dep === signal2) {
+    sub._depEpoch = epoch;
+    return;
+  }
   const deps = sub._deps;
   if (deps) {
-    if (deps.has(signal2)) return;
-    deps.add(signal2);
+    deps.set(signal2, epoch);
   } else if (sub._dep !== void 0) {
-    const set = /* @__PURE__ */ new Set();
-    set.add(sub._dep);
-    set.add(signal2);
-    sub._deps = set;
+    const map = /* @__PURE__ */ new Map();
+    map.set(sub._dep, sub._depEpoch);
+    map.set(signal2, epoch);
+    sub._deps = map;
     sub._dep = void 0;
+    sub._depEpoch = void 0;
   } else {
     sub._dep = signal2;
+    sub._depEpoch = epoch;
   }
-  let subs = signal2[SUBS];
+  const sig = signal2;
+  let subs = sig[SUBS];
   if (!subs) {
     subs = /* @__PURE__ */ new Set();
-    signalSubscribers.set(signal2, subs);
-    signal2[SUBS] = subs;
+    sig[SUBS] = subs;
   }
+  const prevSize = subs.size;
   subs.add(currentSubscriber);
-  if (subs.size === 1) {
-    signal2.__f = currentSubscriber;
-  } else if (signal2.__f !== void 0) {
-    signal2.__f = void 0;
+  if (subs.size !== prevSize) {
+    if (subs.size === 1) {
+      sig.__f = currentSubscriber;
+    } else if (sig.__f !== void 0) {
+      sig.__f = void 0;
+    }
   }
 }
 function queueSignalNotification(signal2) {
@@ -138,66 +205,102 @@ function queueSignalNotification(signal2) {
     }
   }
 }
-var MAX_DRAIN_ITERATIONS = 1e3;
+var maxSubscriberRepeats = 50;
+var maxDrainIterations = 1e6;
+var drainEpoch = 0;
+function tickRepeat(sub) {
+  const s = sub;
+  if (s._runEpoch !== drainEpoch) {
+    s._runEpoch = drainEpoch;
+    s._runs = 1;
+    return false;
+  }
+  return ++s._runs > maxSubscriberRepeats;
+}
+function cycleError(sub) {
+  if (typeof console !== "undefined") {
+    const name = sub.__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.`
+    );
+  }
+}
+function absoluteDrainError() {
+  if (typeof console !== "undefined") {
+    console.error(
+      `[SibuJS] Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
+    );
+  }
+}
+function drainQueue() {
+  let i = 0;
+  while (i < pendingQueue.length) {
+    if (i >= maxDrainIterations) {
+      absoluteDrainError();
+      break;
+    }
+    const sub = pendingQueue[i++];
+    if (tickRepeat(sub)) {
+      cycleError(sub);
+      break;
+    }
+    pendingSet.delete(sub);
+    safeInvoke(sub);
+  }
+}
 function drainNotificationQueue() {
   if (notifyDepth > 0) return;
   notifyDepth++;
+  drainEpoch++;
   try {
-    let i = 0;
-    while (i < pendingQueue.length) {
-      if (i >= MAX_DRAIN_ITERATIONS) {
-        if (typeof console !== "undefined") {
-          console.error(
-            `[SibuJS] Notification queue exceeded ${MAX_DRAIN_ITERATIONS} iterations \u2014 likely an effect that writes to a signal it reads. Breaking to prevent infinite loop.`
-          );
-        }
-        break;
-      }
-      safeInvoke(pendingQueue[i]);
-      i++;
-    }
+    drainQueue();
   } finally {
-    pendingQueue.length = 0;
-    pendingSet.clear();
     notifyDepth--;
+    if (notifyDepth === 0) {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+    }
   }
 }
 function propagateDirty(sub) {
   sub();
-  let sig = sub._sig;
-  while (sig) {
+  const rootSig = sub._sig;
+  if (!rootSig) return;
+  const stack = propagateStack;
+  const baseLen = stack.length;
+  stack.push(rootSig);
+  while (stack.length > baseLen) {
+    const sig = stack.pop();
     const first = sig.__f;
     if (first) {
       if (first._c) {
         const nSig = first._sig;
-        nSig._d = true;
-        sig = nSig;
-        continue;
-      }
-      if (!pendingSet.has(first)) {
+        if (!nSig._d) {
+          nSig._d = true;
+          stack.push(nSig);
+        }
+      } else if (!pendingSet.has(first)) {
         pendingSet.add(first);
         pendingQueue.push(first);
       }
-      break;
+      continue;
     }
     const subs = sig[SUBS];
-    if (!subs) break;
-    let nextSig;
+    if (!subs) continue;
     for (const s of subs) {
       if (s._c) {
-        s();
         const nSig = s._sig;
-        if (nSig && !nextSig) {
-          nextSig = nSig;
-        } else if (nSig) {
-          propagateDirty(s);
+        if (nSig && !nSig._d) {
+          nSig._d = true;
+          stack.push(nSig);
+        } else if (!nSig) {
+          s();
         }
       } else if (!pendingSet.has(s)) {
         pendingSet.add(s);
         pendingQueue.push(s);
       }
     }
-    sig = nextSig;
   }
 }
 function notifySubscribers(signal2) {
@@ -213,21 +316,22 @@ function notifySubscribers(signal2) {
       return;
     }
     notifyDepth++;
+    drainEpoch++;
     try {
       if (first._c) {
         propagateDirty(first);
+      } else if (tickRepeat(first)) {
+        cycleError(first);
       } else {
         safeInvoke(first);
       }
-      let i = 0;
-      while (i < pendingQueue.length) {
-        safeInvoke(pendingQueue[i]);
-        i++;
-      }
+      drainQueue();
     } finally {
-      pendingQueue.length = 0;
-      pendingSet.clear();
       notifyDepth--;
+      if (notifyDepth === 0) {
+        pendingQueue.length = 0;
+        pendingSet.clear();
+      }
     }
     return;
   }
@@ -245,57 +349,45 @@ function notifySubscribers(signal2) {
     return;
   }
   notifyDepth++;
+  drainEpoch++;
   try {
-    let directCount = 0;
     for (const sub of subs) {
-      pendingQueue[directCount++] = sub;
-    }
-    for (let i2 = 0; i2 < directCount; i2++) {
-      if (pendingQueue[i2]._c) {
-        propagateDirty(pendingQueue[i2]);
-      }
-    }
-    for (let i2 = 0; i2 < directCount; i2++) {
-      if (!pendingQueue[i2]._c) {
-        if (!pendingSet.has(pendingQueue[i2])) {
-          safeInvoke(pendingQueue[i2]);
-        }
+      if (sub._c) {
+        propagateDirty(sub);
+      } else if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
       }
     }
-    let i = directCount;
-    while (i < pendingQueue.length) {
-      safeInvoke(pendingQueue[i]);
-      i++;
-    }
+    drainQueue();
   } finally {
-    pendingQueue.length = 0;
-    pendingSet.clear();
     notifyDepth--;
+    if (notifyDepth === 0) {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+    }
   }
 }
 function cleanup(subscriber) {
   const sub = subscriber;
   const singleDep = sub._dep;
   if (singleDep !== void 0) {
-    const subs = singleDep[SUBS];
-    if (subs) {
-      subs.delete(subscriber);
-      if (singleDep.__f === subscriber) {
-        singleDep.__f = void 0;
-      }
+    const sig = singleDep;
+    const subs = sig[SUBS];
+    if (subs?.delete(subscriber)) {
+      syncFastPath(sig, subs);
     }
     sub._dep = void 0;
+    sub._depEpoch = void 0;
     return;
   }
   const deps = sub._deps;
   if (!deps || deps.size === 0) return;
-  for (const signal2 of deps) {
-    const subs = signal2[SUBS];
-    if (subs) {
-      subs.delete(subscriber);
-      if (signal2.__f === subscriber) {
-        signal2.__f = void 0;
-      }
+  for (const signal2 of deps.keys()) {
+    const sig = signal2;
+    const subs = sig[SUBS];
+    if (subs?.delete(subscriber)) {
+      syncFastPath(sig, subs);
     }
   }
   deps.clear();
@@ -305,6 +397,7 @@ function cleanup(subscriber) {
 function derived(getter, options) {
   devAssert(typeof getter === "function", "derived: argument must be a getter function.");
   const debugName = options?.name;
+  const equals = options?.equals;
   const cs = {};
   cs._d = false;
   cs._g = getter;
@@ -315,8 +408,14 @@ function derived(getter, options) {
   markDirty._c = 1;
   markDirty._sig = cs;
   track(() => {
-    cs._d = false;
-    cs._v = getter();
+    let threw = true;
+    try {
+      cs._v = getter();
+      cs._d = false;
+      threw = false;
+    } finally {
+      if (threw) cs._d = true;
+    }
   }, markDirty);
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   let evaluating = false;
@@ -329,11 +428,16 @@ function derived(getter, options) {
     if (trackingSuspended) {
       if (cs._d) {
         evaluating = true;
+        let threw = true;
         try {
-          cs._d = false;
-          cs._v = getter();
+          retrack(() => {
+            cs._v = getter();
+            cs._d = false;
+            threw = false;
+          }, markDirty);
         } finally {
           evaluating = false;
+          if (threw) cs._d = true;
         }
       }
       return cs._v;
@@ -342,13 +446,17 @@ function derived(getter, options) {
     if (cs._d) {
       const oldValue = cs._v;
       evaluating = true;
+      let threw = true;
       try {
-        track(() => {
+        retrack(() => {
+          const next = getter();
+          cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
           cs._d = false;
-          cs._v = getter();
+          threw = false;
         }, markDirty);
       } finally {
         evaluating = false;
+        if (threw) cs._d = true;
       }
       if (hook && oldValue !== cs._v) {
         hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
@@ -366,9 +474,28 @@ function derived(getter, options) {
 }
 
 // src/core/ssr-context.ts
-var ssrMode = false;
+var als = null;
+try {
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    const req = Function("return typeof require==='function'?require:null")();
+    if (req) {
+      const mod = req("node:async_hooks");
+      als = new mod.AsyncLocalStorage();
+    }
+  }
+} catch {
+  als = null;
+}
+var fallbackStore = { ssr: false, suspenseIdCounter: 0 };
+function getSSRStore() {
+  if (als) {
+    const s = als.getStore();
+    if (s) return s;
+  }
+  return fallbackStore;
+}
 function isSSR() {
-  return ssrMode;
+  return getSSRStore().ssr;
 }
 
 // src/core/signals/effect.ts
@@ -378,26 +505,114 @@ function effect(effectFn, options) {
   if (isSSR()) return () => {
   };
   const onError = options?.onError;
+  let userCleanups = [];
+  const onCleanup = (fn) => {
+    userCleanups.push(fn);
+  };
+  const runUserCleanups = () => {
+    if (userCleanups.length === 0) return;
+    const list = userCleanups;
+    userCleanups = [];
+    for (let i = list.length - 1; i >= 0; i--) {
+      try {
+        list[i]();
+      } catch (err) {
+        if (typeof console !== "undefined") {
+          console.warn("[SibuJS effect] onCleanup threw:", err);
+        }
+      }
+    }
+  };
+  const invokeBody = () => effectFn(onCleanup);
   const wrappedFn = onError ? () => {
     try {
-      effectFn();
+      invokeBody();
     } catch (err) {
       onError(err);
     }
-  } : effectFn;
+  } : invokeBody;
   let cleanupHandle = () => {
   };
+  let running = false;
+  let rerunPending = false;
+  const MAX_RERUNS = 100;
   const subscriber = () => {
-    cleanupHandle();
-    cleanupHandle = track(wrappedFn, subscriber);
+    if (running) {
+      rerunPending = true;
+      return;
+    }
+    running = true;
+    try {
+      let reruns = 0;
+      do {
+        rerunPending = false;
+        runUserCleanups();
+        cleanupHandle();
+        cleanupHandle = track(wrappedFn, subscriber);
+        if (++reruns > MAX_RERUNS) {
+          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.`
+            );
+          }
+          rerunPending = false;
+          break;
+        }
+      } while (rerunPending);
+    } finally {
+      running = false;
+      rerunPending = false;
+    }
   };
-  cleanupHandle = track(wrappedFn, subscriber);
+  running = true;
+  try {
+    let reruns = 0;
+    do {
+      rerunPending = false;
+      runUserCleanups();
+      cleanupHandle();
+      cleanupHandle = track(wrappedFn, subscriber);
+      if (++reruns > MAX_RERUNS) {
+        if (_g.__SIBU_DEV_WARN__ !== false && typeof console !== "undefined") {
+          console.error(
+            `[SibuJS] effect re-requested itself ${MAX_RERUNS}+ times on initial run \u2014 likely a write-reads-self cycle. Breaking to prevent infinite loop.`
+          );
+        }
+        rerunPending = false;
+        break;
+      }
+    } while (rerunPending);
+  } finally {
+    running = false;
+    rerunPending = false;
+  }
   const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   if (hook) hook.emit("effect:create", { effectFn });
+  let disposed = false;
   return () => {
+    if (disposed) return;
+    disposed = true;
     const h = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (h) h.emit("effect:destroy", { effectFn });
-    cleanupHandle();
+    if (h) {
+      try {
+        h.emit("effect:destroy", { effectFn });
+      } catch {
+      }
+    }
+    try {
+      runUserCleanups();
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS effect] onCleanup threw during dispose:", err);
+      }
+    }
+    try {
+      cleanupHandle();
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS effect] dispose threw:", err);
+      }
+    }
   };
 }
 
@@ -421,10 +636,13 @@ function enqueueBatchedSignal(signal2) {
   return true;
 }
 function flushBatch() {
-  for (const signal2 of pendingSignals) {
-    queueSignalNotification(signal2);
+  try {
+    for (const signal2 of pendingSignals) {
+      queueSignalNotification(signal2);
+    }
+  } finally {
+    pendingSignals.clear();
   }
-  pendingSignals.clear();
   drainNotificationQueue();
 }
 
@@ -481,10 +699,12 @@ function calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter) {
       break;
   }
   delay = Math.min(delay, maxDelay);
+  if (!Number.isFinite(delay)) delay = Number.MAX_SAFE_INTEGER;
   if (jitter > 0) {
     const jitterRange = delay * jitter;
     delay += (Math.random() * 2 - 1) * jitterRange;
   }
+  if (!Number.isFinite(delay) || Number.isNaN(delay)) delay = 0;
   return Math.max(0, delay);
 }
 async function withRetry(fn, options, onRetry, signal2) {
@@ -498,6 +718,7 @@ async function withRetry(fn, options, onRetry, signal2) {
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     if (signal2?.aborted) throw new DOMException("Aborted", "AbortError");
     try {
+      if (signal2?.aborted) throw new DOMException("Aborted", "AbortError");
       return await fn();
     } catch (error) {
       lastError = error;
@@ -579,24 +800,46 @@ function query(key, fetcher, options = {}) {
     let entry = queryCache.get(key2);
     if (!entry) {
       entry = getOrCreateEntry(key2);
-      entry.subscribers++;
       entry.listeners.add(onCacheUpdate);
       entry.refetchers.add(doFetch);
     }
     if (entry.promise) {
       setIsFetching(true);
+      const captured = entry.promise;
       try {
-        await entry.promise;
+        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) {
+          onCacheUpdate();
+          if (entry.error) onError?.(entry.error);
+        }
+      } finally {
+        if (!disposed && currentKey === key2) onSettled?.();
       }
-      onCacheUpdate();
       return;
     }
     abortController?.abort();
     abortController = new AbortController();
     const signal2 = abortController.signal;
     setIsFetching(true);
-    const promise = withRetry(() => fetcher({ signal: signal2, key: key2 }), retryOptions, void 0, signal2);
+    let promise;
+    try {
+      promise = withRetry(() => fetcher({ signal: signal2, key: key2 }), retryOptions, void 0, signal2);
+    } catch (err) {
+      setIsFetching(false);
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      entry.error = errorObj;
+      onError?.(errorObj);
+      onSettled?.();
+      return;
+    }
     entry.promise = promise;
     try {
       const result = await promise;
@@ -658,6 +901,7 @@ function query(key, fetcher, options = {}) {
         oldEntry.subscribers--;
         if (oldEntry.subscribers <= 0 && cacheTime >= 0) {
           const oldKey = currentKey;
+          if (oldEntry.gcTimer !== null) clearTimeout(oldEntry.gcTimer);
           oldEntry.gcTimer = setTimeout(() => queryCache.delete(oldKey), cacheTime);
         }
       }
@@ -665,7 +909,7 @@ function query(key, fetcher, options = {}) {
     const keyChanged = currentKey !== key2;
     currentKey = key2;
     const entry = getOrCreateEntry(key2, initialData);
-    if (keyChanged || entry.subscribers === 0) entry.subscribers++;
+    if (keyChanged) entry.subscribers++;
     if (entry.gcTimer !== null) {
       clearTimeout(entry.gcTimer);
       entry.gcTimer = null;
@@ -680,6 +924,11 @@ function query(key, fetcher, options = {}) {
         setError(entry.error);
       });
     }
+    if (!keyChanged && currentKey === key2 && entry.data !== void 0) {
+      const isDataStale2 = entry.dataUpdatedAt === 0 || Date.now() - entry.dataUpdatedAt >= staleTime;
+      if (enabled && isDataStale2 && !entry.promise) doFetch();
+      return;
+    }
     const isDataStale = entry.dataUpdatedAt === 0 || Date.now() - entry.dataUpdatedAt >= staleTime;
     if (enabled && (entry.data === void 0 || isDataStale)) {
       doFetch();
@@ -707,6 +956,7 @@ function query(key, fetcher, options = {}) {
     }
   }
   function dispose() {
+    if (disposed) return;
     disposed = true;
     abortController?.abort();
     effectCleanup();
@@ -719,12 +969,17 @@ function query(key, fetcher, options = {}) {
         entry.subscribers--;
         if (entry.subscribers <= 0 && cacheTime >= 0) {
           const key2 = currentKey;
+          if (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
           entry.gcTimer = setTimeout(() => queryCache.delete(key2), cacheTime);
         }
       }
     }
-    if (focusHandler) globalThis.removeEventListener("focus", focusHandler);
-    if (onlineHandler) globalThis.removeEventListener("online", onlineHandler);
+    if (focusHandler && typeof globalThis.removeEventListener === "function") {
+      globalThis.removeEventListener("focus", focusHandler);
+    }
+    if (onlineHandler && typeof globalThis.removeEventListener === "function") {
+      globalThis.removeEventListener("online", onlineHandler);
+    }
   }
   return {
     data,
@@ -768,7 +1023,19 @@ function clearQueryCache() {
   }
   queryCache.clear();
   for (const listener of activeListeners) listener();
-  for (const refetcher of activeRefetchers) refetcher();
+  for (const refetcher of activeRefetchers) {
+    refetcher().catch((err) => {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS query] refetch after clearQueryCache failed:", err);
+      }
+    });
+  }
+}
+function __resetQueryCache() {
+  for (const entry of queryCache.values()) {
+    if (entry.gcTimer) clearTimeout(entry.gcTimer);
+  }
+  queryCache.clear();
 }
 
 // src/data/mutation.ts
@@ -831,7 +1098,10 @@ function mutation(mutationFn, options = {}) {
     isSuccess,
     isIdle,
     mutate: (variables) => {
-      execute(variables).catch(() => {
+      execute(variables).catch((err) => {
+        if (typeof console !== "undefined") {
+          console.warn("[SibuJS mutation] mutate() failed; check `.error()` signal or onError option.", err);
+        }
       });
     },
     mutateAsync: execute,
@@ -867,11 +1137,13 @@ function infiniteQuery(key, fetcher, options) {
   const hasPreviousPage = derived(() => prevPageParam() !== void 0);
   let abortController = null;
   let disposed = false;
+  let runId = 0;
   async function fetchPage(pageParam, direction) {
     if (disposed) return;
     abortController?.abort();
     abortController = new AbortController();
     const signal2 = abortController.signal;
+    const myRun = ++runId;
     batch(() => {
       setIsFetching(true);
       if (direction === "next") setIsFetchingNext(true);
@@ -880,7 +1152,7 @@ function infiniteQuery(key, fetcher, options) {
     });
     try {
       const page = await withRetry(() => fetcher({ signal: signal2, pageParam }), retryOptions, void 0, signal2);
-      if (disposed) return;
+      if (disposed || myRun !== runId) return;
       const currentPages = pages();
       let newPages;
       if (direction === "prev") {
@@ -900,7 +1172,7 @@ function infiniteQuery(key, fetcher, options) {
       });
       onSuccess?.(newPages);
     } catch (err) {
-      if (disposed) return;
+      if (disposed || myRun !== runId) return;
       if (err instanceof DOMException && err.name === "AbortError") return;
       const errorObj = err instanceof Error ? err : new Error(String(err));
       batch(() => {
@@ -915,9 +1187,12 @@ function infiniteQuery(key, fetcher, options) {
   const effectCleanup = effect(() => {
     resolveKey();
     if (enabled) {
-      setPages([]);
-      setNextPageParam(initialPageParam);
-      setPrevPageParam(void 0);
+      abortController?.abort();
+      batch(() => {
+        setPages([]);
+        setNextPageParam(initialPageParam);
+        setPrevPageParam(void 0);
+      });
       fetchPage(initialPageParam, "initial");
     }
   });
@@ -1154,18 +1429,57 @@ function idbPut(db, store, item) {
     tx.onerror = () => reject(tx.error);
   });
 }
-function idbDelete(db, store, key) {
+function idbPutWithChange(db, item, change) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(["items", "_changes"], "readwrite");
+    tx.objectStore("items").put(item);
+    tx.objectStore("_changes").put(change);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+function idbDeleteWithChange(db, key, change) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(["items", "_changes"], "readwrite");
+    tx.objectStore("items").delete(key);
+    tx.objectStore("_changes").put(change);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+function idbGetAllWithKeys(db, store) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readonly");
+    const out = [];
+    const req = tx.objectStore(store).openCursor();
+    req.onsuccess = () => {
+      const cursor = req.result;
+      if (cursor) {
+        out.push({ key: cursor.primaryKey, value: cursor.value });
+        cursor.continue();
+      } else {
+        resolve(out);
+      }
+    };
+    req.onerror = () => reject(req.error);
+  });
+}
+function idbDeleteKeys(db, store, keys) {
+  if (keys.length === 0) return Promise.resolve();
   return new Promise((resolve, reject) => {
     const tx = db.transaction(store, "readwrite");
-    tx.objectStore(store).delete(key);
+    const objStore = tx.objectStore(store);
+    for (const k of keys) objStore.delete(k);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
 }
-function idbClear(db, store) {
+function idbPutMany(db, store, items) {
+  if (items.length === 0) return Promise.resolve();
   return new Promise((resolve, reject) => {
     const tx = db.transaction(store, "readwrite");
-    tx.objectStore(store).clear();
+    const objStore = tx.objectStore(store);
+    for (const item of items) objStore.put(item);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
@@ -1188,15 +1502,13 @@ async function offlineStore(options) {
     setPendingCount(changes.length);
   }
   async function put(item) {
-    await idbPut(db, "items", item);
-    await idbPut(db, "_changes", { type: "put", item, timestamp: Date.now() });
+    await idbPutWithChange(db, item, { type: "put", item, timestamp: Date.now() });
     await refreshData();
   }
   async function remove(key) {
     const existing = await idbGet(db, "items", key);
     if (existing) {
-      await idbDelete(db, "items", key);
-      await idbPut(db, "_changes", { type: "delete", item: existing, timestamp: Date.now() });
+      await idbDeleteWithChange(db, key, { type: "delete", item: existing, timestamp: Date.now() });
       await refreshData();
     }
   }
@@ -1207,25 +1519,45 @@ async function offlineStore(options) {
     return data().filter(filter);
   }
   async function sync() {
-    if (!adapter || isSyncing()) return;
+    if (!adapter || isSyncing() || closed) return;
     setIsSyncing(true);
     try {
-      const changes = await idbGetAll(db, "_changes");
-      if (changes.length > 0) {
-        const result = await adapter.push(changes);
+      const snapshot = await idbGetAllWithKeys(db, "_changes");
+      if (closed) return;
+      if (snapshot.length > 0) {
+        const result = await adapter.push(snapshot.map((e) => e.value));
+        if (closed) return;
         if (result.ok) {
-          await idbClear(db, "_changes");
+          await idbDeleteKeys(
+            db,
+            "_changes",
+            snapshot.map((e) => e.key)
+          );
+          if (closed) return;
         }
       }
       const remoteItems = await adapter.pull(lastSynced());
-      for (const item of remoteItems) {
-        await idbPut(db, "items", item);
+      if (closed) return;
+      const pendingChanges = await idbGetAll(db, "_changes");
+      if (closed) return;
+      const pendingKeys = /* @__PURE__ */ new Set();
+      for (const c of pendingChanges) {
+        const k = c.item[keyPath];
+        if (k != null) pendingKeys.add(k);
       }
+      const safeRemote = remoteItems.filter((item) => {
+        const k = item[keyPath];
+        return k == null || !pendingKeys.has(k);
+      });
+      await idbPutMany(db, "items", safeRemote);
+      if (closed) return;
       const now = Date.now();
       await idbPut(db, "_meta", now);
+      if (closed) return;
       setLastSynced(now);
       await refreshData();
-    } catch {
+    } catch (err) {
+      if (typeof console !== "undefined") console.warn("[offlineStore] sync failed", err);
     } finally {
       setIsSyncing(false);
     }
@@ -1233,13 +1565,21 @@ async function offlineStore(options) {
   function attach(newAdapter) {
     adapter = newAdapter;
   }
+  let onlineHandler = null;
+  let closed = false;
   function close() {
+    closed = true;
+    if (onlineHandler && typeof window !== "undefined") {
+      window.removeEventListener("online", onlineHandler);
+      onlineHandler = null;
+    }
     db.close();
   }
   if (autoSync && typeof window !== "undefined") {
-    window.addEventListener("online", () => {
+    onlineHandler = () => {
       sync();
-    });
+    };
+    window.addEventListener("online", onlineHandler);
   }
   return {
     data,
@@ -1262,9 +1602,11 @@ function syncAdapter(config) {
 // src/core/rendering/context.ts
 function context(defaultValue) {
   const [getValue, setValue] = signal(defaultValue);
-  return {
+  const ctx = {
     provide(value) {
+      const previous2 = getValue();
       setValue(value);
+      return () => setValue(previous2);
     },
     use() {
       return getValue;
@@ -1274,8 +1616,18 @@ function context(defaultValue) {
     },
     set(value) {
       setValue(value);
+    },
+    withContext(value, fn) {
+      const previous2 = getValue();
+      setValue(value);
+      try {
+        return fn();
+      } finally {
+        setValue(previous2);
+      }
     }
   };
+  return ctx;
 }
 
 // src/data/routeLoader.ts
@@ -1296,9 +1648,16 @@ function loaderData() {
     error: resource2.error
   };
 }
-async function preloadRoute(route, context2) {
+async function preloadRoute(route, context2, callerSignal) {
   if (!route.loader) return void 0;
   const controller = new AbortController();
+  if (callerSignal) {
+    if (callerSignal.aborted) {
+      controller.abort();
+    } else {
+      callerSignal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+  }
   return route.loader(context2, { signal: controller.signal });
 }
 
@@ -1313,7 +1672,7 @@ function validateWsUrl(raw) {
 function socket(url, options) {
   const autoReconnect = options?.autoReconnect ?? false;
   const reconnectDelay = options?.reconnectDelay ?? 1e3;
-  const maxReconnects = options?.maxReconnects ?? Infinity;
+  const maxReconnects = options?.maxReconnects ?? 10;
   const heartbeat = options?.heartbeat;
   const protocols = options?.protocols;
   const [data, setData] = signal(null);
@@ -1347,13 +1706,19 @@ function socket(url, options) {
     ws.onclose = () => {
       setStatus("closed");
       stopHeartbeat();
-      if (autoReconnect && !disposed && !manuallyClosed && reconnectCount < maxReconnects) {
+      const wasManual = manuallyClosed;
+      manuallyClosed = false;
+      if (autoReconnect && !disposed && !wasManual && reconnectCount < maxReconnects) {
+        const cap = 3e4;
+        const delay = Math.min(cap, reconnectDelay * 2 ** reconnectCount);
+        const jittered = delay * (0.5 + Math.random() * 0.5);
         reconnectCount++;
         reconnectTimer = setTimeout(() => {
+          reconnectTimer = null;
+          if (disposed || manuallyClosed) return;
           connect();
-        }, reconnectDelay);
+        }, jittered);
       }
-      manuallyClosed = false;
     };
     ws.onerror = () => {
     };
@@ -1399,13 +1764,24 @@ function socket(url, options) {
 }
 
 // src/utils/sanitize.ts
+var SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
 function sanitizeUrl(url) {
   const trimmed = url.replace(/[\x00-\x20\x7f-\x9f]+/g, "").trim();
   if (!trimmed) return "";
   const lower = trimmed.toLowerCase();
-  if (lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:") || lower.startsWith("blob:")) {
-    return "";
+  let schemeEnd = -1;
+  for (let i = 0; i < lower.length; i++) {
+    const ch = lower.charCodeAt(i);
+    if (ch === 58) {
+      schemeEnd = i;
+      break;
+    }
+    if (ch === 47 || ch === 63 || ch === 35) break;
   }
+  if (schemeEnd === -1) return trimmed;
+  const scheme = lower.slice(0, schemeEnd + 1);
+  if (!/^[a-z][a-z0-9+.-]*:$/.test(scheme)) return trimmed;
+  if (SAFE_URL_PROTOCOLS.indexOf(scheme) === -1) return "";
   return trimmed;
 }
 
@@ -1417,12 +1793,16 @@ function validateSseUrl(raw) {
 }
 function stream(url, options) {
   const autoReconnect = options?.autoReconnect ?? false;
+  const maxReconnects = options?.maxReconnects ?? 10;
+  const baseMs = options?.reconnectBaseMs ?? 1e3;
+  const maxMs = options?.reconnectMaxMs ?? 3e4;
   const [data, setData] = signal(null);
   const [event, setEvent] = signal(null);
   const [status, setStatus] = signal("connecting");
   let source = null;
   let disposed = false;
   let reconnectTimer = null;
+  let attempts = 0;
   function connect() {
     if (disposed) return;
     const safeUrl = validateSseUrl(url);
@@ -1436,6 +1816,7 @@ function stream(url, options) {
     });
     source.onopen = () => {
       setStatus("open");
+      attempts = 0;
     };
     source.onmessage = (evt) => {
       setData(evt.data);
@@ -1445,11 +1826,14 @@ function stream(url, options) {
       if (source && source.readyState === EventSource.CLOSED) {
         setStatus("closed");
         source = null;
-        if (autoReconnect && !disposed) {
+        if (autoReconnect && !disposed && attempts < maxReconnects) {
+          const delay = Math.min(maxMs, baseMs * 2 ** attempts);
+          const jittered = delay * (0.5 + Math.random() * 0.5);
+          attempts++;
           reconnectTimer = setTimeout(() => {
             reconnectTimer = null;
             connect();
-          }, 1e3);
+          }, jittered);
         }
       }
     };
@@ -1474,6 +1858,7 @@ function stream(url, options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  __resetQueryCache,
   calculateDelay,
   clearQueryCache,
   debounce,