sibujs 4.5.0 → 4.7.0

package/dist/data.cjs

@@ -34,12 +34,14 @@ __export(data_exports, {
   preloadRoute: () => preloadRoute,
   previous: () => previous,
   query: () => query,
+  renderWithLoader: () => renderWithLoader,
   resource: () => resource,
   setQueryData: () => setQueryData,
   socket: () => socket,
   stream: () => stream,
   syncAdapter: () => syncAdapter,
   throttle: () => throttle,
+  withLoader: () => withLoader,
   withRetry: () => withRetry
 });
 module.exports = __toCommonJS(data_exports);
@@ -83,8 +85,8 @@ function safeStringify(value) {
     return Object.prototype.toString.call(value);
   }
 }
-function describe(context2) {
-  return context2.name ? `${context2.phase} "${context2.name}"` : context2.phase;
+function describe(context) {
+  return context.name ? `${context.phase} "${context.name}"` : context.phase;
 }
 var REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function untrackedRun(fn) {
@@ -92,8 +94,8 @@ function untrackedRun(fn) {
   return api?.untracked ? api.untracked(fn) : fn();
 }
 var PROPAGATE_EVENT = "sibu:error-propagate";
-function claimedByBoundary(error, context2) {
-  const raw = context2.node;
+function claimedByBoundary(error, context) {
+  const raw = context.node;
   if (!raw || typeof CustomEvent === "undefined") return false;
   const target = resolveEventTarget(raw);
   if (!target) return false;
@@ -101,7 +103,7 @@ function claimedByBoundary(error, context2) {
     const event = new CustomEvent(PROPAGATE_EVENT, {
       bubbles: true,
       cancelable: true,
-      detail: { error, context: context2 }
+      detail: { error, context }
     });
     return target.dispatchEvent(event) === false;
   } catch {
@@ -120,20 +122,20 @@ function resolveEventTarget(node) {
   const self = node;
   return typeof self.dispatchEvent === "function" ? self : null;
 }
-function defaultReport(error, context2) {
+function defaultReport(error, context) {
   if (typeof console === "undefined") return;
-  console.error(`[SibuJS] Uncaught error during ${describe(context2)}: ${error.message}`, error);
+  console.error(`[SibuJS] Uncaught error during ${describe(context)}: ${error.message}`, error);
 }
-function reportError(error, context2) {
+function reportError(error, context) {
   const err = normalizeError(error);
   untrackedRun(() => {
-    if (claimedByBoundary(err, context2)) return;
+    if (claimedByBoundary(err, context)) return;
     const s = state();
     const handler = s.handler;
     if (handler && s.handlerDepth === 0) {
       s.handlerDepth++;
       try {
-        handler(error instanceof Error ? error : err, context2);
+        handler(error instanceof Error ? error : err, context);
         return;
       } catch (handlerError) {
         if (typeof console !== "undefined") {
@@ -144,10 +146,29 @@ function reportError(error, context2) {
         s.handlerDepth--;
       }
     }
-    defaultReport(err, context2);
+    defaultReport(err, context);
   });
 }
 
+// src/core/rendering/dispose.ts
+function resolveCapture(capture) {
+  let frame = capture;
+  while (frame?.closed) frame = frame.forwardTo;
+  return frame ?? null;
+}
+var registrationCaptures = [];
+function currentDisposerCapture() {
+  return resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+}
+function beginDisposerCapture(capture) {
+  if (capture === null && registrationCaptures.length === 0) return false;
+  registrationCaptures.push(resolveCapture(capture));
+  return true;
+}
+function endDisposerCapture() {
+  registrationCaptures.pop();
+}
+
 // src/reactivity/track-core.ts
 var POOL_MAX = 4096;
 var nodePool = [];
@@ -306,6 +327,7 @@ function retrack(effectFn, subscriber) {
   }
   currentSubscriber = subscriber;
   const sub = subscriber;
+  if (sub._cap === void 0) sub._cap = currentDisposerCapture();
   const epoch = ++subscriberEpochCounter;
   sub._epoch = epoch;
   sub._structDirty = false;
@@ -497,7 +519,12 @@ function drainQueue() {
       quarantined.add(sub);
       continue;
     }
-    safeInvoke(sub);
+    const pushed = beginDisposerCapture(sub._cap ?? null);
+    try {
+      safeInvoke(sub);
+    } finally {
+      if (pushed) endDisposerCapture();
+    }
   }
 }
 function drainNotificationQueue() {
@@ -633,7 +660,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.5.0" : "dev";
+var _runtimeVersion = true ? "4.7.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
@@ -689,6 +716,14 @@ var getSubscriberCount2 = API.getSubscriberCount;
 var getSubscriberDeps2 = API.getSubscriberDeps;
 var forEachSubscriber2 = API.forEachSubscriber;
 
+// src/core/devtoolsHook.ts
+function emitDevtools(hook, event, payload) {
+  try {
+    hook.emit(event, payload);
+  } catch {
+  }
+}
+
 // src/core/signals/derived.ts
 function derived(getter, options) {
   devAssert(typeof getter === "function", "derived: argument must be a getter function.");
@@ -715,17 +750,17 @@ function derived(getter, options) {
     cs._d = false;
     cs._init = true;
   };
-  track2(() => {
-    let threw = true;
-    try {
+  try {
+    track2(() => {
       cs._v = getter();
       cs._d = false;
       cs._init = true;
-      threw = false;
-    } finally {
-      if (threw) cs._d = true;
-    }
-  }, markDirty);
+    }, markDirty);
+  } catch (err) {
+    disposed = true;
+    cleanup2(markDirty);
+    throw err;
+  }
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   const validate = () => {
     if (!cs._d || disposed || pendingError !== void 0) return;
@@ -744,7 +779,7 @@ function derived(getter, options) {
       if (disposed) cleanup2(markDirty);
     }
     if (hook && !disposed && !Object.is(oldValue, cs._v)) {
-      hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+      emitDevtools(hook, "computed:update", { signal: cs, oldValue, newValue: cs._v });
     }
   };
   cs._validate = validate;
@@ -795,7 +830,7 @@ function derived(getter, options) {
       }
     }
   };
-  if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
+  if (hook) emitDevtools(hook, "computed:create", { signal: cs, name: debugName, getter: computedGetter });
   return computedGetter;
 }
 
@@ -964,12 +999,17 @@ function effect(effectFn, options) {
   try {
     retrack2(ctx.bodyFn, ctx.subscriber);
     if (ctx.rerunPending) drainReruns(ctx);
+  } catch (err) {
+    ctx.disposed = true;
+    if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
+    cleanup2(ctx.subscriber);
+    throw err;
   } finally {
     ctx.running = false;
     ctx.rerunPending = false;
   }
   const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook) hook.emit("effect:create", { effectFn });
+  if (hook) emitDevtools(hook, "effect:create", { effectFn });
   return () => disposeEffect(ctx);
 }
 
@@ -1056,7 +1096,7 @@ function signal(initial, options) {
       state2.__v++;
       if (DEV) {
         const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-        if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
+        if (hook) emitDevtools(hook, "signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
       }
       if (!enqueueBatchedSignal(state2)) {
         notifySubscribers2(state2);
@@ -1070,7 +1110,7 @@ function signal(initial, options) {
       state2.value = newValue;
       state2.__v++;
       const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-      if (hook) hook.emit("signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
+      if (hook) emitDevtools(hook, "signal:update", { signal: state2, name: debugName, oldValue: prev, newValue });
       if (!enqueueBatchedSignal(state2)) {
         notifySubscribers2(state2);
       }
@@ -1089,7 +1129,7 @@ function signal(initial, options) {
   }
   if (DEV) {
     const hook = _g2.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-    if (hook) hook.emit("signal:create", { signal: state2, name: debugName, getter: get, initial });
+    if (hook) emitDevtools(hook, "signal:create", { signal: state2, name: debugName, getter: get, initial });
   }
   return [get, set];
 }
@@ -1211,7 +1251,83 @@ function waitForRetryDelay(delay, signal2) {
   });
 }
 
+// src/data/structuralSharing.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isPlainArray(value) {
+  return Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype;
+}
+function reconcile(prev, next, depth, walk, newRoot) {
+  if (Object.is(prev, next)) return prev;
+  const arrays = isPlainArray(prev) && isPlainArray(next);
+  if (!arrays && !(isPlainObject(prev) && isPlainObject(next))) return next;
+  if (Object.getPrototypeOf(prev) !== Object.getPrototypeOf(next)) return next;
+  const nextObject = next;
+  const seenAt = walk.path.get(nextObject);
+  if (seenAt !== void 0) {
+    walk.cycleTo = Math.min(walk.cycleTo, seenAt);
+    return next;
+  }
+  const prevRecord = prev;
+  const nextRecord = next;
+  const nextKeys = arrays ? Array.from({ length: next.length }, (_, i) => i) : Object.keys(nextRecord);
+  const prevSize = arrays ? prev.length : Object.keys(prevRecord).length;
+  const copy = arrays ? new Array(nextKeys.length) : Object.create(Object.getPrototypeOf(next));
+  let allFromPrev = prevSize === nextKeys.length;
+  let allFromNext = true;
+  const outerCycleTo = walk.cycleTo;
+  walk.cycleTo = Number.POSITIVE_INFINITY;
+  walk.path.set(nextObject, depth);
+  for (const key of nextKeys) {
+    if (arrays && !Object.hasOwn(nextRecord, key)) {
+      if (Object.hasOwn(prevRecord, key)) allFromPrev = false;
+      continue;
+    }
+    const nextChild = nextRecord[key];
+    const hasPrev = Object.hasOwn(prevRecord, key);
+    const shared = hasPrev ? reconcile(prevRecord[key], nextChild, depth + 1, walk, false) : nextChild;
+    copy[key] = shared;
+    if (!hasPrev || !Object.is(shared, prevRecord[key])) allFromPrev = false;
+    if (!Object.is(shared, nextChild)) allFromNext = false;
+  }
+  walk.path.delete(nextObject);
+  const reached = walk.cycleTo;
+  walk.cycleTo = Math.min(outerCycleTo, reached < depth ? reached : Number.POSITIVE_INFINITY);
+  if (reached <= depth) return next;
+  if (allFromPrev && !newRoot) return prev;
+  if (allFromNext) return next;
+  return copy;
+}
+function applyStructuralSharing(option, prev, next, explicit = false) {
+  if (option === false || prev === void 0) return next;
+  const forceNew = explicit && !Object.is(prev, next);
+  if (typeof option === "function") {
+    const shared = option(prev, next);
+    return forceNew && Object.is(shared, prev) ? next : shared;
+  }
+  return reconcile(prev, next, 0, { path: /* @__PURE__ */ new Map(), cycleTo: Number.POSITIVE_INFINITY }, forceNew);
+}
+
 // src/data/query.ts
+function shareSafely(option, prev, next, explicit) {
+  const shared = untracked2(
+    () => runSelect("query structuralSharing", () => applyStructuralSharing(option, prev, next, explicit))
+  );
+  return shared.ok ? shared.value : next;
+}
+function sharedView(entry) {
+  const raw = entry.data;
+  if (raw === void 0) return void 0;
+  if (entry.hasShared && Object.is(entry.sharedFrom, raw)) return entry.shared;
+  const value = shareSafely(true, entry.hasShared ? entry.shared : void 0, raw, entry.explicit);
+  entry.shared = value;
+  entry.sharedFrom = raw;
+  entry.hasShared = true;
+  return value;
+}
 var globalQueryCache = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.query.cache.v1"), () => /* @__PURE__ */ new Map());
 function getActiveQueryCache() {
   return getRequestScopedCache("query") ?? globalQueryCache;
@@ -1237,7 +1353,11 @@ function getOrCreateEntry(cache, key, initialData) {
       listeners: /* @__PURE__ */ new Set(),
       refetchers: /* @__PURE__ */ new Set(),
       controller: null,
-      generation: 0
+      generation: 0,
+      explicit: false,
+      shared: void 0,
+      sharedFrom: void 0,
+      hasShared: false
     };
     cache.set(key, entry);
   }
@@ -1256,13 +1376,24 @@ function query(key, fetcher, options = {}) {
     onSuccess,
     onError,
     onSettled,
-    select
+    select,
+    structuralSharing = true
   } = options;
   const resolveKey = typeof key === "function" ? key : () => key;
   const cache = getActiveQueryCache();
   const [data, setData] = signal(initialData);
   const [isFetching, setIsFetching] = signal(false);
   const [error, setError] = signal(void 0);
+  const [updatedAt, setUpdatedAt] = signal(0);
+  const [base, setBase] = signal(void 0);
+  let baseEntry = null;
+  let baseValue;
+  let baseExplicit = false;
+  let customEntry = null;
+  let customFrom;
+  let customValue;
+  let selectedEntry = null;
+  let selectedValue;
   let disposed = false;
   let currentKey = null;
   let attachedEntry = null;
@@ -1271,11 +1402,57 @@ function query(key, fetcher, options = {}) {
   const loading = derived(() => isFetching() && data() === void 0);
   const isStale = derived(() => {
     data();
+    updatedAt();
     if (!currentKey) return true;
     const entry = cache.get(currentKey);
     if (!entry || entry.dataUpdatedAt === 0) return true;
     return Date.now() - entry.dataUpdatedAt >= staleTime;
   });
+  function viewOf(entry) {
+    const raw = entry.data;
+    if (raw === void 0) return void 0;
+    if (structuralSharing === false) return raw;
+    if (typeof structuralSharing !== "function") return sharedView(entry);
+    const sameEntry = customEntry === entry;
+    if (sameEntry && Object.is(customFrom, raw)) return customValue;
+    const value = shareSafely(structuralSharing, sameEntry ? customValue : void 0, raw, entry.explicit);
+    customEntry = entry;
+    customFrom = raw;
+    customValue = value;
+    return value;
+  }
+  function commitBase(entry, value) {
+    const changed = !Object.is(value, baseValue);
+    baseEntry = entry;
+    baseValue = value;
+    if (!select) {
+      setData(value);
+      return;
+    }
+    if (!changed) return;
+    baseExplicit = entry?.explicit === true;
+    setBase(value);
+  }
+  const stopSelect = select ? effect(() => {
+    const raw = base();
+    const entry = baseEntry;
+    const explicit = baseExplicit;
+    baseExplicit = false;
+    if (entry === null && selectedEntry === null) return;
+    if (raw === void 0) {
+      selectedEntry = entry;
+      selectedValue = void 0;
+      setData(void 0);
+      return;
+    }
+    const selected = runSelect("query select", () => select(raw));
+    if (!selected.ok) return;
+    const prev = selectedEntry === entry ? selectedValue : void 0;
+    const value = shareSafely(structuralSharing, prev, selected.value, explicit);
+    selectedEntry = entry;
+    selectedValue = value;
+    setData(value);
+  }) : null;
   function detachFromEntry() {
     const entry = attachedEntry;
     const key2 = attachedKey;
@@ -1334,7 +1511,7 @@ function query(key, fetcher, options = {}) {
             const settledError = entry.error;
             runCallback("query onError", () => onError?.(settledError));
           } else if (entry.data !== void 0) {
-            const settledData = entry.data;
+            const settledData = viewOf(entry);
             runCallback("query onSuccess", () => onSuccess?.(settledData));
           }
           runCallback("query onSettled", () => onSettled?.());
@@ -1365,17 +1542,14 @@ function query(key, fetcher, options = {}) {
       entry.promise = null;
       entry.controller = null;
       entry.data = result;
+      entry.explicit = false;
       entry.dataUpdatedAt = Date.now();
       entry.error = void 0;
       notifyListeners(entry.listeners, "query cache listener");
       if (disposed || currentKey !== key2) return;
-      const selected = runSelect("query select", () => select ? select(result) : result);
-      batch(() => {
-        if (selected.ok) setData(selected.value);
-        setIsFetching(false);
-        setError(void 0);
-      });
-      runCallback("query onSuccess", () => onSuccess?.(result));
+      if (!entry.listeners.has(onCacheUpdate)) onCacheUpdate();
+      const committedResult = viewOf(entry);
+      runCallback("query onSuccess", () => onSuccess?.(committedResult));
     } catch (err) {
       if (entry.generation !== generation) return;
       entry.promise = null;
@@ -1405,18 +1579,19 @@ function query(key, fetcher, options = {}) {
     const entry = cache.get(currentKey);
     if (!entry) {
       batch(() => {
-        setData(void 0);
+        commitBase(null, void 0);
         setError(void 0);
         setIsFetching(false);
+        setUpdatedAt(0);
       });
       return;
     }
-    const raw = entry.data;
-    const selected = raw !== void 0 && select ? runSelect("query select", () => select(raw)) : { ok: true, value: raw };
+    const view = viewOf(entry);
     batch(() => {
-      if (selected.ok) setData(selected.value);
+      commitBase(entry, view);
       setError(entry.error);
       if (!entry.promise) setIsFetching(false);
+      setUpdatedAt(entry.dataUpdatedAt);
     });
   }
   const effectCleanup = effect(() => {
@@ -1426,11 +1601,11 @@ function query(key, fetcher, options = {}) {
     const entry = getOrCreateEntry(cache, key2, initialData);
     attachToEntry(entry, key2);
     if (entry.data !== void 0) {
-      const raw = entry.data;
-      const selected = runSelect("query select", () => select ? select(raw) : raw);
+      const view = viewOf(entry);
       batch(() => {
-        if (selected.ok) setData(selected.value);
+        commitBase(entry, view);
         setError(entry.error);
+        setUpdatedAt(entry.dataUpdatedAt);
       });
     }
     if (!keyChanged && currentKey === key2 && entry.data !== void 0) {
@@ -1468,6 +1643,7 @@ function query(key, fetcher, options = {}) {
     if (disposed) return;
     disposed = true;
     effectCleanup();
+    stopSelect?.();
     loading.dispose();
     isStale.dispose();
     if (intervalTimer) clearInterval(intervalTimer);
@@ -1499,13 +1675,15 @@ function invalidateQueries(keyOrPredicate) {
   }
 }
 function getQueryData(key) {
-  return getActiveQueryCache().get(key)?.data;
+  const entry = getActiveQueryCache().get(key);
+  return entry ? sharedView(entry) : void 0;
 }
 function setQueryData(key, data) {
   const entry = getActiveQueryCache().get(key);
   if (!entry) return;
-  const newData = typeof data === "function" ? data(entry.data) : data;
+  const newData = typeof data === "function" ? data(sharedView(entry)) : data;
   entry.data = newData;
+  entry.explicit = true;
   entry.dataUpdatedAt = Date.now();
   notifyListeners(entry.listeners, "query cache listener");
 }
@@ -1555,7 +1733,7 @@ function mutation(mutationFn, options = {}) {
     abortController = new AbortController();
     const signal2 = abortController.signal;
     const myRun = ++runId;
-    let context2;
+    let context;
     batch(() => {
       setLoading(true);
       setError(void 0);
@@ -1563,7 +1741,7 @@ function mutation(mutationFn, options = {}) {
     });
     try {
       if (options.onMutate) {
-        context2 = await options.onMutate(variables);
+        context = await options.onMutate(variables);
       }
       const result = await withRetry(() => mutationFn(variables, signal2), options.retry, void 0, signal2);
       if (myRun !== runId) return result;
@@ -1574,8 +1752,8 @@ function mutation(mutationFn, options = {}) {
         setLoading(false);
         setStatus("success");
       });
-      runCallback("mutation onSuccess", () => options.onSuccess?.(result, variables, context2));
-      runCallback("mutation onSettled", () => options.onSettled?.(result, void 0, variables, context2));
+      runCallback("mutation onSuccess", () => options.onSuccess?.(result, variables, context));
+      runCallback("mutation onSettled", () => options.onSettled?.(result, void 0, variables, context));
       return result;
     } catch (err) {
       if (isAbortError(err)) {
@@ -1597,8 +1775,8 @@ function mutation(mutationFn, options = {}) {
         setLoading(false);
         setStatus("error");
       });
-      runCallback("mutation onError", () => options.onError?.(errorObj, variables, context2));
-      runCallback("mutation onSettled", () => options.onSettled?.(void 0, errorObj, variables, context2));
+      runCallback("mutation onError", () => options.onError?.(errorObj, variables, context));
+      runCallback("mutation onSettled", () => options.onSettled?.(void 0, errorObj, variables, context));
       throw errorObj;
     }
   }
@@ -1736,18 +1914,21 @@ function infiniteQuery(key, fetcher, options) {
     }
   });
   function fetchNextPage() {
+    if (disposed) return Promise.resolve();
     if (inFlight) return inFlight;
     const param = nextPageParam();
     if (param === void 0) return Promise.resolve();
     return fetchPage(param, "next");
   }
   function fetchPreviousPage() {
+    if (disposed) return Promise.resolve();
     if (inFlight) return inFlight;
     const param = prevPageParam();
     if (param === void 0) return Promise.resolve();
     return fetchPage(param, "prev");
   }
   async function refetch() {
+    if (disposed) return;
     batch(() => {
       setPages([]);
       setNextPageParam(initialPageParam);
@@ -1831,25 +2012,26 @@ function throttle(getter, interval) {
   let pending = null;
   let lastEmitted = getter();
   let timer = null;
+  function emit(value) {
+    setThrottled(value);
+    lastEmitted = value;
+    cooldown = true;
+    pending = null;
+    timer = setTimeout(endWindow, interval);
+  }
+  function endWindow() {
+    timer = null;
+    if (pending !== null && !Object.is(pending.value, lastEmitted)) {
+      emit(pending.value);
+      return;
+    }
+    pending = null;
+    cooldown = false;
+  }
   const stop = effect(() => {
     const value = getter();
     if (!cooldown) {
-      if (!Object.is(value, lastEmitted)) {
-        setThrottled(value);
-        lastEmitted = value;
-        cooldown = true;
-        pending = null;
-        timer = setTimeout(() => {
-          timer = null;
-          cooldown = false;
-          if (pending !== null) {
-            const trailingValue = pending.value;
-            pending = null;
-            setThrottled(trailingValue);
-            lastEmitted = trailingValue;
-          }
-        }, interval);
-      }
+      if (!Object.is(value, lastEmitted)) emit(value);
     } else {
       pending = { value };
     }
@@ -1885,6 +2067,15 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
   const [loading, setLoading] = signal(false);
   const [error, setError] = signal(void 0);
   let currentData = options.initialValue;
+  function commitData(next, explicit) {
+    const sharing = options.structuralSharing ?? true;
+    const shared = untracked2(
+      () => runSelect("resource structuralSharing", () => applyStructuralSharing(sharing, currentData, next, explicit))
+    );
+    currentData = shared.ok ? shared.value : next;
+    setData(currentData);
+    return currentData;
+  }
   let abortController = null;
   let disposed = false;
   let effectCleanup = null;
@@ -1904,12 +2095,12 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
     try {
       const result = await withRetry(() => fetcher(sourceValue, { signal: signal2, prev }), options.retry, void 0, signal2);
       if (version !== fetchVersion || disposed) return;
-      currentData = result;
+      let committed = result;
       batch(() => {
-        setData(result);
+        committed = commitData(result, false);
         setLoading(false);
       });
-      runCallback("resource onSuccess", () => options.onSuccess?.(result));
+      runCallback("resource onSuccess", () => options.onSuccess?.(committed));
     } catch (err) {
       if (version !== fetchVersion || disposed) return;
       if (isAbortError(err)) {
@@ -1923,7 +2114,7 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
       });
       runCallback("resource onError", () => options.onError?.(errorObj));
     } finally {
-      if (version === fetchVersion) {
+      if (!disposed && version === fetchVersion) {
         runCallback("resource onSettled", () => options.onSettled?.());
       }
     }
@@ -1943,8 +2134,7 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
     refetch: () => doFetch(source ? source() : void 0),
     mutate: (value) => {
       const newValue = typeof value === "function" ? value(currentData) : value;
-      currentData = newValue;
-      setData(newValue);
+      commitData(newValue, true);
     },
     abort: () => abortController?.abort(),
     dispose: () => {
@@ -2229,62 +2419,55 @@ function syncAdapter(config) {
   return config;
 }
 
-// src/core/rendering/context.ts
-function context(defaultValue) {
-  const [getValue, setValue] = signal(defaultValue);
-  const warnIfSSR = (method) => {
-    if (!DEV || !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);
-    },
-    use() {
-      return getValue;
-    },
-    get() {
-      return getValue();
-    },
-    set(value) {
-      warnIfSSR("set");
-      setValue(value);
-    },
-    withContext(value, fn) {
-      warnIfSSR("withContext");
-      const previous2 = getValue();
-      setValue(value);
-      try {
-        const result = fn();
-        if (DEV && 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);
-      }
-    }
-  };
-  return ctx;
-}
-
 // src/data/routeLoader.ts
-var LoaderContext = context(null);
-function executeLoader(loader, context2, options) {
-  const res = resource(({ signal: signal2 }) => loader(context2, { signal: signal2 }), options);
-  LoaderContext.provide(res);
+var _clientScope = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.routeLoader.v2"), () => ({ stack: [] }));
+var _disposed = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.routeLoader.disposed.v1"), () => /* @__PURE__ */ new WeakSet());
+function currentScope() {
+  const cache = getRequestScopedCache("routeLoader");
+  if (!cache) return _clientScope;
+  let scope = cache.get("scope");
+  if (!scope) {
+    scope = { stack: [] };
+    cache.set("scope", scope);
+  }
+  return scope;
+}
+function executeLoader(loader, context, options) {
+  const res = resource(({ signal: signal2 }) => loader(context, { signal: signal2 }), options);
+  const disposeResource = res.dispose;
+  res.dispose = () => {
+    _disposed.add(res);
+    disposeResource();
+  };
   return res;
 }
+function renderWithLoader(loader, render) {
+  if (_disposed.has(loader)) {
+    throw new Error("renderWithLoader: the loader resource has been disposed");
+  }
+  const scope = currentScope();
+  const entry = loader;
+  scope.stack.push(entry);
+  try {
+    return render();
+  } finally {
+    const index = scope.stack.lastIndexOf(entry);
+    if (index !== -1) scope.stack.splice(index, 1);
+  }
+}
+function withLoader(loader, context, render, options) {
+  const res = executeLoader(loader, context, options);
+  try {
+    return { view: renderWithLoader(res, render), resource: res };
+  } catch (err) {
+    res.dispose();
+    throw err;
+  }
+}
 function loaderData() {
-  const resource2 = LoaderContext.get();
-  if (!resource2) {
+  const scope = currentScope();
+  const resource2 = scope.stack[scope.stack.length - 1];
+  if (!resource2 || _disposed.has(resource2)) {
     throw new Error("loaderData must be used inside a route with a loader");
   }
   return {
@@ -2293,7 +2476,7 @@ function loaderData() {
     error: resource2.error
   };
 }
-async function preloadRoute(route, context2, callerSignal) {
+async function preloadRoute(route, context, callerSignal) {
   if (!route.loader) return void 0;
   const controller = new AbortController();
   let onAbort = null;
@@ -2306,7 +2489,7 @@ async function preloadRoute(route, context2, callerSignal) {
     }
   }
   try {
-    return await route.loader(context2, { signal: controller.signal });
+    return await route.loader(context, { signal: controller.signal });
   } finally {
     if (onAbort) callerSignal?.removeEventListener("abort", onAbort);
   }
@@ -2334,34 +2517,73 @@ function socket(url, options) {
   let heartbeatTimer = null;
   let disposed = false;
   let manuallyClosed = false;
+  let lifecycle = 0;
   function getUrl() {
     return typeof url === "function" ? url() : url;
   }
   function connect() {
     if (disposed) return;
+    const generation = lifecycle;
+    const invalidated = () => disposed || generation !== lifecycle;
     if (typeof WebSocket === "undefined") {
       setStatus("closed");
       return;
     }
-    const safeUrl = validateWsUrl(getUrl());
+    let rawUrl;
+    try {
+      rawUrl = getUrl();
+    } catch (error) {
+      setStatus("closed");
+      reportError(error, { phase: "async", name: "socket" });
+      return;
+    }
+    if (invalidated()) {
+      setStatus("closed");
+      return;
+    }
+    const safeUrl = validateWsUrl(rawUrl);
     if (safeUrl === null) {
       setStatus("closed");
       return;
     }
     setStatus("connecting");
-    ws = new WebSocket(safeUrl, protocols);
-    ws.onopen = () => {
+    if (invalidated()) {
+      setStatus("closed");
+      return;
+    }
+    let instance;
+    try {
+      instance = new WebSocket(safeUrl, protocols);
+    } catch (error) {
+      setStatus("closed");
+      reportError(error, { phase: "async", name: "socket" });
+      return;
+    }
+    if (invalidated()) {
+      instance.close();
+      setStatus("closed");
+      return;
+    }
+    ws = instance;
+    instance.onopen = () => {
+      if (ws !== instance) return;
+      const openGeneration = lifecycle;
       setStatus("open");
+      if (disposed || openGeneration !== lifecycle || ws !== instance) return;
       reconnectCount = 0;
       startHeartbeat();
     };
-    ws.onmessage = (event) => {
+    instance.onmessage = (event) => {
+      if (ws !== instance) return;
       setData(event.data);
     };
-    ws.onclose = () => {
+    instance.onclose = () => {
+      if (ws !== instance) return;
+      ws = null;
+      const closeGeneration = lifecycle;
       setStatus("closed");
       stopHeartbeat();
-      const wasManual = manuallyClosed;
+      const wasManual = manuallyClosed || closeGeneration !== lifecycle;
       manuallyClosed = false;
       if (autoReconnect && !disposed && !wasManual && reconnectCount < maxReconnects) {
         const cap = 3e4;
@@ -2375,7 +2597,7 @@ function socket(url, options) {
         }, jittered);
       }
     };
-    ws.onerror = () => {
+    instance.onerror = () => {
     };
   }
   function startHeartbeat() {
@@ -2399,13 +2621,23 @@ function socket(url, options) {
     }
   }
   function close() {
+    lifecycle++;
     manuallyClosed = true;
     if (reconnectTimer !== null) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
     stopHeartbeat();
-    if (ws) {
+    if (!ws) {
+      setStatus("closed");
+      return;
+    }
+    if (ws.readyState === WebSocket.CLOSED) {
+      ws = null;
+      setStatus("closed");
+      return;
+    }
+    if (ws.readyState !== WebSocket.CLOSING) {
       setStatus("closing");
       ws.close();
     }
@@ -2463,6 +2695,7 @@ function stream(url, options) {
   let disposed = false;
   let reconnectTimer = null;
   let attempts = 0;
+  let closeGeneration = 0;
   function connect() {
     if (disposed) return;
     if (typeof EventSource === "undefined") {
@@ -2474,44 +2707,64 @@ function stream(url, options) {
       setStatus("closed");
       return;
     }
+    const generation = closeGeneration;
     setStatus("connecting");
-    source = new EventSource(safeUrl, {
+    if (disposed || generation !== closeGeneration) return;
+    const instance = new EventSource(safeUrl, {
       withCredentials: options?.withCredentials ?? false
     });
-    source.onopen = () => {
+    if (disposed || generation !== closeGeneration) {
+      instance.close();
+      return;
+    }
+    source = instance;
+    const live = () => !disposed && source === instance;
+    instance.onopen = () => {
+      if (!live()) return;
       setStatus("open");
       attempts = 0;
     };
-    source.onmessage = (evt) => {
+    instance.onmessage = (evt) => {
+      if (!live()) return;
       setData(evt.data);
       setEvent(evt.type);
     };
-    source.onerror = () => {
-      if (source && source.readyState === EventSource.CLOSED) {
-        setStatus("closed");
-        source = null;
-        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();
-          }, jittered);
-        }
+    instance.onerror = () => {
+      if (!live() || instance.readyState !== EventSource.CLOSED) return;
+      detach(instance);
+      source = null;
+      const generation2 = closeGeneration;
+      setStatus("closed");
+      if (disposed || generation2 !== closeGeneration) return;
+      if (autoReconnect && 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();
+        }, jittered);
       }
     };
   }
+  function detach(instance) {
+    instance.onopen = null;
+    instance.onmessage = null;
+    instance.onerror = null;
+  }
   function close() {
+    closeGeneration++;
     if (reconnectTimer !== null) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
-    if (source) {
-      source.close();
-      setStatus("closed");
+    const instance = source;
+    if (instance) {
       source = null;
+      detach(instance);
+      instance.close();
     }
+    setStatus("closed");
   }
   function dispose() {
     disposed = true;
@@ -2536,11 +2789,13 @@ function stream(url, options) {
   preloadRoute,
   previous,
   query,
+  renderWithLoader,
   resource,
   setQueryData,
   socket,
   stream,
   syncAdapter,
   throttle,
+  withLoader,
   withRetry
 });