@solidjs/signals 0.13.2 → 0.13.4

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);
-      }
-    }
-  }
-}
-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;
+  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);
     }
-  }
-  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) {
@@ -901,7 +1017,15 @@ function getOwner() {
   return context;
 }
 function onCleanup(fn) {
-  if (!context) return fn;
+  if (!context) {
+    console.warn("onCleanup called outside a reactive context will never be run");
+    return fn;
+  }
+  if (context._childrenForbidden) {
+    throw new Error(
+      "Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead"
+    );
+  }
   if (!context._disposal) context._disposal = fn;
   else if (Array.isArray(context._disposal)) context._disposal.push(fn);
   else context._disposal = [context._disposal, fn];
@@ -933,8 +1057,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 +1077,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 +1241,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 +1256,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 +1377,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;
@@ -1357,6 +1417,7 @@ function signal(v, options, firewall = null) {
   const s = {
     _equals: options?.equals != null ? options.equals : isEqual,
     _pureWrite: !!options?.pureWrite,
+    _noSnapshot: !!options?._noSnapshot,
     _unobserved: options?.unobserved,
     _value: v,
     _subs: null,
@@ -1368,7 +1429,11 @@ function signal(v, options, firewall = null) {
   };
   s._name = options?.name ?? "signal";
   firewall && (firewall._child = s);
-  if (snapshotCaptureActive && !s._pureWrite && !((firewall?._statusFlags ?? 0) & STATUS_PENDING)) {
+  if (
+    snapshotCaptureActive &&
+    !s._noSnapshot &&
+    !((firewall?._statusFlags ?? 0) & STATUS_PENDING)
+  ) {
     s._snapshotValue = v === undefined ? NO_SNAPSHOT : v;
     snapshotSources.add(s);
   }
@@ -1436,13 +1501,11 @@ 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 (read(getPendingSignal(el))) foundPending = true;
+    if (firewall && read(getPendingSignal(firewall))) foundPending = true;
     pendingCheckActive = prevCheck;
     return el._value;
   }
@@ -1477,9 +1540,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);
@@ -1515,8 +1582,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 ||
@@ -1529,7 +1598,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);
@@ -1554,7 +1623,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);
@@ -1577,6 +1646,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;
@@ -1600,6 +1673,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;
@@ -1726,6 +1803,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;
+  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;
+  }
+}
+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);
+  onCleanup(() => 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();
@@ -1823,6 +2011,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(() => {
@@ -1845,7 +2038,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();
@@ -3018,7 +3212,7 @@ const ON_INIT = Symbol();
 class CollectionQueue extends Queue {
   _collectionType;
   _sources = new Set();
-  _disabled = signal(false, { pureWrite: true });
+  _disabled = signal(false, { pureWrite: true, _noSnapshot: true });
   _initialized = false;
   _onFn;
   _prevOn = ON_INIT;
@@ -3048,6 +3242,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) {
@@ -3061,7 +3258,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);
@@ -3074,6 +3275,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;