@solidjs/signals 0.9.8 → 0.9.10

package/dist/dev.js

@@ -1,8 +1,15 @@
 class NotReadyError extends Error {
-  cause;
-  constructor(cause) {
+  _source;
+  constructor(_source) {
     super();
-    this.cause = cause;
+    this._source = _source;
+  }
+}
+class StatusError extends Error {
+  _source;
+  constructor(_source, original) {
+    super(original instanceof Error ? original.message : String(original), { cause: original });
+    this._source = _source;
   }
 }
 class NoOwnerError extends Error {
@@ -26,7 +33,6 @@ const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
 const REACTIVE_ZOMBIE = 1 << 5;
 const REACTIVE_DISPOSED = 1 << 6;
 const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
-const STATUS_NONE = 0;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
@@ -140,10 +146,93 @@ const zombieQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _mi
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
-let optimisticReadActive = false;
 let projectionWriteActive = false;
-function setOptimisticReadActive(value) {
-  optimisticReadActive = value;
+const signalLanes = new WeakMap();
+const activeLanes = new Set();
+let currentOptimisticLane = null;
+function setCurrentOptimisticLane(lane) {
+  currentOptimisticLane = lane;
+}
+function getOrCreateLane(signal) {
+  let lane = signalLanes.get(signal);
+  if (lane) {
+    return findLane(lane);
+  }
+  const parentSource = signal._parentSource;
+  const parentLane = parentSource?._optimisticLane ? findLane(parentSource._optimisticLane) : null;
+  lane = {
+    _source: signal,
+    _pendingAsync: new Set(),
+    _effectQueues: [[], []],
+    _mergedInto: null,
+    _transition: activeTransition,
+    _parentLane: parentLane
+  };
+  signalLanes.set(signal, lane);
+  activeLanes.add(lane);
+  signal._laneVersion = signal._overrideVersion || 0;
+  return lane;
+}
+function findLane(lane) {
+  while (lane._mergedInto) lane = lane._mergedInto;
+  return lane;
+}
+function mergeLanes(lane1, lane2) {
+  lane1 = findLane(lane1);
+  lane2 = findLane(lane2);
+  if (lane1 === lane2) return lane1;
+  lane2._mergedInto = lane1;
+  for (const node of lane2._pendingAsync) lane1._pendingAsync.add(node);
+  lane1._effectQueues[0].push(...lane2._effectQueues[0]);
+  lane1._effectQueues[1].push(...lane2._effectQueues[1]);
+  return lane1;
+}
+function clearLaneEntry(signal) {
+  signalLanes.delete(signal);
+}
+function resolveLane(el) {
+  const lane = el._optimisticLane;
+  if (!lane) return undefined;
+  const root = findLane(lane);
+  if (activeLanes.has(root)) return root;
+  el._optimisticLane = undefined;
+  return undefined;
+}
+function hasActiveOverride(el) {
+  return !!(el._optimistic && el._pendingValue !== NOT_PENDING);
+}
+function assignOrMergeLane(el, sourceLane) {
+  const sourceRoot = findLane(sourceLane);
+  const existing = el._optimisticLane;
+  if (existing) {
+    if (existing._mergedInto) {
+      el._optimisticLane = sourceLane;
+      return;
+    }
+    const existingRoot = findLane(existing);
+    if (activeLanes.has(existingRoot)) {
+      if (existingRoot !== sourceRoot && !hasActiveOverride(el)) {
+        if (sourceRoot._parentLane && findLane(sourceRoot._parentLane) === existingRoot) {
+          el._optimisticLane = sourceLane;
+        } else if (existingRoot._parentLane && findLane(existingRoot._parentLane) === sourceRoot);
+        else {
+          mergeLanes(sourceRoot, existingRoot);
+        }
+      }
+      return;
+    }
+  }
+  el._optimisticLane = sourceLane;
+}
+function runLaneEffects(type) {
+  for (const lane of activeLanes) {
+    if (lane._mergedInto || lane._pendingAsync.size > 0) continue;
+    const effects = lane._effectQueues[type - 1];
+    if (effects.length) {
+      lane._effectQueues[type - 1] = [];
+      runQueue(effects, type);
+    }
+  }
 }
 function setProjectionWriteActive(value) {
   projectionWriteActive = value;
@@ -156,7 +245,6 @@ function schedule() {
 class Queue {
   _parent = null;
   _queues = [[], []];
-  _optimisticQueues = [[], []];
   _children = [];
   created = clock;
   addChild(child) {
@@ -170,30 +258,26 @@ class Queue {
       child._parent = null;
     }
   }
-  notify(node, mask, flags) {
-    if (this._parent) return this._parent.notify(node, mask, flags);
+  notify(node, mask, flags, error) {
+    if (this._parent) return this._parent.notify(node, mask, flags, error);
     return false;
   }
-  _runQueue(type, queues, method) {
-    if (queues[type - 1].length) {
-      const effects = queues[type - 1];
-      queues[type - 1] = [];
+  run(type) {
+    if (this._queues[type - 1].length) {
+      const effects = this._queues[type - 1];
+      this._queues[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this._children.length; i++) {
-      this._children[i][method]?.(type);
-    }
-  }
-  run(type) {
-    this._runQueue(type, this._queues, "run");
-  }
-  runOptimistic(type) {
-    this._runQueue(type, this._optimisticQueues, "runOptimistic");
+    for (let i = 0; i < this._children.length; i++) this._children[i].run?.(type);
   }
   enqueue(type, fn) {
     if (type) {
-      const queue = optimisticReadActive ? this._optimisticQueues : this._queues;
-      queue[type - 1].push(fn);
+      if (currentOptimisticLane) {
+        const lane = findLane(currentOptimisticLane);
+        lane._effectQueues[type - 1].push(fn);
+      } else {
+        this._queues[type - 1].push(fn);
+      }
     }
     schedule();
   }
@@ -242,23 +326,23 @@ class GlobalQueue extends Queue {
           this._pendingNodes = [];
           this._optimisticNodes = [];
           this._optimisticStores = new Set();
-          this.runOptimistic(EFFECT_RENDER);
-          this.runOptimistic(EFFECT_USER);
-          this.stashQueues(activeTransition.queueStash);
+          runLaneEffects(EFFECT_RENDER);
+          runLaneEffects(EFFECT_USER);
+          this.stashQueues(activeTransition._queueStash);
           clock++;
-          scheduled = false;
-          runTransitionPending(activeTransition.pendingNodes);
+          scheduled = dirtyQueue._max >= dirtyQueue._min;
+          reassignPendingTransition(activeTransition._pendingNodes);
           activeTransition = null;
           finalizePureQueue(null, true);
           return;
         }
-        this._pendingNodes !== activeTransition.pendingNodes &&
-          this._pendingNodes.push(...activeTransition.pendingNodes);
-        this.restoreQueues(activeTransition.queueStash);
+        this._pendingNodes !== activeTransition._pendingNodes &&
+          this._pendingNodes.push(...activeTransition._pendingNodes);
+        this.restoreQueues(activeTransition._queueStash);
         transitions.delete(activeTransition);
         const completingTransition = activeTransition;
         activeTransition = null;
-        runTransitionPending(this._pendingNodes);
+        reassignPendingTransition(this._pendingNodes);
         finalizePureQueue(completingTransition);
       } else {
         if (transitions.size) runHeap(zombieQueue, GlobalQueue._update);
@@ -266,23 +350,24 @@ class GlobalQueue extends Queue {
       }
       clock++;
       scheduled = dirtyQueue._max >= dirtyQueue._min;
-      this.runOptimistic(EFFECT_RENDER);
+      runLaneEffects(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
-      this.runOptimistic(EFFECT_USER);
+      runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
     } finally {
       this._running = false;
     }
   }
-  notify(node, mask, flags) {
+  notify(node, mask, flags, error) {
     if (mask & STATUS_PENDING) {
       if (flags & STATUS_PENDING) {
+        const actualError = error !== undefined ? error : node._error;
         if (
           activeTransition &&
-          node._error &&
-          !activeTransition.asyncNodes.includes(node._error.cause)
+          actualError &&
+          !activeTransition._asyncNodes.includes(actualError._source)
         ) {
-          activeTransition.asyncNodes.push(node._error.cause);
+          activeTransition._asyncNodes.push(actualError._source);
           schedule();
         }
       }
@@ -293,47 +378,63 @@ class GlobalQueue extends Queue {
   initTransition(transition) {
     if (transition) transition = currentTransition(transition);
     if (transition && transition === activeTransition) return;
-    if (!transition && activeTransition && activeTransition.time === clock) return;
+    if (!transition && activeTransition && activeTransition._time === clock) return;
     if (!activeTransition) {
       activeTransition = transition ?? {
-        time: clock,
-        pendingNodes: [],
-        asyncNodes: [],
-        optimisticNodes: [],
-        optimisticStores: new Set(),
-        actions: [],
-        queueStash: { _queues: [[], []], _children: [] },
-        done: false
+        _time: clock,
+        _pendingNodes: [],
+        _asyncNodes: [],
+        _optimisticNodes: [],
+        _optimisticStores: new Set(),
+        _actions: [],
+        _queueStash: { _queues: [[], []], _children: [] },
+        _done: false
       };
     } else if (transition) {
-      activeTransition.done = transition;
-      transition.actions.push(...activeTransition.actions);
-      transitions.delete(activeTransition);
+      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);
+      }
+      transitions.delete(outgoing);
       activeTransition = transition;
     }
     transitions.add(activeTransition);
-    activeTransition.time = clock;
+    activeTransition._time = clock;
     for (let i = 0; i < this._pendingNodes.length; i++) {
       const n = this._pendingNodes[i];
       n._transition = activeTransition;
-      activeTransition.pendingNodes.push(n);
+      activeTransition._pendingNodes.push(n);
     }
-    this._pendingNodes = activeTransition.pendingNodes;
+    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);
+      activeTransition._optimisticNodes.push(node);
     }
-    this._optimisticNodes = activeTransition.optimisticNodes;
-    for (const store of this._optimisticStores) {
-      activeTransition.optimisticStores.add(store);
+    this._optimisticNodes = activeTransition._optimisticNodes;
+    for (const lane of activeLanes) {
+      if (!lane._transition) lane._transition = activeTransition;
     }
-    this._optimisticStores = activeTransition.optimisticStores;
+    for (const store of this._optimisticStores) activeTransition._optimisticStores.add(store);
+    this._optimisticStores = activeTransition._optimisticStores;
   }
 }
 function insertSubs(node, optimistic = false) {
+  const sourceLane = node._optimisticLane || currentOptimisticLane;
   for (let s = node._subs; s !== null; s = s._nextSub) {
-    if (optimistic) s._sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+    if (optimistic && sourceLane) {
+      s._sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+      assignOrMergeLane(s._sub, sourceLane);
+    } else if (optimistic) {
+      s._sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+      s._sub._optimisticLane = undefined;
+    }
     const sub = s._sub;
     if (sub._type === EFFECT_TRACKED) {
       if (!sub._modified) {
@@ -349,9 +450,8 @@ function insertSubs(node, optimistic = false) {
 }
 function finalizePureQueue(completingTransition = null, incomplete = false) {
   let resolvePending = !incomplete;
-  if (dirtyQueue._max >= dirtyQueue._min) {
-    runHeap(dirtyQueue, GlobalQueue._update);
-  }
+  if (!incomplete) checkBoundaryChildren(globalQueue);
+  if (dirtyQueue._max >= dirtyQueue._min) runHeap(dirtyQueue, GlobalQueue._update);
   if (resolvePending) {
     const pendingNodes = globalQueue._pendingNodes;
     for (let i = 0; i < pendingNodes.length; i++) {
@@ -361,15 +461,17 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
         n._pendingValue = NOT_PENDING;
         if (n._type && n._type !== EFFECT_TRACKED) n._modified = true;
       }
+      n._statusFlags &= ~STATUS_UNINITIALIZED;
       if (n._fn) GlobalQueue._dispose(n, false, true);
     }
     pendingNodes.length = 0;
     const optimisticNodes = completingTransition
-      ? completingTransition.optimisticNodes
+      ? completingTransition._optimisticNodes
       : globalQueue._optimisticNodes;
     for (let i = 0; i < optimisticNodes.length; i++) {
       const n = optimisticNodes[i];
       const original = n._pendingValue;
+      n._optimisticLane = undefined;
       if (original !== NOT_PENDING && n._value !== original) {
         n._value = original;
         insertSubs(n, true);
@@ -379,7 +481,7 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
     }
     optimisticNodes.length = 0;
     const optimisticStores = completingTransition
-      ? completingTransition.optimisticStores
+      ? completingTransition._optimisticStores
       : globalQueue._optimisticStores;
     if (GlobalQueue._clearOptimisticStore && optimisticStores.size) {
       for (const store of optimisticStores) {
@@ -388,13 +490,35 @@ 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);
+    }
+  }
+}
+function checkBoundaryChildren(queue) {
+  for (const child of queue._children) {
+    child.checkSources?.();
+    checkBoundaryChildren(child);
   }
 }
 function trackOptimisticStore(store) {
   globalQueue._optimisticStores.add(store);
   schedule();
 }
-function runTransitionPending(pendingNodes) {
+function reassignPendingTransition(pendingNodes) {
   for (let i = 0; i < pendingNodes.length; i++) {
     pendingNodes[i]._transition = activeTransition;
   }
@@ -411,20 +535,21 @@ function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++) queue[i](type);
 }
 function transitionComplete(transition) {
-  if (transition.done) return true;
-  if (transition.actions.length) return false;
+  if (transition._done) return true;
+  if (transition._actions.length) return false;
   let done = true;
-  for (let i = 0; i < transition.asyncNodes.length; i++) {
-    if (transition.asyncNodes[i]._statusFlags & STATUS_PENDING) {
+  for (let i = 0; i < transition._asyncNodes.length; i++) {
+    const node = transition._asyncNodes[i];
+    if (node._statusFlags & STATUS_PENDING && node._error?._source === node) {
       done = false;
       break;
     }
   }
-  done && (transition.done = true);
+  done && (transition._done = true);
   return done;
 }
 function currentTransition(transition) {
-  while (transition.done && typeof transition.done === "object") transition = transition.done;
+  while (transition._done && typeof transition._done === "object") transition = transition._done;
   return transition;
 }
 function runInTransition(transition, fn) {
@@ -448,11 +573,11 @@ function action(genFn) {
       const it = genFn(...args);
       globalQueue.initTransition();
       let ctx = activeTransition;
-      ctx.actions.push(it);
+      ctx._actions.push(it);
       const done = (v, e) => {
         ctx = currentTransition(ctx);
-        const i = ctx.actions.indexOf(it);
-        if (i >= 0) ctx.actions.splice(i, 1);
+        const i = ctx._actions.indexOf(it);
+        if (i >= 0) ctx._actions.splice(i, 1);
         activeTransition = ctx;
         schedule();
         e ? reject(e) : resolve(v);
@@ -499,7 +624,7 @@ function recompute(el, create = false) {
     if (el._transition && (!isEffect || activeTransition) && activeTransition !== el._transition)
       globalQueue.initTransition(el._transition);
     deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    if (el._transition) disposeChildren(el);
+    if (el._transition || isEffect === EFFECT_TRACKED) disposeChildren(el);
     else {
       markDisposal(el);
       el._pendingDisposal = el._disposal;
@@ -509,7 +634,8 @@ function recompute(el, create = false) {
     }
   }
   const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
-  const hasOptimisticOverride = el._optimistic && el._pendingValue !== NOT_PENDING;
+  const hasOverride = hasActiveOverride(el);
+  const wasPending = !!(el._statusFlags & STATUS_PENDING);
   const oldcontext = context;
   context = el;
   el._depsTail = null;
@@ -518,17 +644,36 @@ function recompute(el, create = false) {
   let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   let oldHeight = el._height;
   let prevTracking = tracking;
-  let prevOptimisticRead = optimisticReadActive;
+  let prevLane = currentOptimisticLane;
   tracking = true;
-  if (isOptimisticDirty) setOptimisticReadActive(true);
+  if (isOptimisticDirty) {
+    const lane = resolveLane(el);
+    if (lane) setCurrentOptimisticLane(lane);
+  }
   try {
     value = handleAsync(el, el._fn(value));
     clearStatus(el);
+    const resolvedLane = resolveLane(el);
+    if (resolvedLane) {
+      resolvedLane._pendingAsync.delete(el);
+      updatePendingSignal(resolvedLane._source);
+    }
   } catch (e) {
-    if (e instanceof NotReadyError) {
-      if (e.cause !== el) link(e.cause, el);
-      notifyStatus(el, STATUS_PENDING, e);
-    } else notifyStatus(el, STATUS_ERROR, e);
+    if (e instanceof NotReadyError && currentOptimisticLane) {
+      const lane = findLane(currentOptimisticLane);
+      if (lane._source !== el) {
+        lane._pendingAsync.add(el);
+        el._optimisticLane = lane;
+        updatePendingSignal(lane._source);
+      }
+    }
+    notifyStatus(
+      el,
+      e instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
+      e,
+      undefined,
+      e instanceof NotReadyError ? el._optimisticLane : undefined
+    );
   } finally {
     tracking = prevTracking;
     el._flags = REACTIVE_NONE;
@@ -544,21 +689,34 @@ function recompute(el, create = false) {
       if (depsTail !== null) depsTail._nextDep = null;
       else el._deps = null;
     }
-    const valueChanged =
-      !el._equals ||
-      !el._equals(el._pendingValue === NOT_PENDING ? el._value : el._pendingValue, value);
+    const compareValue = hasOverride
+      ? el._value
+      : el._pendingValue === NOT_PENDING
+        ? el._value
+        : el._pendingValue;
+    const valueChanged = !el._equals || !el._equals(compareValue, value);
     if (valueChanged) {
+      const prevVisible = hasOverride ? el._value : undefined;
       if (create || (isEffect && activeTransition !== el._transition) || isOptimisticDirty)
         el._value = value;
       else el._pendingValue = value;
-      insertSubs(el, isOptimisticDirty || hasOptimisticOverride);
+      if (hasOverride && !isOptimisticDirty && wasPending) {
+        const ov = el._overrideVersion || 0;
+        const lv = el._laneVersion || 0;
+        if (ov <= lv) el._value = value;
+      }
+      if (!hasOverride || isOptimisticDirty || el._value !== prevVisible) {
+        insertSubs(el, isOptimisticDirty || hasOverride);
+      }
+    } else if (hasOverride) {
+      el._pendingValue = value;
     } else if (el._height != oldHeight) {
       for (let s = el._subs; s !== null; s = s._nextSub) {
         insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
       }
     }
   }
-  setOptimisticReadActive(prevOptimisticRead);
+  setCurrentOptimisticLane(prevLane);
   (!create || el._statusFlags & STATUS_PENDING) &&
     !el._transition &&
     !(activeTransition && el._optimistic) &&
@@ -581,27 +739,40 @@ function handleAsync(el, result, setter) {
   const handleError = error => {
     if (el._inFlight !== result) return;
     globalQueue.initTransition(el._transition);
-    if (error instanceof NotReadyError) {
-      if (error.cause !== el) link(error.cause, el);
-      notifyStatus(el, STATUS_PENDING, error);
-    } else notifyStatus(el, STATUS_ERROR, error);
+    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);
     clearStatus(el);
+    const lane = resolveLane(el);
+    if (lane) lane._pendingAsync.delete(el);
     if (setter) setter(value);
     else if (el._optimistic) {
-      const hasOverride = el._pendingValue !== NOT_PENDING;
+      const hadOverride = el._pendingValue !== NOT_PENDING;
       if (el._fn) el._pendingValue = value;
-      if (!hasOverride) {
+      if (!hadOverride) {
         el._value = value;
         insertSubs(el);
       }
       el._time = clock;
-      schedule();
-    } else setSignal(el, () => value);
+    } else if (lane) {
+      const prevValue = el._value;
+      const equals = el._equals;
+      if (!equals || !equals(value, prevValue)) {
+        el._value = value;
+        el._time = clock;
+        if (el._pendingValueComputed) {
+          setSignal(el._pendingValueComputed, value);
+        }
+        insertSubs(el, true);
+      }
+    } else {
+      setSignal(el, () => value);
+    }
+    schedule();
     flush();
     then?.();
   };
@@ -660,32 +831,51 @@ function handleAsync(el, result, setter) {
   return syncValue;
 }
 function clearStatus(el) {
-  el._statusFlags = STATUS_NONE;
+  el._statusFlags = el._statusFlags & STATUS_UNINITIALIZED;
   el._error = null;
   updatePendingSignal(el);
+  el._notifyStatus?.();
+}
+function notifyStatus(el, status, error, blockStatus, lane) {
+  if (
+    status === STATUS_ERROR &&
+    !(error instanceof StatusError) &&
+    !(error instanceof NotReadyError)
+  )
+    error = new StatusError(el, error);
+  const isSource = error instanceof NotReadyError && error._source === el;
+  const isOptimisticBoundary = status === STATUS_PENDING && el._optimistic && !isSource;
+  const startsBlocking = isOptimisticBoundary && hasActiveOverride(el);
+  if (!blockStatus) {
+    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) {
-    el._notifyStatus();
-  } else {
-    if (!el._transition) {
-      for (let s = el._subs; s !== null; s = s._nextSub) {
-        if (s._sub._statusFlags & STATUS_PENDING) {
-          insertIntoHeap(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-        }
-      }
+    if (downstreamBlockStatus) {
+      el._notifyStatus(status, error);
+    } else {
+      el._notifyStatus();
     }
-    schedule();
+    return;
   }
-}
-function notifyStatus(el, status, error) {
-  el._statusFlags = status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
-  el._error = error;
-  updatePendingSignal(el);
-  if (el._notifyStatus) return el._notifyStatus();
   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);
+      notifyStatus(s._sub, status, error, downstreamBlockStatus, downstreamLane);
     }
   }
   for (let child = el._child; child !== null; child = child._nextChild) {
@@ -693,7 +883,7 @@ function notifyStatus(el, status, error) {
       s._sub._time = clock;
       if (s._sub._error !== error) {
         !s._sub._transition && globalQueue._pendingNodes.push(s._sub);
-        notifyStatus(s._sub, status, error);
+        notifyStatus(s._sub, status, error, downstreamBlockStatus, downstreamLane);
       }
     }
   }
@@ -711,7 +901,7 @@ function updateIfNecessary(el) {
       }
     }
   }
-  if (el._flags & REACTIVE_DIRTY) {
+  if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (el._error && el._time < clock)) {
     recompute(el);
   }
   el._flags = REACTIVE_NONE;
@@ -929,29 +1119,60 @@ function optimisticComputed(fn, initialValue, options) {
 function getPendingSignal(el) {
   if (!el._pendingSignal) {
     el._pendingSignal = optimisticSignal(false, { pureWrite: true });
+    if (el._parentSource) {
+      el._pendingSignal._parentSource = el;
+    }
     if (computePendingState(el)) setSignal(el._pendingSignal, true);
   }
   return el._pendingSignal;
 }
 function computePendingState(el) {
-  if (el._pendingValue !== NOT_PENDING) return true;
   const comp = el;
+  if (el._optimistic && el._pendingValue !== NOT_PENDING) {
+    if (comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED))
+      return true;
+    if (el._parentSource) {
+      const lane = el._optimisticLane ? findLane(el._optimisticLane) : null;
+      return !!(lane && lane._pendingAsync.size > 0);
+    }
+    return true;
+  }
+  if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) return true;
   return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));
 }
 function getPendingValueComputed(el) {
   if (!el._pendingValueComputed) {
     const prevPending = pendingReadActive;
     pendingReadActive = false;
+    const prevCheck = pendingCheckActive;
+    pendingCheckActive = false;
     const prevContext = context;
     context = null;
     el._pendingValueComputed = optimisticComputed(() => read(el));
+    el._pendingValueComputed._parentSource = el;
     context = prevContext;
+    pendingCheckActive = prevCheck;
     pendingReadActive = prevPending;
   }
   return el._pendingValueComputed;
 }
 function updatePendingSignal(el) {
-  if (el._pendingSignal) setSignal(el._pendingSignal, computePendingState(el));
+  if (el._pendingSignal) {
+    const pending = computePendingState(el);
+    const sig = el._pendingSignal;
+    setSignal(sig, pending);
+    if (!pending && sig._optimisticLane) {
+      const sourceLane = resolveLane(el);
+      if (sourceLane && sourceLane._pendingAsync.size > 0) {
+        const sigLane = findLane(sig._optimisticLane);
+        if (sigLane !== sourceLane) {
+          mergeLanes(sourceLane, sigLane);
+        }
+      }
+      clearLaneEntry(sig);
+      sig._optimisticLane = undefined;
+    }
+  }
 }
 function isEqual(a, b) {
   return a === b;
@@ -966,6 +1187,22 @@ function untrack(fn) {
   }
 }
 function read(el) {
+  if (pendingReadActive) {
+    const pendingComputed = getPendingValueComputed(el);
+    const prevPending = pendingReadActive;
+    pendingReadActive = false;
+    const value = read(pendingComputed);
+    pendingReadActive = prevPending;
+    if (pendingComputed._statusFlags & STATUS_PENDING) return el._value;
+    if (stale && currentOptimisticLane && pendingComputed._optimisticLane) {
+      const pcLane = findLane(pendingComputed._optimisticLane);
+      const curLane = findLane(currentOptimisticLane);
+      if (pcLane !== curLane && pcLane._pendingAsync.size > 0) {
+        return el._value;
+      }
+    }
+    return value;
+  }
   if (pendingCheckActive) {
     const target = el._firewall || el;
     const pendingSig = getPendingSignal(target);
@@ -977,15 +1214,6 @@ function read(el) {
     pendingCheckActive = prevCheck;
     return el._value;
   }
-  if (pendingReadActive) {
-    const pendingComputed = getPendingValueComputed(el);
-    const prevPending = pendingReadActive;
-    pendingReadActive = false;
-    const value = read(pendingComputed);
-    pendingReadActive = prevPending;
-    if (pendingComputed._statusFlags & STATUS_PENDING) return el._value;
-    return value;
-  }
   let c = context;
   if (c?._root) c = c._parentComputed;
   if (refreshing && el._fn) recompute(el);
@@ -1009,11 +1237,21 @@ function read(el) {
   const asyncCompute = el._firewall || el;
   if (
     c &&
-    !optimisticReadActive &&
     asyncCompute._statusFlags & STATUS_PENDING &&
     !(stale && asyncCompute._transition && activeTransition !== asyncCompute._transition)
-  )
-    throw asyncCompute._error;
+  ) {
+    if (currentOptimisticLane) {
+      const pendingLane = asyncCompute._optimisticLane;
+      const lane = findLane(currentOptimisticLane);
+      if (pendingLane && findLane(pendingLane) === lane && !hasActiveOverride(asyncCompute)) {
+        if (!tracking) link(el, c);
+        throw asyncCompute._error;
+      }
+    } else {
+      if (!tracking) link(el, c);
+      throw asyncCompute._error;
+    }
+  }
   if (el._fn && el._statusFlags & STATUS_ERROR) {
     if (el._time < clock) {
       recompute(el, true);
@@ -1021,7 +1259,7 @@ function read(el) {
     } else throw el._error;
   }
   return !c ||
-    optimisticReadActive ||
+    currentOptimisticLane !== null ||
     el._pendingValue === NOT_PENDING ||
     (stale && el._transition && activeTransition !== el._transition)
     ? el._value
@@ -1040,7 +1278,13 @@ function setSignal(el, v) {
       : el._pendingValue;
   if (typeof v === "function") v = v(currentValue);
   const valueChanged = !el._equals || !el._equals(currentValue, v);
-  if (!valueChanged) return v;
+  if (!valueChanged) {
+    if (isOptimistic && el._pendingValue !== NOT_PENDING && el._fn) {
+      insertSubs(el, true);
+      schedule();
+    }
+    return v;
+  }
   if (isOptimistic) {
     const alreadyTracked = globalQueue._optimisticNodes.includes(el);
     if (el._transition && alreadyTracked) {
@@ -1052,6 +1296,9 @@ function setSignal(el, v) {
     if (!alreadyTracked) {
       globalQueue._optimisticNodes.push(el);
     }
+    el._overrideVersion = (el._overrideVersion || 0) + 1;
+    const lane = getOrCreateLane(el);
+    el._optimisticLane = lane;
     el._value = v;
   } else {
     if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
@@ -1156,6 +1403,8 @@ function isPending(fn) {
   try {
     fn();
     return foundPending;
+  } catch {
+    return foundPending;
   } finally {
     pendingCheckActive = prevPendingCheck;
     foundPending = prevFoundPending;
@@ -1228,25 +1477,27 @@ function effect(compute, effect, error, initialValue, options) {
   node._errorFn = error;
   node._cleanup = undefined;
   node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
-  node._notifyStatus = () => {
-    if (node._statusFlags & STATUS_ERROR) {
-      let error = node._error;
+  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(error, () => {
+            ? node._errorFn(err, () => {
                 node._cleanup?.();
                 node._cleanup = undefined;
               })
-            : console.error(error);
+            : console.error(err);
         } catch (e) {
-          error = e;
+          err = e;
         }
       }
-      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw error;
+      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, node._statusFlags);
+      node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
   };
   recompute(node, true);
   !options?.defer &&
@@ -1994,18 +2245,27 @@ function clearOptimisticStore(store) {
   if (!target || !target[STORE_OPTIMISTIC_OVERRIDE]) return;
   const override = target[STORE_OPTIMISTIC_OVERRIDE];
   const nodes = target[STORE_NODE];
-  if (nodes) {
-    for (const key of Reflect.ownKeys(override)) {
-      if (nodes[key]) {
-        const baseValue =
-          target[STORE_OVERRIDE] && key in target[STORE_OVERRIDE]
-            ? target[STORE_OVERRIDE][key]
-            : target[STORE_VALUE][key];
-        const value = baseValue === $DELETED ? undefined : baseValue;
-        setSignal(nodes[key], isWrappable(value) ? wrap(value, target) : value);
+  setProjectionWriteActive(true);
+  try {
+    if (nodes) {
+      for (const key of Reflect.ownKeys(override)) {
+        if (nodes[key]) {
+          nodes[key]._optimisticLane = undefined;
+          const baseValue =
+            target[STORE_OVERRIDE] && key in target[STORE_OVERRIDE]
+              ? target[STORE_OVERRIDE][key]
+              : target[STORE_VALUE][key];
+          const value = baseValue === $DELETED ? undefined : baseValue;
+          setSignal(nodes[key], isWrappable(value) ? wrap(value, target) : value);
+        }
+      }
+      if (nodes[$TRACK]) {
+        nodes[$TRACK]._optimisticLane = undefined;
+        setSignal(nodes[$TRACK], undefined);
       }
     }
-    nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
+  } finally {
+    setProjectionWriteActive(false);
   }
   delete target[STORE_OPTIMISTIC_OVERRIDE];
 }
@@ -2453,10 +2713,11 @@ function compare(key, a, b) {
 }
 function boundaryComputed(fn, propagationMask) {
   const node = computed(fn, undefined, { lazy: true });
-  node._notifyStatus = () => {
-    const flags = node._statusFlags;
+  node._notifyStatus = (status, error) => {
+    const flags = status !== undefined ? status : node._statusFlags;
+    const actualError = error !== undefined ? error : node._error;
     node._statusFlags &= ~node._propagationMask;
-    node._queue.notify(node, node._propagationMask, flags);
+    node._queue.notify(node, node._propagationMask, flags, actualError);
   };
   node._propagationMask = propagationMask;
   node._preventAutoDisposal = true;
@@ -2484,7 +2745,7 @@ class ConditionalQueue extends Queue {
     if (!type || read(this._disabled)) return;
     return super.run(type);
   }
-  notify(node, type, flags) {
+  notify(node, type, flags, error) {
     if (read(this._disabled)) {
       if (type & STATUS_PENDING) {
         if (flags & STATUS_PENDING) {
@@ -2499,12 +2760,12 @@ class ConditionalQueue extends Queue {
         } else if (this._errorNodes.delete(node)) type &= ~STATUS_ERROR;
       }
     }
-    return type ? super.notify(node, type, flags) : true;
+    return type ? super.notify(node, type, flags, error ?? node._error) : true;
   }
 }
 class CollectionQueue extends Queue {
   _collectionType;
-  _nodes = new Set();
+  _sources = new Set();
   _disabled = signal(false, { pureWrite: true });
   _initialized = false;
   constructor(type) {
@@ -2515,21 +2776,28 @@ class CollectionQueue extends Queue {
     if (!type || read(this._disabled)) return;
     return super.run(type);
   }
-  notify(node, type, flags) {
+  notify(node, type, flags, error) {
     if (
       !(type & this._collectionType) ||
       (this._collectionType & STATUS_PENDING && this._initialized)
     )
-      return super.notify(node, type, flags);
+      return super.notify(node, type, flags, error);
     if (flags & this._collectionType) {
-      this._nodes.add(node);
-      if (this._nodes.size === 1) setSignal(this._disabled, true);
-    } else if (this._nodes.size > 0) {
-      this._nodes.delete(node);
-      if (this._nodes.size === 0) setSignal(this._disabled, false);
+      const source = error?._source || node._error?._source;
+      if (source) {
+        const wasEmpty = this._sources.size === 0;
+        this._sources.add(source);
+        if (wasEmpty) setSignal(this._disabled, true);
+      }
     }
     type &= ~this._collectionType;
-    return type ? super.notify(node, type, flags) : true;
+    return type ? super.notify(node, type, flags, error) : true;
+  }
+  checkSources() {
+    for (const source of this._sources) {
+      if (!(source._statusFlags & this._collectionType)) this._sources.delete(source);
+    }
+    if (!this._sources.size) setSignal(this._disabled, false);
   }
 }
 var BoundaryMode;
@@ -2545,8 +2813,12 @@ function createBoundary(fn, condition) {
     const disabled = read(queue._disabled);
     tree._propagationMask = disabled ? STATUS_ERROR | STATUS_PENDING : 0;
     if (!disabled) {
-      queue._pendingNodes.forEach(node => queue.notify(node, STATUS_PENDING, STATUS_PENDING));
-      queue._errorNodes.forEach(node => queue.notify(node, STATUS_ERROR, STATUS_ERROR));
+      queue._pendingNodes.forEach(node =>
+        queue.notify(node, STATUS_PENDING, STATUS_PENDING, node._error)
+      );
+      queue._errorNodes.forEach(node =>
+        queue.notify(node, STATUS_ERROR, STATUS_ERROR, node._error)
+      );
       queue._pendingNodes.clear();
       queue._errorNodes.clear();
     }
@@ -2572,26 +2844,12 @@ function createCollectionBoundary(type, fn, fallback) {
 function createLoadBoundary(fn, fallback) {
   return createCollectionBoundary(STATUS_PENDING, fn, () => fallback());
 }
-function collectErrorSources(node, sources) {
-  let root = true;
-  let dep = node._deps;
-  while (dep !== null) {
-    const source = dep._dep;
-    if (source._deps && source._statusFlags & STATUS_ERROR) {
-      root = false;
-      collectErrorSources(source, sources);
-    }
-    dep = dep._nextDep;
-  }
-  root && sources.push(node);
-}
 function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(STATUS_ERROR, fn, queue => {
-    let node = queue._nodes.values().next().value;
-    return fallback(node._error, () => {
-      const sources = [];
-      for (const node of queue._nodes) collectErrorSources(node, sources);
-      for (const source of sources) recompute(source);
+    let source = queue._sources.values().next().value;
+    const error = source._error?.cause ?? source._error;
+    return fallback(error, () => {
+      for (const source of queue._sources) recompute(source);
       schedule();
     });
   });