@solidjs/signals 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/dev.js

@@ -669,15 +669,12 @@ class GlobalQueue extends Queue {
   // _clearOptimisticStore).
   static _releaseAffectsScope = null;
   // affects()-side hooks (wired by affects.ts, mirroring _update): the mark
-  // engine — count/register/release plus the post-commit re-application of
-  // marked reads — lives with the feature. Every call site is gated by state
-  // only that module creates, so `!` invocations are safe once the gate holds.
-  static _applyAffectsReads = null;
+  // engine — count/register/release — lives with the feature. Every call site
+  // is gated by state only that module creates, so `!` invocations are safe
+  // once the gate holds.
   static _releaseAffectsMarks = null;
   static _markAffects = null;
   static _releaseAffectsMark = null;
-  static _onlyMarkPending = null;
-  static _collectMarkSources = null;
   // External-source bridge (wired by enableExternalSource(); null while no
   // config is active — including after _resetExternalSourceConfig()).
   static _wireExternalSource = null;
@@ -707,11 +704,9 @@ class GlobalQueue extends Queue {
   // once the gate holds.
   static _optimisticWrite = null;
   static _resolveOptimistic = null;
-  static _stashOptimistic = null;
   static _transitionBlocked = null;
   static _cleanupLanes = null;
   static _runLaneEffects = null;
-  static _readStashed = null;
   static _gatedRead = null;
   static _laneSuspends = null;
   static _laneReadsCommitted = null;
@@ -731,8 +726,12 @@ class GlobalQueue extends Queue {
           const stashedTransition = activeTransition;
           runHeap(zombieQueue, GlobalQueue._update);
           // Detach: the stashed transition keeps its batch; ambient work that
-          // follows lands in a fresh one.
-          currentBatch = this._batch = createBatch();
+          // follows lands in a fresh one. If the batch is already a separate
+          // ambient one — action done() restored activeTransition without
+          // adopting the batch, and an ordinary write landed there before
+          // the scheduled flush (#2916) — keep it: replacing it would strand
+          // its queued pending nodes with held _pendingValues forever.
+          if (this._batch === stashedTransition) currentBatch = this._batch = createBatch();
           // Run lane effects immediately (before stashing) - lanes with no pending async
           if (activeLanes.size) {
             GlobalQueue._runLaneEffects(EFFECT_RENDER);
@@ -740,21 +739,13 @@ class GlobalQueue extends Queue {
           }
           this.stashQueues(stashedTransition._queueStash);
           clock++;
-          scheduled = dirtyQueue._max >= dirtyQueue._min;
+          // A kept ambient batch may hold pending nodes (#2916): stay
+          // scheduled so the outer drain loop commits them via the plain
+          // flush path instead of leaving them until the next natural flush.
+          scheduled = dirtyQueue._max >= dirtyQueue._min || this._batch._pendingNodes.length > 0;
           reassignPendingTransition(stashedTransition._pendingNodes);
           activeTransition = null;
-          // The stash pass (committed-view rerun of plain optimistic signals)
-          // wraps finalizePureQueue in the engine; a non-empty _optimisticNodes
-          // means _optimisticWrite ran, which installed the hook.
-          if (
-            !stashedTransition._actions.length &&
-            !stashedTransition._asyncReporters.size &&
-            stashedTransition._optimisticNodes.length
-          ) {
-            GlobalQueue._stashOptimistic(stashedTransition);
-          } else {
-            finalizePureQueue(null, true);
-          }
+          finalizePureQueue(null, true);
           return;
         }
         const completingTransition = activeTransition;
@@ -826,6 +817,11 @@ class GlobalQueue extends Queue {
     if (mask & STATUS_PENDING) {
       if (flags & STATUS_PENDING) {
         const actualError = error !== undefined ? error : node._error;
+        // A visibility-only mark notification (the affects() boundary
+        // channel) updates display state on its way up but must be invisible
+        // to completion accounting BY CONSTRUCTION: it never registers a
+        // reporter and never counts toward the loading-boundary diagnostic.
+        if (actualError?._markVisual) return true;
         if (activeTransition && actualError) {
           const source = actualError.source;
           let reporters = activeTransition._asyncReporters.get(source);
@@ -972,8 +968,14 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
     }
     // Declared motion ends with the transaction: settle (or plain flush end
     // for ambient marks) releases each registration's refcount. A non-empty
-    // batch means registerAffectsMark ran, which installed the hook.
-    if (batch._affectsNodes.length) GlobalQueue._releaseAffectsMarks(batch._affectsNodes);
+    // batch means registerAffectsMark ran, which installed the hook. Marks
+    // held boundary display state through the visual channel, and their
+    // release is the display-state update point — re-run the boundary sweep
+    // (the earlier sweep above ran while the marks were still live).
+    if (batch._affectsNodes.length) {
+      GlobalQueue._releaseAffectsMarks(batch._affectsNodes);
+      if (globalQueue._children.length) checkBoundaryChildren(globalQueue);
+    }
     // A non-empty set means trackOptimisticStore ran, which installed the
     // hook; the hook iterates, clears, and schedules (keeping the loop out of
     // core lets esbuild shake it — rollup already folds the null guard). The
@@ -1156,7 +1158,15 @@ function insertIntoHeap(n, heap) {
   if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
   if (flags & REACTIVE_CHECK) {
     n._flags = (flags & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
-  } else n._flags = flags | REACTIVE_IN_HEAP;
+  } else {
+    n._flags = flags | REACTIVE_IN_HEAP;
+    // An unmarked node entering a marked heap invalidates the markHeap memo:
+    // `_marked` is only reset by runHeap, so a write between two mid-tick
+    // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
+    // this node unmarked and every downstream pull stale until the next
+    // flush (#2922: the second `latest()` returned the first write's value).
+    if (heap._marked && !(flags & REACTIVE_DIRTY)) heap._marked = false;
+  }
   if (!(flags & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(n, heap);
 }
 function insertIntoHeapHeight(n, heap) {
@@ -1588,9 +1598,14 @@ function unobserved(el) {
 }
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
 function link(dep, sub, pendingObserver = false) {
+  // Repeat touches within one pass AND-combine `_pendingObserver`: a probe
+  // read (`isPending(() => x())`) beside a value read of the same dep must
+  // not relabel the value dependency as probe-only — the value read is what
+  // real-error propagation and affects() coverage key off, regardless of
+  // read order within the computation.
   const prevDep = sub._depsTail;
   if (prevDep !== null && prevDep._dep === dep) {
-    prevDep._pendingObserver = pendingObserver;
+    prevDep._pendingObserver &&= pendingObserver;
     return;
   }
   let nextDep = null;
@@ -1600,6 +1615,7 @@ function link(dep, sub, pendingObserver = false) {
     if (nextDep !== null && nextDep._dep === dep) {
       nextDep._gen = sub._depGen;
       sub._depsTail = nextDep;
+      // First touch of this pass: the previous pass's label is stale.
       nextDep._pendingObserver = pendingObserver;
       return;
     }
@@ -1615,7 +1631,10 @@ function link(dep, sub, pendingObserver = false) {
     prevSub._sub === sub &&
     (!isRecomputing || prevSub._gen === sub._depGen)
   ) {
-    prevSub._pendingObserver = pendingObserver;
+    // Gen-matched during a recompute = repeat touch this pass (AND); outside
+    // a recompute there is no pass boundary, so the latest read labels it.
+    if (isRecomputing) prevSub._pendingObserver &&= pendingObserver;
+    else prevSub._pendingObserver = pendingObserver;
     return;
   }
   const newLink =
@@ -1679,20 +1698,13 @@ function forEachDependent(el, fn) {
 // Queue a node to re-run on the next flush (used both when a pending source
 // settles and when an `isPending` observer must re-evaluate after a real error):
 // shared scheduling helper in heap.ts (tracked effects bypass the heap).
-function settlePendingSource(
-  el,
-  source = el,
-  // Mark release runs inside queue finalization: companion writes must go
-  // through the settlement snap (committed), because a setSignal here would
-  // open a fresh transition-scoped override window that nothing reverts.
-  snap = false
-) {
+function settlePendingSource(el) {
   let scheduled = false;
   const visited = new Set();
-  // Companion updates no-op without the verdict layer (null hooks).
-  const updateCompanions = snap ? GlobalQueue._snapCompanions : GlobalQueue._updatePendingSignal;
+  // Companion updates no-op without the verdict layer (null hook).
+  const updateCompanions = GlobalQueue._updatePendingSignal;
   const settle = node => {
-    if (visited.has(node) || !removePendingSource(node, source)) return;
+    if (visited.has(node) || !removePendingSource(node, el)) return;
     visited.add(node);
     node._time = clock;
     const remaining = node._pendingSources?.values().next().value;
@@ -1968,18 +1980,6 @@ function notifyStatus(el, status, error, blockStatus, lane) {
     error = new StatusError(el, error);
   const pendingSource =
     status === STATUS_PENDING && error instanceof NotReadyError ? error.source : undefined;
-  // Mark-sourced propagation must not capture subscribers into the marking
-  // action's transaction (#2893): they carry no held value needing a
-  // transition-scheduled commit, and stamping `_transition` on them would
-  // freeze unrelated writes that share a downstream memo until the action
-  // settles. Real async keeps queuing (its commits ride the transition).
-  const markSourced = pendingSource?._affectsFor !== undefined;
-  // A real error is a settled verdict a mark must not erase (#2893): landing
-  // STATUS_PENDING here would clobber `_error` with the sentinel's
-  // NotReadyError, and unlike real async there is no arriving value whose
-  // recompute would surface the error again. Descent stops too — everything
-  // downstream holds the propagated error for the same reason.
-  if (markSourced && el._statusFlags & STATUS_ERROR) return;
   const isSource = pendingSource === el;
   const isOptimisticBoundary =
     status === STATUS_PENDING && el._overrideValue !== undefined && !isSource;
@@ -2033,7 +2033,7 @@ function notifyStatus(el, status, error, blockStatus, lane) {
         schedule();
         return;
       }
-      if (!downstreamBlockStatus && !markSourced && !sub._transition) queuePendingNode(sub);
+      if (!downstreamBlockStatus && !sub._transition) queuePendingNode(sub);
       notifyStatus(sub, status, error, downstreamBlockStatus, downstreamLane);
     }
   });
@@ -2067,17 +2067,6 @@ let pendingCheckActive = false;
 let latestReadActive = false;
 let context = null;
 let currentOptimisticLane = null;
-/**
- * Marked sources read by the recompute currently on the stack (saved/restored
- * per recompute, like `context`). A computed that reads a node with a live
- * `affects()` mark inherits the mark's pendingness — `recompute` applies the
- * collected sources through `applyAffectsReads` after its commit, because the
- * `clearStatus` at the top of the commit path wipes whatever sentinel entries
- * the node held from the registration-time push. This is the pull half of
- * mark propagation (real async re-establishes itself by re-throwing on read;
- * marks are value-transparent, so they re-establish here instead).
- */
-let affectsReads = null;
 let snapshotCaptureActive = false;
 let snapshotSources = null;
 function ownerInSnapshotScope(owner) {
@@ -2164,9 +2153,6 @@ function recompute(el, create = false) {
   let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   let oldHeight = el._height;
   let prevTracking = tracking;
-  const prevAffectsReads = affectsReads;
-  affectsReads = null;
-  let markedReads = null;
   let prevLane = currentOptimisticLane;
   let prevStrictRead = false;
   {
@@ -2174,6 +2160,14 @@ function recompute(el, create = false) {
     strictRead = false;
   }
   tracking = true;
+  // A computed's fn establishes its OWN dependencies, so it must never run
+  // inside a latest() read window: read() short-circuits through the
+  // companion path before dependency linking, so a memo created (eagerly
+  // computed) inside latest(fn) came out permanently dependency-less (#2926).
+  // latestRead() already suspends the flag for its pull-recomputes; this
+  // covers creation-time computes and flushes that run inside the window.
+  const prevLatestRead = latestReadActive;
+  latestReadActive = false;
   // Lane posture lives with the engine: OPTIMISTIC_DIRTY is only ever set by
   // engine-driven paths, and _optimisticNodes is only pushed by
   // _optimisticWrite, so the hook is installed whenever either gate holds.
@@ -2230,12 +2224,11 @@ function recompute(el, create = false) {
     if (reaskChanged) GlobalQueue._repollVerdicts(el);
   } finally {
     tracking = prevTracking;
+    latestReadActive = prevLatestRead;
     strictRead = prevStrictRead;
     if (isStaleEffect) stale = prevStale;
     el._flags = REACTIVE_NONE | (create ? el._flags & REACTIVE_SNAPSHOT_STALE : 0);
     context = oldcontext;
-    markedReads = affectsReads;
-    affectsReads = prevAffectsReads;
   }
   if (!el._error) {
     trimStaleDeps(el);
@@ -2305,28 +2298,11 @@ function recompute(el, create = false) {
     }
   }
   currentOptimisticLane = prevLane;
-  // Marks read during this recompute re-attach after the commit above:
-  // earlier, the sentinel's NotReadyError in `_error` would have routed the
-  // fresh value into the error-skip branch instead of committing it. A real
-  // (non-NotReady) error wins over marks (#2893): applying the sentinel here
-  // would clobber the user's error with a NotReadyError from a node whose
-  // reads value-transparency promises can never throw NotReady.
-  // `markedReads` only collects under a live mark, so the hook is installed.
-  if (markedReads && !(el._statusFlags & STATUS_ERROR))
-    GlobalQueue._applyAffectsReads(el, markedReads);
-  // Mark-only pending doesn't queue (#2893): the node holds no value needing
-  // a transition-scheduled commit, and queueing would stamp the marking
-  // action's transaction onto it — freezing unrelated writes that share it.
-  // (Single mask test up front keeps the mark-free hot path at original cost.)
-  const pendFlags = el._statusFlags & (STATUS_PENDING | STATUS_UNINITIALIZED);
   const needsPendingCommit =
     el._pendingValue !== NOT_PENDING ||
     el._pendingFirstChild !== null ||
     el._pendingDisposal !== null ||
-    (pendFlags !== 0 &&
-      (pendFlags !== STATUS_PENDING ||
-        activeAffectsMarks === 0 ||
-        !GlobalQueue._onlyMarkPending(el)));
+    (el._statusFlags & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
   // Override-covered holds (hasOverride) always queue: their commit belongs
   // to their own transition's schedule (A18 re-rule) and is unobservable
   // under the override (A17). Revert no longer commits anything, so an
@@ -2635,17 +2611,14 @@ function read(el) {
     !snapshotCaptureActive &&
     !strictRead
   ) {
-    if (c && tracking) {
-      link(el, c);
-      // A live mark on a read source flows to the reader (probe reads are
-      // excluded: the probe's own collection owns that verdict, and marking
-      // the enclosing memo would make an `isPending` wrapper itself pending).
-      if (activeAffectsMarks !== 0 && el._affectsCount && !pendingCheckActive)
-        (affectsReads ??= []).push(el);
-    }
+    if (c && tracking) link(el, c);
     return !c || el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   }
-  if (strictRead && owner._statusFlags & STATUS_PENDING)
+  // The dev component-body safeguard (#2897) must not fire inside an
+  // isPending() probe: its plain Error would be swallowed by the probe's
+  // catch (which only rethrows NotReadyError), making dev return false where
+  // prod propagates NotReady (#2928). Probe reads follow the prod path.
+  if (strictRead && !pendingCheckActive && owner._statusFlags & STATUS_PENDING)
     throwPendingUntrackedRead(strictRead, {
       ownerId: c?.id,
       ownerName: c?._name,
@@ -2653,16 +2626,6 @@ function read(el) {
     });
   if (c && tracking) {
     link(el, c, pendingCheckActive);
-    // Mark inheritance through derivation (see the fast path above), and its
-    // transitive half (#2893): a mark-pended owner's sentinel sources flow to
-    // the reader like a direct mark — value-transparent reads have no throw
-    // to re-establish through, so without this a mid-window recompute sheds
-    // pendingness permanently past one derivation level.
-    if (activeAffectsMarks !== 0 && !pendingCheckActive) {
-      if (el._affectsCount) (affectsReads ??= []).push(el);
-      if (owner._statusFlags & STATUS_PENDING)
-        GlobalQueue._collectMarkSources(owner, (affectsReads ??= []));
-    }
     if (owner._fn) {
       const elQueue = queueFor(el);
       if (owner._height >= elQueue._min) {
@@ -2677,16 +2640,7 @@ function read(el) {
       }
     }
   }
-  // Mark-only pending never suspends the reader (#2886): an affects() mark is
-  // a promise of change, not an absence of value, so a derived node whose only
-  // pending sources are mark sentinels keeps its real value readable —
-  // pendingness reaches readers through verdicts (isPending), not throws.
-  // (`activeAffectsMarks` gates the source scan off the mark-free hot path;
-  // sentinels can't survive in pending sources past their last release.)
-  if (
-    owner._statusFlags & STATUS_PENDING &&
-    !(activeAffectsMarks !== 0 && GlobalQueue._onlyMarkPending(owner))
-  ) {
+  if (owner._statusFlags & STATUS_PENDING) {
     if (c && !(stale && owner._transition && activeTransition !== owner._transition)) {
       if (c && c._config & CONFIG_CHILDREN_FORBIDDEN) {
         const message =
@@ -2743,9 +2697,7 @@ function read(el) {
       nodeName: owner?._name
     });
   if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING) {
-    // An active override means the engine is installed (A17: the override IS
-    // the value for every reader — that check itself stays right here).
-    if (c && stale && GlobalQueue._readStashed(el)) return el._value;
+    // A17: the override IS the value for every reader.
     return unwrapOverride(el._overrideValue);
   }
   // Entanglement gate: a reader recomputing under an optimistic lane that reads
@@ -3136,9 +3088,6 @@ function isUndefined(value) {
  * `_optimisticNodes.length`, `activeLanes.size`), so `!` invocations are safe
  * once the gate holds — the same late-binding contract as verdict.ts.
  */
-// When a background transition is stashed, plain optimistic signals need one
-// committed-view rerun. Keep that override local to the stash flush.
-let stashedOptimisticReads = null;
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */
 function optimisticWrite(el, v) {
   const hasOverride = el._overrideValue !== NOT_PENDING;
@@ -3176,34 +3125,6 @@ function optimisticWrite(el, v) {
   schedule();
   return v;
 }
-function readStashed(node) {
-  return !!stashedOptimisticReads?.has(node);
-}
-function queueStashedOptimisticEffects(node) {
-  for (let s = node._subs; s !== null; s = s._nextSub) {
-    const sub = s._sub;
-    if (!sub._type) continue;
-    enqueueSub(sub);
-  }
-}
-/**
- * Incomplete-transition finalization when the stashed transition holds
- * optimistic nodes: give plain optimistic signals one committed-view rerun.
- */
-function stashOptimistic(stashedTransition) {
-  stashedOptimisticReads = new Set();
-  for (let i = 0; i < stashedTransition._optimisticNodes.length; i++) {
-    const node = stashedTransition._optimisticNodes[i];
-    if (node._fn || node._config & CONFIG_OWNED_WRITE) continue;
-    stashedOptimisticReads.add(node);
-    queueStashedOptimisticEffects(node);
-  }
-  try {
-    finalizePureQueue(null, true);
-  } finally {
-    stashedOptimisticReads = null;
-  }
-}
 /**
  * transitionComplete's override blockage: a settling transition stays open
  * while one of its optimistic nodes holds an active override that is still
@@ -3216,11 +3137,7 @@ function transitionBlocked(transition) {
       hasActiveOverride(node) &&
       "_statusFlags" in node &&
       node._statusFlags & STATUS_PENDING &&
-      node._error instanceof NotReadyError &&
-      // Mark-sourced pending never blocks settlement: affects() releases AT
-      // settle, so counting its sentinel here would deadlock the window it
-      // is scoped to.
-      !node._error.source?._affectsFor
+      node._error instanceof NotReadyError
     ) {
       return true;
     }
@@ -3382,11 +3299,9 @@ function installOptimisticEngine() {
   if (GlobalQueue._optimisticWrite !== null) return;
   GlobalQueue._optimisticWrite = optimisticWrite;
   GlobalQueue._resolveOptimistic = resolveOptimisticNodes;
-  GlobalQueue._stashOptimistic = stashOptimistic;
   GlobalQueue._transitionBlocked = transitionBlocked;
   GlobalQueue._cleanupLanes = cleanupCompletedLanes;
   GlobalQueue._runLaneEffects = runLaneEffects;
-  GlobalQueue._readStashed = readStashed;
   GlobalQueue._gatedRead = gatedRead;
   GlobalQueue._laneSuspends = laneSuspends;
   GlobalQueue._laneReadsCommitted = laneReadsCommitted;
@@ -3435,6 +3350,46 @@ function collectPendingSources(el) {
 function witnessAffects(node) {
   pendingProbe?.sources.add(node);
 }
+/**
+ * The affects() coverage walk — the read half of the dedicated mark channel.
+ * A node is covered by a live mark iff it carries one (`_affectsCount`) or
+ * derives, through its CURRENT deps (hopping store firewalls), from a node
+ * that does. Pull-based coverage means graph rewires, mid-window recomputes,
+ * and probe-triggered recomputes can never strand or strip a mark — there is
+ * nothing stored downstream to corrupt. Probe-created links
+ * (`_pendingObserver`) are skipped so an `isPending` wrapper memo never
+ * inherits the coverage it reports on.
+ */
+function markWalk(el, seen) {
+  if (el._affectsCount) return true;
+  // A real error outranks an inherited mark (A16/A24c): an errored node
+  // answers probes with its error, not a coverage verdict, and coverage does
+  // not flow through it — matching the rails' behavior, where propagation
+  // stopped at errored nodes. A DIRECT mark on an errored node still reads
+  // pending (the count check above), also matching.
+  if (el._statusFlags & STATUS_ERROR) return false;
+  if (seen.has(el)) return false;
+  seen.add(el);
+  const firewall = el._firewall;
+  if (firewall && markWalk(firewall, seen)) return true;
+  // Mid-recompute (the clearStatus companion poke runs before
+  // trimStaleDeps), only the validated prefix [_deps.._depsTail] is this
+  // pass's dependency set — walking past it would read dropped deps and
+  // latch a stale verdict on the companion.
+  const comp = el;
+  const tail = comp._flags & REACTIVE_RECOMPUTING_DEPS ? comp._depsTail : undefined;
+  if (tail !== null) {
+    for (let d = comp._deps ?? null; d !== null; d = d._nextDep) {
+      if (!d._pendingObserver && markWalk(d._dep, seen)) return true;
+      if (d === tail) break;
+    }
+  }
+  return false;
+}
+/** Gated entry: apps with no live mark pay one integer compare. */
+function markCovered(el) {
+  return activeAffectsMarks !== 0 && markWalk(el, new Set());
+}
 function quietPending(el) {
   if (el._pendingSources) {
     for (const source of el._pendingSources) if (!source._reask) return false;
@@ -3452,11 +3407,13 @@ function newQuestionInFlight(comp) {
 function computePendingState(el) {
   const comp = el;
   if (comp._flags & REACTIVE_DISPOSED) return false;
-  if (el._affectsCount) return true;
+  // Mark coverage is transitive by dep-graph reachability: a latest() shadow
+  // reaches its owner (and a store leaf its firewall) through its own deps,
+  // so the one walk covers direct marks, derivation, and companion chains.
+  if (markCovered(el)) return true;
   const firewall = el._firewall;
   if (el._parentSource) {
     const parentNode = el._parentSource;
-    if (parentNode._affectsCount) return true;
     const parent = parentNode._firewall || parentNode;
     return newQuestionInFlight(parent);
   }
@@ -3489,12 +3446,22 @@ function updateChildCompanions(el) {
     if (child._pendingSignal || child._latestValueComputed) updatePendingSignal(child);
   }
 }
-function repollDownstreamVerdicts(el) {
+/**
+ * Re-derive every verdict companion downstream of `el` (subs + firewall
+ * children, dedup'd). The affects() channel's poke walk: registration and
+ * re-ask flips use the live write path (companion setSignal — its own lane
+ * lets the wake escape an incomplete transition's effect stash, #2887);
+ * mark release passes `snap` because it runs inside queue finalization,
+ * where companion writes must land committed (a setSignal there would open
+ * a fresh override window that nothing settles).
+ */
+function repollDownstreamVerdicts(el, snap = false) {
+  const update = snap ? snapCompanionsToState : updatePendingSignal;
   const visited = new Set();
   const visit = node => {
     if (visited.has(node)) return;
     visited.add(node);
-    if (node._pendingSignal || node._latestValueComputed) updatePendingSignal(node);
+    if (node._pendingSignal || node._latestValueComputed) update(node);
     for (let s = node._subs; s !== null; s = s._nextSub) visit(s._sub);
     for (let child = node._child ?? null; child !== null; child = child._nextChild) {
       visit(child);
@@ -3557,6 +3524,19 @@ function latestRead(el) {
       : el._value;
   let value;
   try {
+    // An untracked latest() read has no reading context, so read() never
+    // performs its mid-tick pull — a plain write queued between two latest()
+    // calls left a still-subscribed shadow at its previous speculative value
+    // until the flush (#2922). Mirror the tracked-read pull here: mark the
+    // queued staleness through the graph, then bring the shadow up to date.
+    const queue = queueFor(pendingComputed);
+    if (
+      pendingComputed._height >= queue._min &&
+      !(pendingComputed._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))
+    ) {
+      markHeap(queue);
+      prepareComputed(pendingComputed, true);
+    }
     value = read(pendingComputed);
   } catch (e) {
     if (e instanceof NotReadyError && (!context || !(el._statusFlags & STATUS_UNINITIALIZED)))
@@ -3573,6 +3553,16 @@ function latestRead(el) {
       return visibleValue;
     }
   }
+  // A shadow recomputed by the pull above (not at creation) holds its fresh
+  // speculative value in _pendingValue; a contextless read() only surfaces
+  // _value. Overrides stay authoritative (A17), and stale readers keep the
+  // other transition's committed view, matching read()'s own selection.
+  if (
+    pendingComputed._pendingValue !== NOT_PENDING &&
+    !hasActiveOverride(pendingComputed) &&
+    !(stale && pendingComputed._transition && activeTransition !== pendingComputed._transition)
+  )
+    return pendingComputed._pendingValue;
   return value;
 }
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */
@@ -3882,6 +3872,22 @@ function restoreTransition(transition, fn) {
   return result;
 }
 /**
+ * The primitive for mutations: imperative async workflows whose *writes span
+ * an async gap* — optimistic write, server round-trip, reconciling write —
+ * where intermediate state must not leak and failure must revert cleanly
+ * (pair with `createOptimistic` / `createOptimisticStore`).
+ *
+ * Navigation-shaped updates do not need an action. A plain setter call is
+ * enough: reads pull the async, and downstream async computeds hold their
+ * previous values per-node until the new ones are ready (`isPending` /
+ * `latest` expose the in-flight state). Reach for `action` only when writes
+ * happen *after* async work, not merely upstream of it.
+ *
+ * Framework-level actions (router form actions, server actions) are
+ * specializations of this primitive: they are actions in exactly this sense —
+ * the same transactional semantics — with form binding, serialization, and
+ * submission tracking layered on top. The shared name is deliberate.
+ *
  * Wraps a generator function so each invocation runs as a single transaction
  * (a "transition") that batches every signal/store write between yields. The
  * surrounding UI sees one atomic update per yielded step; nothing is committed
@@ -3980,11 +3986,33 @@ function action(genFn) {
       };
       const run = r => {
         if (r.done) return done(r.value);
-        if (isThenable(r.value))
-          return void r.value.then(
-            v => restoreTransition(ctx, () => step(v)),
-            e => restoreTransition(ctx, () => step(e, true))
-          );
+        // Thenable assimilation can itself throw synchronously (a `then`
+        // getter, or a `then()` method that throws — #2918). Match `await`
+        // semantics: the failure is thrown back into the generator at the
+        // yield point (catchable there); if uncaught, step()'s guard settles
+        // the action so its iterator never leaks in the transition. The
+        // settled flag implements A+ 2.3.3.3.4.1: a throw after the thenable
+        // already called a callback is ignored.
+        let settled = false;
+        try {
+          if (isThenable(r.value))
+            return void r.value.then(
+              v => {
+                if (settled) return;
+                settled = true;
+                restoreTransition(ctx, () => step(v));
+              },
+              e => {
+                if (settled) return;
+                settled = true;
+                restoreTransition(ctx, () => step(e, true));
+              }
+            );
+        } catch (e) {
+          if (settled) return;
+          settled = true;
+          return void restoreTransition(ctx, () => step(e, true));
+        }
         restoreTransition(ctx, () => step(r.value));
       };
       step();
@@ -4260,6 +4288,12 @@ function createReaction(effectFn, options) {
     });
   };
 }
+/** Delivers effect applies on a microtask instead of queueing them (#2930). */
+class MicrotaskQueue extends Queue {
+  enqueue(type, fn) {
+    queueMicrotask(() => fn(type));
+  }
+}
 /**
  * Awaits a reactive expression and returns its first fully-settled value as a
  * `Promise`. Pending async reads (`createMemo` returning a promise, etc.) are
@@ -4289,6 +4323,17 @@ function resolve(fn) {
   }
   return new Promise((res, rej) => {
     createRoot(dispose => {
+      // Deliver effect applies on a microtask instead of the owner queue: an
+      // incomplete transition stashes its effect queues until it settles, but
+      // an action yielding this promise is itself what keeps the transition
+      // open — the stashed res() deadlocked the action (#2930). The compute
+      // still runs in place (under the transaction's view when created inside
+      // an action step), and status/boundary notifications keep their normal
+      // route through the inherited queue.
+      const owner = getOwner();
+      const queue = new MicrotaskQueue();
+      queue._parent = owner._queue; // notify() forwards up the normal chain
+      owner._queue = queue;
       // A user effect rather than a bare computed: computeds are pull-based and
       // are only re-enqueued when a pending source *resolves* — a rejection just
       // marks them errored, so nothing would re-run and the promise would never
@@ -6027,127 +6072,76 @@ function createStore(first, second, options) {
 }
 
 /**
- * The pending-source identity of a live `affects()` mark on `node` (lazy,
- * one per node, shared by overlapping registrations via the refcount).
- *
- * A mark rides the SAME status rails as real in-flight async — downstream
- * subscribers hold the sentinel in `_pendingSources` — but under its own
- * identity so the two channels can't clear each other:
- * - `_reask` is permanently `false`: a mark is by definition a declared
- *   value change, so `quietPending` never silences a window it participates
- *   in — even when the mark rides over an otherwise-quiet `refresh()`
- *   re-ask of the same node (the whole point of declaring one).
- * - A landing on the marked node settles only the node's OWN source entry;
- *   the sentinel entry survives until the mark's transaction releases it.
- * - The sentinel itself never carries `STATUS_PENDING`, so
- *   `transitionComplete` never counts a mark as a blocker of its own
- *   transaction (release happens AT settle — self-blocking would deadlock),
- *   and reads of the marked node never throw (marks are value-transparent
- *   at the source; pendingness is what propagates).
+ * The counting half of a mark, shared by direct registration and store-scope
+ * inheritance (a node created inside a live keyless mark's identity scope).
+ * A mark is ONLY this count: coverage of everything derived from the node is
+ * pull-derived by the verdict layer's `markWalk` (dep-graph reachability), so
+ * nothing is stored downstream and nothing can be stranded or stripped by
+ * mid-window recomputes.
  */
-function getAffectsSentinel(node) {
-  return (node._affectsSentinel ??= {
-    _name: "affects-sentinel",
-    // Brand + backref: lets the scheduler's settlement checks recognize
-    // mark-sourced pending (which must never block its own transaction —
-    // release happens AT settle).
-    _affectsFor: node,
-    _flags: 0,
-    _statusFlags: 0,
-    _reask: false,
-    _error: undefined,
-    _subs: null,
-    _deps: null
-  });
+function markAffects(node) {
+  node._affectsCount = (node._affectsCount || 0) + 1;
+  shiftAffectsMarks(1);
 }
 /**
- * Push a live mark's pendingness downstream from the marked node through the
- * normal status rails. Runs on every registration (dedup in `notifyStatus`
- * stops re-descent at already-covered subscribers). Subscribers that
- * recompute mid-window shed this via `clearStatus` and re-acquire it through
- * the read path (`applyAffectsReads` for direct readers of the marked node,
- * `collectMarkSources` transitively) — the mark analogue of real async's
- * re-throw-on-read. Subscribers are deliberately NOT queued as pending nodes
- * (#2893): they hold no value needing a transition-scheduled commit, and
- * queueing would stamp the marking action's transaction onto them — from then
- * on ANY write dirtying one of them (including writes to unmarked signals
- * that merely share a downstream memo) would be captured and frozen until the
- * action settles.
+ * Boundary visual channel: within a transaction, a live mark holds Loading
+ * fallbacks / reveal ordering the way real in-flight async would — but the
+ * notification is tagged visibility-only at the source (`_markVisual`), so
+ * the root queue never registers reporters from it: marks are invisible to
+ * ALL completion and settlement accounting by construction. Boundaries hold
+ * the marked node in `_sources` while `_affectsCount` is live; the release
+ * sweep (finalizePureQueue re-checks boundary children after mark release)
+ * is the display-state update point. Ambient marks release inside the same
+ * flush that would surface them, before effects run — verdict-only, netting
+ * no visual change.
  */
-function propagateAffectsMark(node) {
+function notifyMarkBoundaries(node) {
   if (!node._subs && !node._child) return;
-  const sentinel = getAffectsSentinel(node);
-  const error = new NotReadyError(sentinel);
-  forEachDependent(node, sub => {
-    if (!sub._pendingSources?.has(sentinel)) {
-      notifyStatus(sub, STATUS_PENDING, error);
-    }
-  });
-}
-/**
- * Re-establish mark pendingness on a computed that read marked sources
- * during its recompute (`clearStatus` at the top of the commit path wiped
- * any sentinel entries it held). Called by `recompute` after the commit —
- * not before, because setting `_error` earlier would make the commit path
- * treat the node as errored and skip the value write.
- */
-function applyAffectsReads(el, sources) {
-  let applied = false;
-  for (let i = 0; i < sources.length; i++) {
-    const src = sources[i];
-    if (!src._affectsCount) continue;
-    const sentinel = getAffectsSentinel(src);
-    if (addPendingSource(el, sentinel)) {
-      el._statusFlags |= STATUS_PENDING;
-      setPendingError(el, sentinel);
-      applied = true;
+  const error = new NotReadyError(node);
+  error._markVisual = true;
+  const visited = new Set();
+  const visit = sub => {
+    if (visited.has(sub)) return;
+    visited.add(sub);
+    // Display consumers (render effects, boundary computeds) act on the
+    // notification; descent stops there, exactly like the status rails.
+    if (sub._notifyStatus) {
+      sub._notifyStatus(STATUS_PENDING, error);
+      return;
     }
-  }
-  if (applied && GlobalQueue._updatePendingSignal !== null) GlobalQueue._updatePendingSignal(el);
-}
-/**
- * The counting half of a mark, shared by direct registration and store-scope
- * inheritance (a node created inside a live keyless mark's identity scope):
- * bumps the refcount and pokes the node's verdict companions so an
- * already-materialized `false` flips reactively.
- */
-function markAffects(node) {
-  node._affectsCount = (node._affectsCount || 0) + 1;
-  shiftAffectsMarks(1);
-  // Companions only exist once the verdict layer (isPending/latest) loaded;
-  // without them there is no materialized verdict to flip.
-  if (node._affectsCount === 1 && GlobalQueue._updatePendingSignal !== null)
-    GlobalQueue._updatePendingSignal(node);
+    forEachDependent(sub, visit);
+  };
+  forEachDependent(node, visit);
 }
 /**
  * Registers one `affects()` mark on a node: counts it, records the
  * registration with the current transaction (after initTransition the queue's
- * batch IS the active transition, mirroring `_optimisticNodes`), and
- * propagates STATUS_PENDING downstream on the status rails so everything
- * DERIVED from the marked data reads pending too. Propagation runs on every
- * registration (not just the first): subscribers gained since an earlier
- * overlapping registration get covered, and dedup stops re-descent early.
+ * batch IS the active transition, mirroring `_optimisticNodes`), re-derives
+ * every downstream verdict companion (the mark channel's only push — verdict
+ * pokes, not state), and notifies boundary display state. Both walks run on
+ * every registration (not just the first): subscribers gained since an
+ * earlier overlapping registration get covered, and dedup stops re-descent.
  */
 function registerAffectsMark(node) {
   markAffects(node);
   globalQueue._batch._affectsNodes.push(node);
-  propagateAffectsMark(node);
+  // Companions only exist once the verdict layer (isPending/latest) loaded;
+  // without them there is no materialized verdict to poke.
+  GlobalQueue._repollVerdicts !== null && GlobalQueue._repollVerdicts(node);
+  notifyMarkBoundaries(node);
   schedule();
 }
 /**
- * Releases one registration. When the node's last mark drops, settles the
- * mark's sentinel out of every downstream `_pendingSources` (waking blocked
- * nodes and re-deriving verdicts along the walk). Companion writes go through
- * the settlement snap (committed, not transition-scoped) so releasing a mark
- * can't open a fresh override window that would itself need settlement.
+ * Releases one registration. When the node's last mark drops, re-derives
+ * every downstream verdict through the settlement snap (committed, not
+ * transition-scoped — release runs inside queue finalization, where a
+ * setSignal would open a fresh override window that nothing settles).
  */
 function releaseAffectsMark(node) {
   shiftAffectsMarks(-1);
   node._affectsCount--;
   if (!node._affectsCount) {
-    const sentinel = node._affectsSentinel;
-    if (sentinel) settlePendingSource(node, sentinel, true);
-    GlobalQueue._snapCompanions !== null && GlobalQueue._snapCompanions(node);
+    GlobalQueue._repollVerdicts !== null && GlobalQueue._repollVerdicts(node, true);
     GlobalQueue._releaseAffectsScope?.(node);
   }
 }
@@ -6159,53 +6153,14 @@ function releaseAffectsMarks(nodes) {
   for (let i = 0; i < nodes.length; i++) releaseAffectsMark(nodes[i]);
   nodes.length = 0;
 }
-/**
- * True when a node's pending status comes ONLY from affects() sentinels. A
- * mark is a promise of change, not an absence of value: reads of mark-pended
- * derived nodes stay value-transparent (verdicts report pending; the read
- * path must not suspend). Any real async source among the pending sources
- * keeps normal suspension semantics. Core's read path reaches this through
- * `GlobalQueue._onlyMarkPending`, gated on the `activeAffectsMarks` counter.
- */
-function onlyMarkPending(el) {
-  const sources = el._pendingSources;
-  if (sources) {
-    for (const s of sources) if (!s._affectsFor) return false;
-    return true;
-  }
-  return false;
-}
-/**
- * Collect the still-live marked nodes behind a pended owner's sentinel
- * sources into a recompute's `affectsReads`. This is the transitive half of
- * read-path re-establishment (#2893): real async re-establishes at every
- * derivation level because its re-throw on read re-registers the source, but
- * mark-pended reads are value-transparent — without this, pendingness dies on
- * the first mid-window recompute past depth one, and the isPending() probe
- * itself (whose prepare step recomputes retryable NotReady holders) strips
- * the very status it reports on. Reached through
- * `GlobalQueue._collectMarkSources`, gated on `activeAffectsMarks`.
- */
-function collectMarkSources(el, into) {
-  if (el._pendingSources) {
-    for (const s of el._pendingSources) {
-      const marked = s._affectsFor;
-      if (marked && marked._affectsCount) into.push(marked);
-    }
-  }
-}
 // Late installation (same pattern as `GlobalQueue._update`): the mark engine
 // lives with the feature so graphs that never declare a mark never ship it.
-// Each call site is gated by state only this module creates (`markedReads`
-// collection under `activeAffectsMarks`, a non-empty `_affectsNodes` batch,
-// a live scope in the store's `affectsScopes`), so the hooks are installed
-// before the first time any of them can fire.
-GlobalQueue._applyAffectsReads = applyAffectsReads;
+// Each call site is gated by state only this module creates (a non-empty
+// `_affectsNodes` batch, a live scope in the store's `affectsScopes`), so the
+// hooks are installed before the first time any of them can fire.
 GlobalQueue._releaseAffectsMarks = releaseAffectsMarks;
 GlobalQueue._markAffects = markAffects;
 GlobalQueue._releaseAffectsMark = releaseAffectsMark;
-GlobalQueue._onlyMarkPending = onlyMarkPending;
-GlobalQueue._collectMarkSources = collectMarkSources;
 function affects(target, key) {
   if (arguments.length > 2) {
     const message =
@@ -7436,9 +7391,14 @@ class CollectionQueue extends Queue {
   }
   _checkSources() {
     for (const source of this._sources) {
+      // A source with a live affects() mark holds display state for the
+      // mark's lifetime (the visual channel): the marked node carries no
+      // status of its own, so the count is the liveness test. The release
+      // sweep (finalizePureQueue after mark release) re-runs this check.
       if (
         source._flags & REACTIVE_DISPOSED ||
-        (!(source._statusFlags & this._collectionType) &&
+        (!source._affectsCount &&
+          !(source._statusFlags & this._collectionType) &&
           !(this._collectionType & STATUS_ERROR && source._statusFlags & STATUS_PENDING))
       )
         this._sources.delete(source);