sibujs 3.4.0 → 4.0.0

package/dist/data.cjs

@@ -66,8 +66,95 @@ function devWarn(message) {
   }
 }
 
+// src/core/errors.ts
+var ERROR_STATE_KEY = /* @__PURE__ */ Symbol.for("sibujs.runtime-errors.v1");
+function state() {
+  const g = globalThis;
+  const existing = g[ERROR_STATE_KEY];
+  if (existing) return existing;
+  const created = { handler: null, handlerDepth: 0 };
+  g[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 self = node;
+  return typeof self.dispatchEvent === "function" ? self : 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 s = state();
+    const handler = s.handler;
+    if (handler && s.handlerDepth === 0) {
+      s.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 {
+        s.handlerDepth--;
+      }
+    }
+    defaultReport(err, context2);
+  });
+}
+
 // src/reactivity/track-core.ts
-var _isDev2 = isDev();
 var POOL_MAX = 4096;
 var nodePool = [];
 function createNode() {
@@ -75,6 +162,7 @@ function createNode() {
     sig: null,
     sub: null,
     epoch: 0,
+    depVersion: 0,
     sigPrev: null,
     sigNext: null,
     subPrev: null,
@@ -159,9 +247,28 @@ function safeInvoke(sub) {
   try {
     sub();
   } catch (err) {
-    if (_isDev2) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
+    const s = sub;
+    reportError(err, { phase: s._errorPhase ?? "effect", name: s.__name, node: s._errorNode });
   }
 }
+function depsChanged(sub) {
+  let node = sub.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;
 function suspendTracking() {
@@ -242,7 +349,7 @@ function track(effectFn, subscriber) {
   const sub = subscriber;
   return sub._dispose ?? (sub._dispose = () => cleanup(subscriber));
 }
-function reactiveBinding(commit) {
+function reactiveBinding(commit, ownerNode) {
   const run = () => {
     const s = subscriber;
     if (s._disposed || s._reentrant) return;
@@ -258,13 +365,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);
   });
 }
@@ -276,9 +387,12 @@ function recordDependency(signal2) {
   const active = sig.__activeNode ?? null;
   if (active !== null && active.sub === sub) {
     active.epoch = epoch;
+    active.depVersion = sig.__v ?? Number.NaN;
     return;
   }
+  if (sig._validate !== void 0) sub._hasComputedDep = true;
   const node = allocNode(signal2, sub, epoch);
+  node.depVersion = sig.__v ?? Number.NaN;
   node.prevActive = active;
   sig.__activeNode = node;
   linkSub(sub, node);
@@ -297,9 +411,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);
@@ -321,19 +436,21 @@ function tickRepeat(sub) {
   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.`
-    );
-  }
+  const name = sub.__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 i = 0;
@@ -343,11 +460,14 @@ function drainQueue() {
       break;
     }
     const sub = pendingQueue[i++];
+    pendingSet.delete(sub);
+    if (quarantined.size > 0 && quarantined.has(sub)) continue;
+    if (sub._hasComputedDep === true && !depsChanged(sub)) continue;
     if (tickRepeat(sub)) {
       cycleError(sub);
-      break;
+      quarantined.add(sub);
+      continue;
     }
-    pendingSet.delete(sub);
     safeInvoke(sub);
   }
 }
@@ -362,6 +482,7 @@ function drainNotificationQueue() {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -455,6 +576,7 @@ function notifySubscribers(signal2) {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -481,14 +603,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 g = globalThis;
   const existing = g[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']).`
@@ -573,6 +695,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(
@@ -580,32 +717,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) {
@@ -627,20 +743,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 s = als.getStore();
@@ -674,7 +794,7 @@ function flushUserCleanups(ctx) {
     try {
       list[i]();
     } catch (err) {
-      if (typeof console !== "undefined") console.warn("[SibuJS effect] onCleanup threw:", err);
+      reportError(err, { phase: "cleanup" });
     }
   }
 }
@@ -687,11 +807,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) {
@@ -768,6 +889,8 @@ function effect(effectFn, options) {
   sub.depsTail = null;
   sub._epoch = 0;
   sub._structDirty = false;
+  sub._hasComputedDep = false;
+  sub._errorPhase = "effect";
   sub._runEpoch = 0;
   sub._runs = 0;
   ctx.subscriber = sub;
@@ -836,70 +959,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];
 }
@@ -910,6 +1035,50 @@ function globalSingleton(key, create) {
   return g[key] ?? (g[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(label, error) {
+  if (typeof console !== "undefined") {
+    console.error(`[SibuJS data] ${label} threw. The operation's own status is unaffected.`, error);
+  }
+}
+function runCallback(label, fn) {
+  try {
+    fn();
+  } catch (error) {
+    reportCallbackError(label, error);
+  }
+}
+function runSelect(label, fn) {
+  try {
+    return { ok: true, value: fn() };
+  } catch (error) {
+    reportCallbackError(label, error);
+    return { ok: false };
+  }
+}
+function notifyListeners(listeners, label) {
+  for (const listener of Array.from(listeners)) {
+    try {
+      listener();
+    } catch (error) {
+      reportCallbackError(label, error);
+    }
+  }
+}
+
 // src/data/retry.ts
 function calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter) {
   let delay;
@@ -942,39 +1111,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) {
@@ -986,7 +1170,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);
   }
@@ -1012,9 +1198,10 @@ function query(key, fetcher, options = {}) {
   const [data, 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() && data() === void 0);
   const isStale = derived(() => {
@@ -1024,82 +1211,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 = select ? select(result) : result;
+      notifyListeners(entry.listeners, "query cache listener");
+      if (disposed || currentKey !== key2) return;
+      const selected = runSelect("query select", () => select ? select(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() {
@@ -1114,43 +1347,24 @@ function query(key, fetcher, options = {}) {
       return;
     }
     const raw = entry.data;
-    const selected = raw !== void 0 && select ? select(raw) : raw;
+    const selected = raw !== void 0 && select ? runSelect("query select", () => select(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 = select ? select(raw) : raw;
+      const selected = runSelect("query select", () => select ? select(raw) : raw);
       batch(() => {
-        setData(selected);
+        if (selected.ok) setData(selected.value);
         setError(entry.error);
       });
     }
@@ -1188,22 +1402,9 @@ function query(key, fetcher, options = {}) {
   function dispose() {
     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);
     }
@@ -1239,21 +1440,21 @@ function setQueryData(key, data) {
   const newData = typeof data === "function" ? data(entry.data) : data;
   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") {
@@ -1265,7 +1466,7 @@ function clearQueryCache() {
 function __resetQueryCache() {
   const activeCache = getActiveQueryCache();
   for (const entry of activeCache.values()) {
-    if (entry.gcTimer) clearTimeout(entry.gcTimer);
+    abandonEntry(entry);
   }
   activeCache.clear();
 }
@@ -1280,6 +1481,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();
@@ -1297,25 +1500,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;
     }
   }
@@ -1323,6 +1539,8 @@ function mutation(mutationFn, options = {}) {
     runId++;
     abortController?.abort();
     abortController = null;
+    terminalStatus = "idle";
+    terminalError = void 0;
     batch(() => {
       setData(void 0);
       setError(void 0);
@@ -1338,7 +1556,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);
         }
@@ -1411,10 +1629,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);
@@ -1422,7 +1647,7 @@ function infiniteQuery(key, fetcher, options) {
           setIsFetchingNext(false);
           setIsFetchingPrev(false);
         });
-        onError?.(errorObj);
+        runCallback("infiniteQuery onError", () => onError?.(errorObj));
       }
     })();
     inFlight = promise;
@@ -1604,7 +1829,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;
@@ -1613,10 +1838,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;
       }
@@ -1625,10 +1850,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?.());
       }
     }
   }
@@ -1816,13 +2041,14 @@ async function offlineStore(options) {
     return data().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(
@@ -1835,20 +2061,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");
@@ -1861,6 +2085,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;
   }
@@ -1899,10 +2159,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);
@@ -1914,13 +2182,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);
       }
@@ -2077,10 +2353,12 @@ function stripControlChars(value) {
   return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
 }
 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 output = url.replace(OUTER_TRIM, "");
+  const lower = probe.toLowerCase();
   let schemeEnd = -1;
   for (let i = 0; i < lower.length; i++) {
     const ch = lower.charCodeAt(i);
@@ -2090,11 +2368,11 @@ function sanitizeUrl(url) {
     }
     if (ch === 47 || ch === 63 || ch === 35) break;
   }
-  if (schemeEnd === -1) return trimmed;
+  if (schemeEnd === -1) return output;
   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 output;
   if (SAFE_URL_PROTOCOLS.indexOf(scheme) === -1) return "";
-  return trimmed;
+  return output;
 }
 
 // src/ui/stream.ts