@solidjs/signals 0.13.3 → 0.13.5

package/dist/dev.js

@@ -153,12 +153,16 @@ let scheduled = false;
 let projectionWriteActive = false;
 let _enforceLoadingBoundary = false;
 let _hitUnhandledAsync = false;
+let stashedOptimisticReads = null;
 function resetUnhandledAsync() {
   _hitUnhandledAsync = false;
 }
 function enforceLoadingBoundary(enabled) {
   _enforceLoadingBoundary = enabled;
 }
+function shouldReadStashedOptimisticValue(node) {
+  return !!stashedOptimisticReads?.has(node);
+}
 function runLaneEffects(type) {
   for (const lane of activeLanes) {
     if (lane._mergedInto || lane._pendingAsync.size > 0) continue;
@@ -169,14 +173,89 @@ function runLaneEffects(type) {
     }
   }
 }
+function queueStashedOptimisticEffects(node) {
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    const sub = s._sub;
+    if (!sub._type) continue;
+    if (sub._type === EFFECT_TRACKED) {
+      if (!sub._modified) {
+        sub._modified = true;
+        sub._queue.enqueue(EFFECT_USER, sub._run);
+      }
+      continue;
+    }
+    const queue = sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (queue._min > sub._height) queue._min = sub._height;
+    insertIntoHeap(sub, queue);
+  }
+}
 function setProjectionWriteActive(value) {
   projectionWriteActive = value;
 }
+function mergeTransitionState(target, outgoing) {
+  outgoing._done = target;
+  target._actions.push(...outgoing._actions);
+  for (const lane of activeLanes) {
+    if (lane._transition === outgoing) lane._transition = target;
+  }
+  target._optimisticNodes.push(...outgoing._optimisticNodes);
+  for (const store of outgoing._optimisticStores) target._optimisticStores.add(store);
+  for (const node of outgoing._asyncNodes) {
+    if (!target._asyncNodes.includes(node)) target._asyncNodes.push(node);
+  }
+}
+function resolveOptimisticNodes(nodes) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    node._optimisticLane = undefined;
+    if (node._pendingValue !== NOT_PENDING) {
+      node._value = node._pendingValue;
+      node._pendingValue = NOT_PENDING;
+    }
+    const prevOverride = node._overrideValue;
+    node._overrideValue = NOT_PENDING;
+    if (prevOverride !== NOT_PENDING && node._value !== prevOverride) insertSubs(node, true);
+    node._transition = null;
+  }
+  nodes.length = 0;
+}
+function cleanupCompletedLanes(completingTransition) {
+  for (const lane of activeLanes) {
+    const owned = completingTransition
+      ? lane._transition === completingTransition
+      : !lane._transition;
+    if (!owned) continue;
+    if (!lane._mergedInto) {
+      if (lane._effectQueues[0].length) runQueue(lane._effectQueues[0], EFFECT_RENDER);
+      if (lane._effectQueues[1].length) runQueue(lane._effectQueues[1], EFFECT_USER);
+    }
+    if (lane._source._optimisticLane === lane) lane._source._optimisticLane = undefined;
+    lane._pendingAsync.clear();
+    lane._effectQueues[0].length = 0;
+    lane._effectQueues[1].length = 0;
+    activeLanes.delete(lane);
+    signalLanes.delete(lane._source);
+  }
+}
 function schedule() {
   if (scheduled) return;
   scheduled = true;
   if (!globalQueue._running && !projectionWriteActive) queueMicrotask(flush);
 }
+function addTransitionBlocker(node) {
+  if (activeTransition && !activeTransition._asyncNodes.includes(node)) {
+    activeTransition._asyncNodes.push(node);
+  }
+}
+function removeTransitionBlocker(node) {
+  const remove = list => {
+    if (!list) return;
+    const index = list.indexOf(node);
+    if (index >= 0) list.splice(index, 1);
+  };
+  remove(node._transition?._asyncNodes);
+  remove(activeTransition?._asyncNodes);
+}
 class Queue {
   _parent = null;
   _queues = [[], []];
@@ -256,19 +335,32 @@ class GlobalQueue extends Queue {
       if (activeTransition) {
         const isComplete = transitionComplete(activeTransition);
         if (!isComplete) {
-          let t = activeTransition;
+          const stashedTransition = activeTransition;
           runHeap(zombieQueue, GlobalQueue._update);
           this._pendingNodes = [];
           this._optimisticNodes = [];
           this._optimisticStores = new Set();
           runLaneEffects(EFFECT_RENDER);
           runLaneEffects(EFFECT_USER);
-          this.stashQueues(activeTransition._queueStash);
+          this.stashQueues(stashedTransition._queueStash);
           clock++;
           scheduled = dirtyQueue._max >= dirtyQueue._min;
-          reassignPendingTransition(activeTransition._pendingNodes);
+          reassignPendingTransition(stashedTransition._pendingNodes);
           activeTransition = null;
-          finalizePureQueue(null, true);
+          if (!stashedTransition._actions.length && stashedTransition._optimisticNodes.length) {
+            stashedOptimisticReads = new Set();
+            for (let i = 0; i < stashedTransition._optimisticNodes.length; i++) {
+              const node = stashedTransition._optimisticNodes[i];
+              if (node._fn || node._pureWrite) continue;
+              stashedOptimisticReads.add(node);
+              queueStashedOptimisticEffects(node);
+            }
+          }
+          try {
+            finalizePureQueue(null, true);
+          } finally {
+            stashedOptimisticReads = null;
+          }
           return;
         }
         this._pendingNodes !== activeTransition._pendingNodes &&
@@ -297,13 +389,12 @@ class GlobalQueue extends Queue {
     if (mask & STATUS_PENDING) {
       if (flags & STATUS_PENDING) {
         const actualError = error !== undefined ? error : node._error;
-        if (
-          activeTransition &&
-          actualError &&
-          !activeTransition._asyncNodes.includes(actualError.source)
-        ) {
-          activeTransition._asyncNodes.push(actualError.source);
-          schedule();
+        if (activeTransition && actualError) {
+          const source = actualError.source;
+          if (!activeTransition._asyncNodes.includes(source)) {
+            activeTransition._asyncNodes.push(source);
+            schedule();
+          }
         }
         if (_enforceLoadingBoundary) _hitUnhandledAsync = true;
       }
@@ -328,37 +419,35 @@ class GlobalQueue extends Queue {
       };
     } else if (transition) {
       const outgoing = activeTransition;
-      outgoing._done = transition;
-      transition._actions.push(...outgoing._actions);
-      for (const lane of activeLanes) {
-        if (lane._transition === outgoing) lane._transition = transition;
-      }
-      transition._optimisticNodes.push(...outgoing._optimisticNodes);
-      for (const store of outgoing._optimisticStores) {
-        transition._optimisticStores.add(store);
-      }
+      mergeTransitionState(transition, outgoing);
       transitions.delete(outgoing);
       activeTransition = transition;
     }
     transitions.add(activeTransition);
     activeTransition._time = clock;
-    for (let i = 0; i < this._pendingNodes.length; i++) {
-      const n = this._pendingNodes[i];
-      n._transition = activeTransition;
-      activeTransition._pendingNodes.push(n);
-    }
-    this._pendingNodes = activeTransition._pendingNodes;
-    for (let i = 0; i < this._optimisticNodes.length; i++) {
-      const node = this._optimisticNodes[i];
-      node._transition = activeTransition;
-      activeTransition._optimisticNodes.push(node);
-    }
-    this._optimisticNodes = activeTransition._optimisticNodes;
+    if (this._pendingNodes !== activeTransition._pendingNodes) {
+      for (let i = 0; i < this._pendingNodes.length; i++) {
+        const node = this._pendingNodes[i];
+        node._transition = activeTransition;
+        activeTransition._pendingNodes.push(node);
+      }
+      this._pendingNodes = activeTransition._pendingNodes;
+    }
+    if (this._optimisticNodes !== activeTransition._optimisticNodes) {
+      for (let i = 0; i < this._optimisticNodes.length; i++) {
+        const node = this._optimisticNodes[i];
+        node._transition = activeTransition;
+        activeTransition._optimisticNodes.push(node);
+      }
+      this._optimisticNodes = activeTransition._optimisticNodes;
+    }
     for (const lane of activeLanes) {
       if (!lane._transition) lane._transition = activeTransition;
     }
-    for (const store of this._optimisticStores) activeTransition._optimisticStores.add(store);
-    this._optimisticStores = activeTransition._optimisticStores;
+    if (this._optimisticStores !== activeTransition._optimisticStores) {
+      for (const store of this._optimisticStores) activeTransition._optimisticStores.add(store);
+      this._optimisticStores = activeTransition._optimisticStores;
+    }
   }
 }
 function insertSubs(node, optimistic = false) {
@@ -398,40 +487,21 @@ function commitPendingNodes() {
       n._pendingValue = NOT_PENDING;
       if (n._type && n._type !== EFFECT_TRACKED) n._modified = true;
     }
-    if (n._statusFlags & STATUS_PENDING) {
-      const _src = n._error?.source;
-      if (_src && !(_src._statusFlags & STATUS_PENDING)) {
-        n._statusFlags &= -6;
-        n._error = null;
-      }
-    } else n._statusFlags &= ~STATUS_UNINITIALIZED;
+    if (!(n._statusFlags & STATUS_PENDING)) n._statusFlags &= ~STATUS_UNINITIALIZED;
     if (n._fn) GlobalQueue._dispose(n, false, true);
   }
   pendingNodes.length = 0;
 }
 function finalizePureQueue(completingTransition = null, incomplete = false) {
-  let resolvePending = !incomplete;
+  const resolvePending = !incomplete;
   if (resolvePending) commitPendingNodes();
   if (!incomplete) checkBoundaryChildren(globalQueue);
   if (dirtyQueue._max >= dirtyQueue._min) runHeap(dirtyQueue, GlobalQueue._update);
   if (resolvePending) {
     commitPendingNodes();
-    const optimisticNodes = completingTransition
-      ? completingTransition._optimisticNodes
-      : globalQueue._optimisticNodes;
-    for (let i = 0; i < optimisticNodes.length; i++) {
-      const n = optimisticNodes[i];
-      n._optimisticLane = undefined;
-      if (n._pendingValue !== NOT_PENDING) {
-        n._value = n._pendingValue;
-        n._pendingValue = NOT_PENDING;
-      }
-      const prevOverride = n._overrideValue;
-      n._overrideValue = NOT_PENDING;
-      if (prevOverride !== NOT_PENDING && n._value !== prevOverride) insertSubs(n, true);
-      n._transition = null;
-    }
-    optimisticNodes.length = 0;
+    resolveOptimisticNodes(
+      completingTransition ? completingTransition._optimisticNodes : globalQueue._optimisticNodes
+    );
     const optimisticStores = completingTransition
       ? completingTransition._optimisticStores
       : globalQueue._optimisticStores;
@@ -442,22 +512,7 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
       optimisticStores.clear();
       schedule();
     }
-    for (const lane of activeLanes) {
-      const owned = completingTransition
-        ? lane._transition === completingTransition
-        : !lane._transition;
-      if (!owned) continue;
-      if (!lane._mergedInto) {
-        if (lane._effectQueues[0].length) runQueue(lane._effectQueues[0], EFFECT_RENDER);
-        if (lane._effectQueues[1].length) runQueue(lane._effectQueues[1], EFFECT_USER);
-      }
-      if (lane._source._optimisticLane === lane) lane._source._optimisticLane = undefined;
-      lane._pendingAsync.clear();
-      lane._effectQueues[0].length = 0;
-      lane._effectQueues[1].length = 0;
-      activeLanes.delete(lane);
-      signalLanes.delete(lane._source);
-    }
+    cleanupCompletedLanes(completingTransition);
   }
 }
 function checkBoundaryChildren(queue) {
@@ -478,7 +533,7 @@ function reassignPendingTransition(pendingNodes) {
 const globalQueue = new GlobalQueue();
 function flush() {
   let count = 0;
-  while (scheduled) {
+  while (scheduled || activeTransition) {
     if (++count === 1e5) throw new Error("Potential Infinite Loop Detected.");
     globalQueue.flush();
   }
@@ -560,6 +615,9 @@ function resolveLane(el) {
   el._optimisticLane = undefined;
   return undefined;
 }
+function resolveTransition(el) {
+  return resolveLane(el)?._transition ?? el._transition;
+}
 function hasActiveOverride(el) {
   return !!(el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING);
 }
@@ -584,6 +642,96 @@ function assignOrMergeLane(el, sourceLane) {
   }
   el._optimisticLane = sourceLane;
 }
+function addPendingSource(el, source) {
+  if (el._pendingSource === source || el._pendingSources?.has(source)) return false;
+  if (!el._pendingSource) {
+    el._pendingSource = source;
+    return true;
+  }
+  if (!el._pendingSources) {
+    el._pendingSources = new Set([el._pendingSource, source]);
+  } else {
+    el._pendingSources.add(source);
+  }
+  el._pendingSource = undefined;
+  return true;
+}
+function removePendingSource(el, source) {
+  if (el._pendingSource) {
+    if (el._pendingSource !== source) return false;
+    el._pendingSource = undefined;
+    return true;
+  }
+  if (!el._pendingSources?.delete(source)) return false;
+  if (el._pendingSources.size === 1) {
+    el._pendingSource = el._pendingSources.values().next().value;
+    el._pendingSources = undefined;
+  } else if (el._pendingSources.size === 0) {
+    el._pendingSources = undefined;
+  }
+  return true;
+}
+function clearPendingSources(el) {
+  el._pendingSource = undefined;
+  el._pendingSources?.clear();
+  el._pendingSources = undefined;
+}
+function setPendingError(el, source, error) {
+  if (!source) {
+    el._error = null;
+    return;
+  }
+  if (error instanceof NotReadyError && error.source === source) {
+    el._error = error;
+    return;
+  }
+  const current = el._error;
+  if (!(current instanceof NotReadyError) || current.source !== source) {
+    el._error = new NotReadyError(source);
+  }
+}
+function forEachDependent(el, fn) {
+  for (let s = el._subs; s !== null; s = s._nextSub) fn(s._sub);
+  for (let child = el._child; child !== null; child = child._nextChild) {
+    for (let s = child._subs; s !== null; s = s._nextSub) fn(s._sub);
+  }
+}
+function settlePendingSource(el) {
+  let scheduled = false;
+  const visited = new Set();
+  const settle = node => {
+    if (visited.has(node) || !removePendingSource(node, el)) return;
+    visited.add(node);
+    node._time = clock;
+    const source = node._pendingSource ?? node._pendingSources?.values().next().value;
+    if (source) {
+      setPendingError(node, source);
+      updatePendingSignal(node);
+    } else {
+      node._statusFlags &= ~STATUS_PENDING;
+      setPendingError(node);
+      updatePendingSignal(node);
+      if (node._blocked) {
+        if (node._type === EFFECT_TRACKED) {
+          const tracked = node;
+          if (!tracked._modified) {
+            tracked._modified = true;
+            tracked._queue.enqueue(EFFECT_USER, tracked._run);
+          }
+        } else {
+          const queue = node._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+          if (queue._min > node._height) queue._min = node._height;
+          insertIntoHeap(node, queue);
+        }
+        scheduled = true;
+      }
+      node._blocked = false;
+    }
+    forEachDependent(node, settle);
+  };
+  forEachDependent(el, settle);
+  if (scheduled) schedule();
+}
 function handleAsync(el, result, setter) {
   const isObject = typeof result === "object" && result !== null;
   const iterator = isObject && untrack(() => result[Symbol.asyncIterator]);
@@ -596,14 +744,14 @@ function handleAsync(el, result, setter) {
   let syncValue;
   const handleError = error => {
     if (el._inFlight !== result) return;
-    globalQueue.initTransition(el._transition);
+    globalQueue.initTransition(resolveTransition(el));
     notifyStatus(el, error instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, error);
     el._time = clock;
   };
   const asyncWrite = (value, then) => {
     if (el._inFlight !== result) return;
     if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-    globalQueue.initTransition(el._transition);
+    globalQueue.initTransition(resolveTransition(el));
     clearStatus(el);
     const lane = resolveLane(el);
     if (lane) lane._pendingAsync.delete(el);
@@ -630,6 +778,7 @@ function handleAsync(el, result, setter) {
     } else {
       setSignal(el, () => value);
     }
+    settlePendingSource(el);
     schedule();
     flush();
     then?.();
@@ -650,7 +799,7 @@ function handleAsync(el, result, setter) {
     );
     isSync = false;
     if (!resolved) {
-      globalQueue.initTransition(el._transition);
+      globalQueue.initTransition(resolveTransition(el));
       throw new NotReadyError(context);
     }
   }
@@ -686,15 +835,18 @@ function handleAsync(el, result, setter) {
     };
     const immediatelyDone = iterate();
     if (!hadSyncValue && !immediatelyDone) {
-      globalQueue.initTransition(el._transition);
+      globalQueue.initTransition(resolveTransition(el));
       throw new NotReadyError(context);
     }
   }
   return syncValue;
 }
-function clearStatus(el) {
-  el._statusFlags = el._statusFlags & STATUS_UNINITIALIZED;
-  el._error = null;
+function clearStatus(el, clearUninitialized = false) {
+  clearPendingSources(el);
+  removeTransitionBlocker(el);
+  el._blocked = false;
+  el._statusFlags = clearUninitialized ? 0 : el._statusFlags & STATUS_UNINITIALIZED;
+  setPendingError(el);
   updatePendingSignal(el);
   el._notifyStatus?.();
 }
@@ -705,25 +857,30 @@ function notifyStatus(el, status, error, blockStatus, lane) {
     !(error instanceof NotReadyError)
   )
     error = new StatusError(el, error);
-  const isSource = error instanceof NotReadyError && error.source === el;
+  const pendingSource =
+    status === STATUS_PENDING && error instanceof NotReadyError ? error.source : undefined;
+  const isSource = pendingSource === el;
   const isOptimisticBoundary =
     status === STATUS_PENDING && el._overrideValue !== undefined && !isSource;
   const startsBlocking = isOptimisticBoundary && hasActiveOverride(el);
   if (!blockStatus) {
-    el._statusFlags =
-      status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
-    el._error = error;
+    if (status === STATUS_PENDING && pendingSource) {
+      addPendingSource(el, pendingSource);
+      el._statusFlags = STATUS_PENDING | (el._statusFlags & STATUS_UNINITIALIZED);
+      setPendingError(el, el._pendingSource ?? el._pendingSources?.values().next().value, error);
+      if (pendingSource === el) addTransitionBlocker(el);
+    } else {
+      clearPendingSources(el);
+      removeTransitionBlocker(el);
+      el._statusFlags =
+        status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
+      el._error = error;
+    }
     updatePendingSignal(el);
   }
   if (lane && !blockStatus) {
     assignOrMergeLane(el, lane);
   }
-  if (startsBlocking && activeTransition && error instanceof NotReadyError) {
-    const source = error.source;
-    if (!activeTransition._asyncNodes.includes(source)) {
-      activeTransition._asyncNodes.push(source);
-    }
-  }
   const downstreamBlockStatus = blockStatus || startsBlocking;
   const downstreamLane = blockStatus || isOptimisticBoundary ? undefined : lane;
   if (el._notifyStatus) {
@@ -734,84 +891,43 @@ function notifyStatus(el, status, error, blockStatus, lane) {
     }
     return;
   }
-  for (let s = el._subs; s !== null; s = s._nextSub) {
-    s._sub._time = clock;
-    if (s._sub._error !== error) {
-      !s._sub._transition && globalQueue._pendingNodes.push(s._sub);
-      notifyStatus(s._sub, status, error, downstreamBlockStatus, downstreamLane);
-    }
-  }
-  for (let child = el._child; child !== null; child = child._nextChild) {
-    for (let s = child._subs; s !== null; s = s._nextSub) {
-      s._sub._time = clock;
-      if (s._sub._error !== error) {
-        !s._sub._transition && globalQueue._pendingNodes.push(s._sub);
-        notifyStatus(s._sub, status, error, downstreamBlockStatus, downstreamLane);
-      }
+  forEachDependent(el, sub => {
+    sub._time = clock;
+    if (
+      (status === STATUS_PENDING &&
+        pendingSource &&
+        sub._pendingSource !== pendingSource &&
+        !sub._pendingSources?.has(pendingSource)) ||
+      (status !== STATUS_PENDING &&
+        (sub._error !== error || sub._pendingSource || sub._pendingSources))
+    ) {
+      !sub._transition && globalQueue._pendingNodes.push(sub);
+      notifyStatus(sub, status, error, downstreamBlockStatus, downstreamLane);
     }
-  }
-}
-function unlinkSubs(link) {
-  const dep = link._dep;
-  const nextDep = link._nextDep;
-  const nextSub = link._nextSub;
-  const prevSub = link._prevSub;
-  if (nextSub !== null) nextSub._prevSub = prevSub;
-  else dep._subsTail = prevSub;
-  if (prevSub !== null) prevSub._nextSub = nextSub;
-  else {
-    dep._subs = nextSub;
-    if (nextSub === null) {
-      dep._unobserved?.();
-      dep._fn && !dep._preventAutoDisposal && !(dep._flags & REACTIVE_ZOMBIE) && unobserved(dep);
-    }
-  }
-  return nextDep;
-}
-function unobserved(el) {
-  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-  let dep = el._deps;
-  while (dep !== null) {
-    dep = unlinkSubs(dep);
-  }
-  el._deps = null;
-  disposeChildren(el, true);
-}
-function link(dep, sub) {
-  const prevDep = sub._depsTail;
-  if (prevDep !== null && prevDep._dep === dep) return;
-  let nextDep = null;
-  const isRecomputing = sub._flags & REACTIVE_RECOMPUTING_DEPS;
-  if (isRecomputing) {
-    nextDep = prevDep !== null ? prevDep._nextDep : sub._deps;
-    if (nextDep !== null && nextDep._dep === dep) {
-      sub._depsTail = nextDep;
-      return;
-    }
-  }
-  const prevSub = dep._subsTail;
-  if (prevSub !== null && prevSub._sub === sub && (!isRecomputing || isValidLink(prevSub, sub)))
-    return;
-  const newLink =
-    (sub._depsTail =
-    dep._subsTail =
-      { _dep: dep, _sub: sub, _nextDep: nextDep, _prevSub: prevSub, _nextSub: null });
-  if (prevDep !== null) prevDep._nextDep = newLink;
-  else sub._deps = newLink;
-  if (prevSub !== null) prevSub._nextSub = newLink;
-  else dep._subs = newLink;
+  });
 }
-function isValidLink(checkLink, sub) {
-  const depsTail = sub._depsTail;
-  if (depsTail !== null) {
-    let link = sub._deps;
-    do {
-      if (link === checkLink) return true;
-      if (link === depsTail) break;
-      link = link._nextDep;
-    } while (link !== null);
+let externalSourceConfig = null;
+function enableExternalSource(config) {
+  const { factory: factory, untrack: untrackFn = fn => fn() } = config;
+  if (externalSourceConfig) {
+    const { factory: oldFactory, untrack: oldUntrack } = externalSourceConfig;
+    externalSourceConfig = {
+      factory: (fn, trigger) => {
+        const oldSource = oldFactory(fn, trigger);
+        const source = factory(x => oldSource.track(x), trigger);
+        return {
+          track: x => source.track(x),
+          dispose() {
+            source.dispose();
+            oldSource.dispose();
+          }
+        };
+      },
+      untrack: fn => oldUntrack(() => untrackFn(fn))
+    };
+  } else {
+    externalSourceConfig = { factory: factory, untrack: untrackFn };
   }
-  return false;
 }
 const PENDING_OWNER = {};
 function markDisposal(el) {
@@ -900,7 +1016,7 @@ function getObserver() {
 function getOwner() {
   return context;
 }
-function onCleanup(fn) {
+function cleanup(fn) {
   if (!context) return fn;
   if (!context._disposal) context._disposal = fn;
   else if (Array.isArray(context._disposal)) context._disposal.push(fn);
@@ -933,8 +1049,10 @@ function createOwner(options) {
       disposeChildren(owner, self);
     }
   };
-  if (leafEffectActive && parent) {
-    throw new Error("Cannot create reactive primitives inside createTrackedEffect");
+  if (parent?._childrenForbidden) {
+    throw new Error(
+      "Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled"
+    );
   }
   if (parent) {
     const lastChild = parent._firstChild;
@@ -951,136 +1069,67 @@ function createRoot(init, options) {
   const owner = createOwner(options);
   return runWithOwner(owner, () => init(owner.dispose));
 }
-let leafEffectActive = false;
-function effect(compute, effect, error, initialValue, options) {
-  let initialized = false;
-  const node = computed(
-    options?.render ? p => staleValues(() => compute(p)) : compute,
-    initialValue,
-    {
-      ...options,
-      equals: () => {
-        node._modified = !node._error;
-        if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
-        return false;
-      },
-      lazy: true
-    }
-  );
-  node._prevValue = initialValue;
-  node._effectFn = effect;
-  node._errorFn = error;
-  node._cleanup = undefined;
-  node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
-  node._notifyStatus = (status, error) => {
-    const actualStatus = status !== undefined ? status : node._statusFlags;
-    const actualError = error !== undefined ? error : node._error;
-    if (actualStatus & STATUS_ERROR) {
-      let err = actualError;
-      node._queue.notify(node, STATUS_PENDING, 0);
-      if (node._type === EFFECT_USER) {
-        try {
-          return node._errorFn
-            ? node._errorFn(err, () => {
-                node._cleanup?.();
-                node._cleanup = undefined;
-              })
-            : console.error(err);
-        } catch (e) {
-          err = e;
-        }
-      }
-      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
-    } else if (node._type === EFFECT_RENDER) {
-      node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
-      if (_hitUnhandledAsync) {
-        resetUnhandledAsync();
-        const err = new Error("An async value must be rendered inside a Loading boundary.");
-        if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
-      }
+function unlinkSubs(link) {
+  const dep = link._dep;
+  const nextDep = link._nextDep;
+  const nextSub = link._nextSub;
+  const prevSub = link._prevSub;
+  if (nextSub !== null) nextSub._prevSub = prevSub;
+  else dep._subsTail = prevSub;
+  if (prevSub !== null) prevSub._nextSub = nextSub;
+  else {
+    dep._subs = nextSub;
+    if (nextSub === null) {
+      dep._unobserved?.();
+      dep._fn && !dep._preventAutoDisposal && !(dep._flags & REACTIVE_ZOMBIE) && unobserved(dep);
     }
-  };
-  recompute(node, true);
-  !options?.defer &&
-    (node._type === EFFECT_USER
-      ? node._queue.enqueue(node._type, runEffect.bind(node))
-      : runEffect.call(node));
-  initialized = true;
-  onCleanup(() => node._cleanup?.());
-  if (!node._parent)
-    console.warn("Effects created outside a reactive context will never be disposed");
-}
-function runEffect() {
-  if (!this._modified || this._flags & REACTIVE_DISPOSED) return;
-  let prevStrictRead = false;
-  {
-    prevStrictRead = setStrictRead("an effect callback");
   }
-  this._cleanup?.();
-  this._cleanup = undefined;
-  try {
-    this._cleanup = this._effectFn(this._value, this._prevValue);
-  } catch (error) {
-    this._error = new StatusError(this, error);
-    this._statusFlags |= STATUS_ERROR;
-    if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw error;
-  } finally {
-    setStrictRead(prevStrictRead);
-    this._prevValue = this._value;
-    this._modified = false;
+  return nextDep;
+}
+function unobserved(el) {
+  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let dep = el._deps;
+  while (dep !== null) {
+    dep = unlinkSubs(dep);
   }
+  el._deps = null;
+  disposeChildren(el, true);
 }
-function trackedEffect(fn, options) {
-  const run = () => {
-    if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
-    node._modified = false;
-    recompute(node);
-  };
-  const node = computed(
-    () => {
-      leafEffectActive = true;
-      try {
-        node._cleanup?.();
-        node._cleanup = undefined;
-        node._cleanup = staleValues(fn) || undefined;
-      } finally {
-        leafEffectActive = false;
-      }
-    },
-    undefined,
-    { ...options, lazy: true }
-  );
-  node._cleanup = undefined;
-  node._modified = true;
-  node._type = EFFECT_TRACKED;
-  node._run = run;
-  node._queue.enqueue(EFFECT_USER, run);
-  onCleanup(() => node._cleanup?.());
-  if (!node._parent)
-    console.warn("Effects created outside a reactive context will never be disposed");
+function link(dep, sub) {
+  const prevDep = sub._depsTail;
+  if (prevDep !== null && prevDep._dep === dep) return;
+  let nextDep = null;
+  const isRecomputing = sub._flags & REACTIVE_RECOMPUTING_DEPS;
+  if (isRecomputing) {
+    nextDep = prevDep !== null ? prevDep._nextDep : sub._deps;
+    if (nextDep !== null && nextDep._dep === dep) {
+      sub._depsTail = nextDep;
+      return;
+    }
+  }
+  const prevSub = dep._subsTail;
+  if (prevSub !== null && prevSub._sub === sub && (!isRecomputing || isValidLink(prevSub, sub)))
+    return;
+  const newLink =
+    (sub._depsTail =
+    dep._subsTail =
+      { _dep: dep, _sub: sub, _nextDep: nextDep, _prevSub: prevSub, _nextSub: null });
+  if (prevDep !== null) prevDep._nextDep = newLink;
+  else sub._deps = newLink;
+  if (prevSub !== null) prevSub._nextSub = newLink;
+  else dep._subs = newLink;
 }
-let externalSourceConfig = null;
-function enableExternalSource(config) {
-  const { factory: factory, untrack: untrackFn = fn => fn() } = config;
-  if (externalSourceConfig) {
-    const { factory: oldFactory, untrack: oldUntrack } = externalSourceConfig;
-    externalSourceConfig = {
-      factory: (fn, trigger) => {
-        const oldSource = oldFactory(fn, trigger);
-        const source = factory(x => oldSource.track(x), trigger);
-        return {
-          track: x => source.track(x),
-          dispose() {
-            source.dispose();
-            oldSource.dispose();
-          }
-        };
-      },
-      untrack: fn => oldUntrack(() => untrackFn(fn))
-    };
-  } else {
-    externalSourceConfig = { factory: factory, untrack: untrackFn };
+function isValidLink(checkLink, sub) {
+  const depsTail = sub._depsTail;
+  if (depsTail !== null) {
+    let link = sub._deps;
+    do {
+      if (link === checkLink) return true;
+      if (link === depsTail) break;
+      link = link._nextDep;
+    } while (link !== null);
   }
+  return false;
 }
 GlobalQueue._update = recompute;
 GlobalQueue._dispose = disposeChildren;
@@ -1184,7 +1233,7 @@ function recompute(el, create = false) {
   }
   try {
     value = handleAsync(el, el._fn(value));
-    clearStatus(el);
+    clearStatus(el, create);
     const resolvedLane = resolveLane(el);
     if (resolvedLane) {
       resolvedLane._pendingAsync.delete(el);
@@ -1199,6 +1248,7 @@ function recompute(el, create = false) {
         updatePendingSignal(lane._source);
       }
     }
+    if (e instanceof NotReadyError) el._blocked = true;
     notifyStatus(
       el,
       e instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
@@ -1319,8 +1369,10 @@ function computed(fn, initialValue, options) {
   self._name = options?.name ?? "computed";
   self._prevHeap = self;
   const parent = context?._root ? context._parentComputed : context;
-  if (leafEffectActive && context) {
-    throw new Error("Cannot create reactive primitives inside createTrackedEffect");
+  if (context?._childrenForbidden) {
+    throw new Error(
+      "Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled"
+    );
   }
   if (context) {
     const lastChild = context._firstChild;
@@ -1338,7 +1390,7 @@ function computed(fn, initialValue, options) {
     const source = externalSourceConfig.factory(self._fn, () => {
       setSignal(bridgeSignal, undefined);
     });
-    onCleanup(() => source.dispose());
+    cleanup(() => source.dispose());
     self._fn = prev => {
       read(bridgeSignal);
       return source.track(prev);
@@ -1441,12 +1493,19 @@ function read(el) {
     return value;
   }
   if (pendingCheckActive) {
-    const target = el._firewall || el;
-    const pendingSig = getPendingSignal(target);
+    const firewall = el._firewall;
     const prevCheck = pendingCheckActive;
     pendingCheckActive = false;
-    if (read(pendingSig)) {
-      foundPending = true;
+    if (firewall && el._overrideValue !== undefined) {
+      if (
+        el._overrideValue !== NOT_PENDING &&
+        (firewall._inFlight || !!(firewall._statusFlags & STATUS_PENDING))
+      ) {
+        foundPending = true;
+      }
+    } else {
+      if (read(getPendingSignal(el))) foundPending = true;
+      if (firewall && read(getPendingSignal(firewall))) foundPending = true;
     }
     pendingCheckActive = prevCheck;
     return el._value;
@@ -1482,9 +1541,13 @@ function read(el) {
     }
   }
   if (owner._statusFlags & STATUS_PENDING) {
-    const _errSource = owner._error?.source;
-    if (_errSource && !(_errSource._statusFlags & STATUS_PENDING)) clearStatus(owner);
-    else if (c && !(stale && owner._transition && activeTransition !== owner._transition)) {
+    if (c && !(stale && owner._transition && activeTransition !== owner._transition)) {
+      if (c?._childrenForbidden) {
+        console.warn(
+          "Reading a pending async value inside createTrackedEffect or onSettled will throw. " +
+            "Use createEffect instead which supports async-aware reactivity."
+        );
+      }
       if (currentOptimisticLane) {
         const pendingLane = owner._optimisticLane;
         const lane = findLane(currentOptimisticLane);
@@ -1520,8 +1583,10 @@ function read(el) {
       `Reactive value read directly in ${strictRead} will not update. ` +
         `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`
     );
-  if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING)
+  if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING) {
+    if (c && stale && shouldReadStashedOptimisticValue(el)) return el._value;
     return el._overrideValue;
+  }
   return !c ||
     (currentOptimisticLane !== null &&
       (el._overrideValue !== undefined ||
@@ -1534,7 +1599,7 @@ function read(el) {
     : el._pendingValue;
 }
 function setSignal(el, v) {
-  if (!el._pureWrite && !leafEffectActive && context && el._firewall !== context)
+  if (!el._pureWrite && !context?._childrenForbidden && context && el._firewall !== context)
     console.warn("A Signal was written to in an owned scope.");
   if (el._transition && activeTransition !== el._transition)
     globalQueue.initTransition(el._transition);
@@ -1559,7 +1624,7 @@ function setSignal(el, v) {
   }
   if (isOptimistic) {
     const firstOverride = el._overrideValue === NOT_PENDING;
-    if (!firstOverride && el._transition) globalQueue.initTransition(el._transition);
+    if (!firstOverride) globalQueue.initTransition(resolveTransition(el));
     if (firstOverride) {
       el._pendingValue = el._value;
       globalQueue._optimisticNodes.push(el);
@@ -1582,6 +1647,10 @@ function setSignal(el, v) {
   return v;
 }
 function runWithOwner(owner, fn) {
+  if (owner && owner._flags & REACTIVE_DISPOSED)
+    console.warn(
+      "runWithOwner called with a disposed owner. Children created inside will never be disposed."
+    );
   const oldContext = context;
   const prevTracking = tracking;
   context = owner;
@@ -1605,6 +1674,10 @@ function getPendingSignal(el) {
 }
 function computePendingState(el) {
   const comp = el;
+  const firewall = el._firewall;
+  if (firewall && el._pendingValue !== NOT_PENDING) {
+    return !firewall._inFlight && !(firewall._statusFlags & STATUS_PENDING);
+  }
   if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING) {
     if (comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED))
       return true;
@@ -1614,6 +1687,9 @@ function computePendingState(el) {
     }
     return true;
   }
+  if (el._overrideValue !== undefined && el._overrideValue === NOT_PENDING && !el._parentSource) {
+    return false;
+  }
   if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) return true;
   return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));
 }
@@ -1731,6 +1807,117 @@ function hasContext(context, owner) {
 function isUndefined(value) {
   return typeof value === "undefined";
 }
+function effect(compute, effect, error, initialValue, options) {
+  let initialized = false;
+  const node = computed(
+    options?.render ? p => staleValues(() => compute(p)) : compute,
+    initialValue,
+    {
+      ...options,
+      equals: () => {
+        node._modified = !node._error;
+        if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
+        return false;
+      },
+      lazy: true
+    }
+  );
+  node._prevValue = initialValue;
+  node._effectFn = effect;
+  node._errorFn = error;
+  node._cleanup = undefined;
+  node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
+  node._notifyStatus = (status, error) => {
+    const actualStatus = status !== undefined ? status : node._statusFlags;
+    const actualError = error !== undefined ? error : node._error;
+    if (actualStatus & STATUS_ERROR) {
+      let err = actualError;
+      node._queue.notify(node, STATUS_PENDING, 0);
+      if (node._type === EFFECT_USER) {
+        try {
+          return node._errorFn
+            ? node._errorFn(err, () => {
+                node._cleanup?.();
+                node._cleanup = undefined;
+              })
+            : console.error(err);
+        } catch (e) {
+          err = e;
+        }
+      }
+      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
+    } else if (node._type === EFFECT_RENDER) {
+      node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
+      if (_hitUnhandledAsync) {
+        resetUnhandledAsync();
+        const err = new Error("An async value must be rendered inside a Loading boundary.");
+        if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
+      }
+    }
+  };
+  recompute(node, true);
+  !options?.defer &&
+    (node._type === EFFECT_USER
+      ? node._queue.enqueue(node._type, runEffect.bind(node))
+      : runEffect.call(node));
+  initialized = true;
+  cleanup(() => node._cleanup?.());
+  if (!node._parent)
+    console.warn("Effects created outside a reactive context will never be disposed");
+}
+function runEffect() {
+  if (!this._modified || this._flags & REACTIVE_DISPOSED) return;
+  let prevStrictRead = false;
+  {
+    prevStrictRead = setStrictRead("an effect callback");
+  }
+  this._cleanup?.();
+  this._cleanup = undefined;
+  try {
+    this._cleanup = this._effectFn(this._value, this._prevValue);
+  } catch (error) {
+    this._error = new StatusError(this, error);
+    this._statusFlags |= STATUS_ERROR;
+    if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw error;
+  } finally {
+    setStrictRead(prevStrictRead);
+    this._prevValue = this._value;
+    this._modified = false;
+  }
+}
+function trackedEffect(fn, options) {
+  const run = () => {
+    if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
+    node._modified = false;
+    recompute(node);
+  };
+  const node = computed(
+    () => {
+      node._cleanup?.();
+      node._cleanup = undefined;
+      node._cleanup = staleValues(fn) || undefined;
+    },
+    undefined,
+    { ...options, lazy: true }
+  );
+  node._cleanup = undefined;
+  node._childrenForbidden = true;
+  node._modified = true;
+  node._type = EFFECT_TRACKED;
+  node._notifyStatus = (status, error) => {
+    const actualStatus = status !== undefined ? status : node._statusFlags;
+    if (actualStatus & STATUS_ERROR) {
+      node._queue.notify(node, STATUS_PENDING, 0);
+      const err = error !== undefined ? error : node._error;
+      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
+    }
+  };
+  node._run = run;
+  node._queue.enqueue(EFFECT_USER, run);
+  cleanup(() => node._cleanup?.());
+  if (!node._parent)
+    console.warn("Effects created outside a reactive context will never be disposed");
+}
 function restoreTransition(transition, fn) {
   globalQueue.initTransition(transition);
   const result = fn();
@@ -1775,6 +1962,17 @@ function action(genFn) {
       step();
     });
 }
+function onCleanup(fn) {
+  {
+    const owner = getOwner();
+    if (!owner) console.warn("onCleanup called outside a reactive context will never be run");
+    else if (owner._childrenForbidden)
+      throw new Error(
+        "Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead"
+      );
+  }
+  return cleanup(fn);
+}
 function accessor(node) {
   const fn = read.bind(null, node);
   fn.$r = true;
@@ -1808,16 +2006,16 @@ function createTrackedEffect(compute, options) {
   trackedEffect(compute, { ...options, name: options?.name ?? "trackedEffect" });
 }
 function createReaction(effectFn, options) {
-  let cleanup = undefined;
-  onCleanup(() => cleanup?.());
+  let cl = undefined;
+  cleanup(() => cl?.());
   const owner = getOwner();
   return tracking => {
     runWithOwner(owner, () => {
       effect(
         () => (tracking(), getOwner()),
         node => {
-          cleanup?.();
-          cleanup = (effectFn.effect || effectFn)?.();
+          cl?.();
+          cl = (effectFn.effect || effectFn)?.();
           dispose(node);
         },
         effectFn.error,
@@ -1828,6 +2026,11 @@ function createReaction(effectFn, options) {
   };
 }
 function resolve(fn) {
+  if (getObserver()) {
+    throw new Error(
+      "Cannot call resolve inside a reactive scope; it only resolves the current value and does not track updates."
+    );
+  }
   return new Promise((res, rej) => {
     createRoot(dispose => {
       computed(() => {
@@ -1850,7 +2053,8 @@ function createOptimistic(first, second, third) {
   return [accessor(node), setSignal.bind(null, node)];
 }
 function onSettled(callback) {
-  getOwner()
+  const owner = getOwner();
+  owner && !owner._childrenForbidden
     ? createTrackedEffect(() => untrack(callback))
     : globalQueue.enqueue(EFFECT_USER, () => {
         const cleanup = callback();
@@ -2025,8 +2229,16 @@ function createProjectionInternal(fn, initialValue = {}, options) {
   const wrappedStore = wrapProjection(initialValue);
   node = computed(() => {
     const owner = getOwner();
-    storeSetter(new Proxy(wrappedStore, writeTraps), s => {
-      const value = handleAsync(owner, fn(s), value => {
+    let settled = false;
+    let result;
+    const draft = new Proxy(
+      wrappedStore,
+      createWriteTraps(() => !settled || owner._inFlight === result)
+    );
+    storeSetter(draft, s => {
+      result = fn(s);
+      settled = true;
+      const value = handleAsync(owner, result, value => {
         value !== s &&
           value !== undefined &&
           storeSetter(wrappedStore, reconcile(value, options?.key || "id"));
@@ -2040,42 +2252,47 @@ function createProjectionInternal(fn, initialValue = {}, options) {
 function createProjection(fn, initialValue = {}, options) {
   return createProjectionInternal(fn, initialValue, options).store;
 }
-const writeTraps = {
-  get(_, prop) {
-    let value;
-    setWriteOverride(true);
-    setProjectionWriteActive(true);
-    try {
-      value = _[prop];
-    } finally {
-      setWriteOverride(false);
-      setProjectionWriteActive(false);
-    }
-    return typeof value === "object" && value !== null ? new Proxy(value, writeTraps) : value;
-  },
-  set(_, prop, value) {
-    setWriteOverride(true);
-    setProjectionWriteActive(true);
-    try {
-      _[prop] = value;
-    } finally {
-      setWriteOverride(false);
-      setProjectionWriteActive(false);
-    }
-    return true;
-  },
-  deleteProperty(_, prop) {
-    setWriteOverride(true);
-    setProjectionWriteActive(true);
-    try {
-      delete _[prop];
-    } finally {
-      setWriteOverride(false);
-      setProjectionWriteActive(false);
+function createWriteTraps(isActive) {
+  const traps = {
+    get(_, prop) {
+      let value;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        value = _[prop];
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(false);
+      }
+      return typeof value === "object" && value !== null ? new Proxy(value, traps) : value;
+    },
+    set(_, prop, value) {
+      if (isActive && !isActive()) return true;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        _[prop] = value;
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(false);
+      }
+      return true;
+    },
+    deleteProperty(_, prop) {
+      if (isActive && !isActive()) return true;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        delete _[prop];
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(false);
+      }
+      return true;
     }
-    return true;
-  }
-};
+  };
+  return traps;
+}
 const $TRACK = Symbol("STORE_TRACK"),
   $TARGET = Symbol("STORE_TARGET"),
   $PROXY = Symbol("STORE_PROXY"),
@@ -2485,10 +2702,18 @@ function createOptimisticProjectionInternal(fn, initialValue = {}, options) {
   if (fn) {
     node = computed(() => {
       const owner = getOwner();
+      let settled = false;
+      let result;
+      const draft = new Proxy(
+        wrappedStore,
+        createWriteTraps(() => !settled || owner._inFlight === result)
+      );
       setProjectionWriteActive(true);
       try {
-        storeSetter(new Proxy(wrappedStore, writeTraps), s => {
-          const value = handleAsync(owner, fn(s), value => {
+        storeSetter(draft, s => {
+          result = fn(s);
+          settled = true;
+          const value = handleAsync(owner, result, value => {
             setProjectionWriteActive(true);
             try {
               value !== s &&
@@ -3013,7 +3238,7 @@ function boundaryComputed(fn, propagationMask) {
 function createBoundChildren(owner, fn, queue, mask) {
   const parentQueue = owner._queue;
   parentQueue.addChild((owner._queue = queue));
-  onCleanup(() => parentQueue.removeChild(owner._queue));
+  cleanup(() => parentQueue.removeChild(owner._queue));
   return runWithOwner(owner, () => {
     const c = computed(fn);
     return boundaryComputed(() => staleValues(() => flatten(read(c))), mask);
@@ -3053,6 +3278,9 @@ class CollectionQueue extends Queue {
     }
     if (this._collectionType & STATUS_PENDING && this._initialized)
       return super.notify(node, type, flags, error);
+    if (this._collectionType & STATUS_PENDING && flags & STATUS_ERROR) {
+      return super.notify(node, STATUS_ERROR, flags, error);
+    }
     if (flags & this._collectionType) {
       const source = error?.source || node._error?.source;
       if (source) {
@@ -3066,7 +3294,11 @@ class CollectionQueue extends Queue {
   }
   checkSources() {
     for (const source of this._sources) {
-      if (!(source._statusFlags & this._collectionType)) this._sources.delete(source);
+      if (
+        !(source._statusFlags & this._collectionType) &&
+        !(this._collectionType & STATUS_ERROR && source._statusFlags & STATUS_PENDING)
+      )
+        this._sources.delete(source);
     }
     if (!this._sources.size) {
       setSignal(this._disabled, false);
@@ -3079,6 +3311,8 @@ class CollectionQueue extends Queue {
   }
 }
 function createCollectionBoundary(type, fn, fallback, onFn) {
+  if (!getOwner())
+    console.warn("Boundaries created outside a reactive context will never be disposed.");
   const owner = createOwner();
   const queue = new CollectionQueue(type);
   if (onFn) queue._onFn = onFn;