@solidjs/signals 2.0.0-rc.19 → 2.0.0-rc.20

package/dist/dev.js

@@ -1,6 +1,7 @@
 import {
   C as CONFIG_GUESS,
   N as NOT_PENDING,
+  S as STATUS_UNINITIALIZED,
   a as NotReadyError,
   b as CONFIG_AUTHORITATIVE,
   e as enqueueSub,
@@ -8,186 +9,198 @@ import {
   s as schedule,
   q as question,
   n as nextQuestion,
+  d as armGuessing,
   i as installLaneHooks,
   G as GlobalQueue,
   r as resolveTx,
-  d as newTransaction,
-  o as ownFlights,
-  R as REACTIVE_DISPOSED,
-  f as CONFIG_VERDICT,
-  g as REACTIVE_PROBE_UNANSWERED,
-  h as blocked,
-  j as REACTIVE_LANE_DIRTY,
-  k as CONFIG_HELD,
-  t as txOf,
-  l as clock,
-  m as insertSubs,
-  p as laneDirty,
-  u as REACTIVE_LANE_READ,
+  f as newTransaction,
+  l as list,
+  g as staleReader,
+  h as removePendingSource,
+  R as REACTIVE_DIRTY,
+  j as REACTIVE_CHECK,
+  k as REACTIVE_IN_HEAP,
+  m as releaseFlightTeardown,
+  o as handleAsync,
+  p as notifyStatus,
+  t as STATUS_PENDING,
+  u as CONFIG_SLOT_NODE,
   v as ext,
-  S as STATUS_UNINITIALIZED,
-  w as REACTIVE_RECOMPUTING_DEPS,
-  x as queuePendingNode,
-  y as list,
-  z as STATUS_ERROR,
-  A as tracking,
-  B as CONFIG_CHILDREN_FORBIDDEN,
-  D as passLane,
-  E as EFFECT_RENDER,
-  F as setPassLane,
-  H as sameLane,
-  I as flushTransaction,
-  J as REACTIVE_SCREEN_READ,
-  K as REACTIVE_FRAME_READ,
-  L as attrHooks,
-  M as commitPendingNode,
-  O as REACTIVE_IN_HEAP,
-  P as REACTIVE_DIRTY,
-  Q as REACTIVE_CHECK,
-  T as STATUS_PENDING,
-  U as CONFIG_INPUTS_PUBLISHED,
-  V as releaseQueues,
-  W as CONFIG_SLOT_NODE,
-  X as holdNode,
-  Y as joinFuture,
-  Z as reruns,
-  _ as CONFIG_STAGED,
-  $ as merge$1,
-  a0 as REACTIVE_JOINED,
-  a1 as REACTIVE_STAGED_READ,
-  a2 as stagedRead,
-  a3 as setVerdict,
-  a4 as context,
-  a5 as installVerdictHooks,
-  a6 as REACTIVE_PROBED,
-  a7 as verdict,
-  a8 as link,
-  a9 as pullComputed,
-  aa as strictRead,
-  ab as strictReadActive,
-  ac as warnStrictReadUntracked,
-  ad as staleReader,
-  ae as globalQueue,
-  af as joinPass,
-  ag as markLateLinker,
-  ah as spectating,
-  ai as unflushedValue,
-  aj as CONFIG_STAGED_ERROR,
-  ak as stagedReaders,
-  al as bornInto,
-  am as enterAction,
-  an as setEffectCallback,
-  ao as exitAction,
-  ap as isThenable,
-  aq as actionDepth,
-  ar as flush,
-  as as setQuestion,
-  at as emitDiagnostic,
-  au as enterCallback,
-  av as exitCallback,
-  aw as getOwner,
-  ax as inEffectCallback,
-  ay as effectCallbackEvent,
-  az as setExternalHooks,
-  aA as signal,
-  aB as setSignal,
-  aC as cleanup,
-  aD as read,
-  aE as DEV$1,
-  aF as CONFIG_TRANSPARENT,
-  aG as NoOwnerError,
-  aH as ContextNotFoundError,
-  aI as createEffectNode,
-  aJ as recompute,
-  aK as EFFECT_USER,
-  aL as reportDiagnostic,
-  aM as computed,
-  aN as staleValues,
-  aO as CONFIG_AUTO_DISPOSE,
-  aP as EFFECT_TRACKED,
-  aQ as heldRunHook,
-  aR as unwrapStatusError,
-  aS as setStrictRead,
-  aT as queueEvent,
-  aU as StatusError,
-  aV as trimStaleDeps,
-  aW as haltReactivityAt,
-  aX as strictReadEvent,
-  aY as setTrackedQueueCallback,
-  aZ as setEffectStatusNotify,
-  a_ as _hitUnhandledAsync,
-  a$ as resetUnhandledAsync,
-  b0 as ROOT_ERROR_HOOK,
-  b1 as registerGraph,
-  b2 as runWithOwner,
-  b3 as setMemo,
-  b4 as $REFRESH,
-  b5 as markRefresh,
-  b6 as createRoot,
-  b7 as getObserver,
-  b8 as dispose,
-  b9 as TimeoutError,
-  ba as untrack,
-  bb as dirtyQueue,
-  bc as CONFIG_REDERIVE,
-  bd as passTx,
-  be as CONFIG_FRESH_READ,
-  bf as createOwner,
-  bg as writeHook,
-  bh as REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE,
-  bi as ownedScopeWriteMessage,
-  bj as isEqual,
-  bk as CONFIG_MANUAL_WRITE,
-  bl as snapshotCaptureActive,
-  bm as captureWriteSnapshot,
-  bn as notePromotedWrite,
-  bo as slotSignal,
-  bp as stagedScreen,
-  bq as CONFIG_PROMOTED,
-  br as setSlotUnobserved,
-  bs as installStoreHooks,
-  bt as joinPassTx,
-  bu as asyncTailFlights,
-  bv as untrackDepth,
-  bw as checkPostAwaitRead,
-  bx as disposalDepth,
-  by as insertIntoHeap,
-  bz as isDisposed,
-  bA as handleAsync,
-  bB as addPendingSource,
-  bC as propagateStatus,
-  bD as forEachDependent,
-  bE as settlePendingSource,
-  bF as joinPassAt,
-  bG as notifyEpoch,
-  bH as SUPPORTS_PROXY,
-  bI as CONFIG_KEY_BAG,
-  bJ as releaseMarksHook,
-  bK as installMarkHooks,
-  bL as CONFIG_LAGS,
-  bM as REACTIVE_REASK,
-  bN as onSupersede,
-  bO as haltReactivity,
-  bP as CONFIG_FRAME,
-  bQ as heldUnder,
-  bR as unhold,
-  bS as laneStageHook,
-  bT as REACTIVE_ZOMBIE,
-  bU as installBoundaryHooks,
-  bV as CAUGHT_REARMED,
-  bW as OBSERVE$1
+  w as txOf,
+  x as commitPendingNode,
+  y as ownFlights,
+  z as stagedReaders,
+  A as REACTIVE_STAGED_READ,
+  B as REACTIVE_DISPOSED,
+  D as CONFIG_VERDICT,
+  E as REACTIVE_PROBE_UNANSWERED,
+  F as blocked,
+  H as bornInto,
+  I as REACTIVE_LANE_DIRTY,
+  J as isThenable,
+  K as CONFIG_HELD,
+  L as clock,
+  M as insertSubs,
+  O as laneDirty,
+  P as REACTIVE_LANE_READ,
+  Q as flushTransaction,
+  T as REACTIVE_RECOMPUTING_DEPS,
+  U as queuePendingNode,
+  V as STATUS_ERROR,
+  W as tracking,
+  X as CONFIG_CHILDREN_FORBIDDEN,
+  Y as passLane,
+  Z as EFFECT_RENDER,
+  _ as setPassLane,
+  $ as sameLane,
+  a0 as REACTIVE_SCREEN_READ,
+  a1 as REACTIVE_FRAME_READ,
+  a2 as attrHooks,
+  a3 as CONFIG_INPUTS_PUBLISHED,
+  a4 as releaseQueues,
+  a5 as holdNode,
+  a6 as reruns,
+  a7 as CONFIG_STAGED,
+  a8 as merge$1,
+  a9 as creatorReads,
+  aa as REACTIVE_JOINED,
+  ab as stagedRead,
+  ac as setVerdict,
+  ad as context,
+  ae as installVerdictHooks,
+  af as creatorPass,
+  ag as CONFIG_ASYNC,
+  ah as REACTIVE_PROBED,
+  ai as REACTIVE_WINDOW,
+  aj as verdict,
+  ak as prepareComputed,
+  al as link,
+  am as pullComputed,
+  an as strictRead,
+  ao as strictReadActive,
+  ap as warnStrictReadUntracked,
+  aq as globalQueue,
+  ar as joinFuture,
+  as as joinPass,
+  at as markLateLinker,
+  au as spectating,
+  av as unflushedValue,
+  aw as CONFIG_STAGED_ERROR,
+  ax as REACTIVE_REASK,
+  ay as enterAction,
+  az as setEffectCallback,
+  aA as exitAction,
+  aB as actionDepth,
+  aC as flush,
+  aD as setQuestion,
+  aE as emitDiagnostic,
+  aF as enterCallback,
+  aG as exitCallback,
+  aH as getOwner,
+  aI as inEffectCallback,
+  aJ as effectCallbackEvent,
+  aK as setExternalHooks,
+  aL as signal,
+  aM as setSignal,
+  aN as cleanup,
+  aO as read,
+  aP as DEV$1,
+  aQ as CONFIG_TRANSPARENT,
+  aR as NoOwnerError,
+  aS as ContextNotFoundError,
+  aT as createEffectNode,
+  aU as recompute,
+  aV as EFFECT_USER,
+  aW as reportDiagnostic,
+  aX as computed,
+  aY as staleValues,
+  aZ as CONFIG_AUTO_DISPOSE,
+  a_ as EFFECT_TRACKED,
+  a$ as heldRunHook,
+  b0 as unwrapStatusError,
+  b1 as setStrictRead,
+  b2 as queueEvent,
+  b3 as StatusError,
+  b4 as trimStaleDeps,
+  b5 as haltReactivityAt,
+  b6 as strictReadEvent,
+  b7 as setTrackedQueueCallback,
+  b8 as setEffectStatusNotify,
+  b9 as _hitUnhandledAsync,
+  ba as resetUnhandledAsync,
+  bb as ROOT_ERROR_HOOK,
+  bc as registerGraph,
+  bd as runWithOwner,
+  be as setMemo,
+  bf as $REFRESH,
+  bg as markRefresh,
+  bh as createRoot,
+  bi as getObserver,
+  bj as dispose,
+  bk as TimeoutError,
+  bl as untrack,
+  bm as dirtyQueue,
+  bn as CONFIG_REDERIVE,
+  bo as passTx,
+  bp as CONFIG_FRESH_READ,
+  bq as createOwner,
+  br as writeHook,
+  bs as REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE,
+  bt as ownedScopeWriteMessage,
+  bu as isEqual,
+  bv as CONFIG_MANUAL_WRITE,
+  bw as checkForeignRead,
+  bx as snapshotCaptureActive,
+  by as captureWriteSnapshot,
+  bz as notePromotedWrite,
+  bA as slotSignal,
+  bB as stagedScreen,
+  bC as devRead,
+  bD as CONFIG_PROMOTED,
+  bE as setSlotUnobserved,
+  bF as installStoreHooks,
+  bG as joinPassTx,
+  bH as asyncTailFlights,
+  bI as untrackDepth,
+  bJ as checkPostAwaitRead,
+  bK as disposalDepth,
+  bL as insertIntoHeap,
+  bM as isDisposed,
+  bN as addPendingSource,
+  bO as propagateStatus,
+  bP as forEachDependent,
+  bQ as settlePendingSource,
+  bR as joinPassAt,
+  bS as notifyEpoch,
+  bT as SUPPORTS_PROXY,
+  bU as CONFIG_KEY_BAG,
+  bV as releaseMarksHook,
+  bW as installMarkHooks,
+  bX as CONFIG_LAGS,
+  bY as onSupersede,
+  bZ as haltReactivity,
+  b_ as CONFIG_FRAME,
+  b$ as heldUnder,
+  c0 as unhold,
+  c1 as laneStageHook,
+  c2 as REACTIVE_ZOMBIE,
+  c3 as installBoundaryHooks,
+  c4 as CAUGHT_REARMED,
+  c5 as OBSERVE$1
 } from "./dev-shared.js";
 export {
-  bX as clearSnapshots,
-  bY as enforceLoadingBoundary,
-  bZ as getNextChildId,
-  b_ as markSnapshotScope,
-  b$ as peekNextChildId,
-  c0 as releaseSnapshotScope,
-  c1 as resetErrorHalt,
-  c2 as setConsoleFooter,
-  c3 as setSnapshotCapture,
-  c4 as setWriteHook
+  c6 as checkForeignOwnerless,
+  c7 as clearSnapshots,
+  c8 as enforceLoadingBoundary,
+  c9 as getNextChildId,
+  ca as markSnapshotScope,
+  cb as peekNextChildId,
+  cc as releaseSnapshotScope,
+  cd as resetErrorHalt,
+  ce as runAsSolidCopy,
+  cf as setConsoleFooter,
+  cg as setSnapshotCapture,
+  ch as setWriteHook
 } from "./dev-shared.js";
 
 // Truth reads (`until`, `refresh`; CONFIG_AUTHORITATIVE) over lane nodes.
@@ -196,11 +209,13 @@ export {
 // which exists once something installs lanes (`createOptimistic`, verdicts).
 /** A lane node's current value: its guess, or the latest it derived — the
  * staging a shown lane holds for its next reveal, else its slot; the
- * committed value while it has none (its first lane pass in flight). */
+ * committed value while it has none (its first lane pass in flight) —
+ * NOT_PENDING for a node with no committed value either (born in the lane,
+ * uninitialized: its reads throw NotReady, A7; #4363). */
 function laneValueOf(el) {
   if (!(el._config & CONFIG_GUESS) && el._pendingValue !== NOT_PENDING) return el._pendingValue;
   const v = el._x._lane;
-  return v !== NOT_PENDING ? v : el._value;
+  return v !== NOT_PENDING || el._statusFlags & STATUS_UNINITIALIZED ? v : el._value;
 }
 /** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
  * the first one installs these on GlobalQueue (signals.ts `watch`).
@@ -272,10 +287,15 @@ function newLane(parent) {
   return l;
 }
 /** What the screen shows for a lane's node: the lane's value once the lane
- * has revealed, the committed truth before. */
+ * has revealed, the committed truth before — NOT_PENDING when there is none
+ * (uninitialized, as `laneValueOf`): its read throws NotReady. */
 function display(el) {
   const v = el._x._lane;
-  return el._x._transaction._shown && v !== NOT_PENDING ? v : el._value;
+  return el._x._transaction._shown && v !== NOT_PENDING
+    ? v
+    : el._statusFlags & STATUS_UNINITIALIZED
+      ? NOT_PENDING
+      : el._value;
 }
 /** Guesses written since the last seam (`[node, value, question, …]`).
  * Applied at the seam, once the frame's verdict is known — the parent is
@@ -288,9 +308,10 @@ const pendingGuesses = [];
  * lane's value or the committed one — what an optimistic updater composes
  * on (a store setter's draft too, store/optimistic.ts). */
 function guessedValueOf(n) {
-  const g = pendingGuessOf(n);
-  if (g !== NOT_PENDING) return g;
-  return n._config & CONFIG_OVERRIDE ? laneValueOf(n) : n._value;
+  let g = pendingGuessOf(n);
+  return g !== NOT_PENDING || (n._config & CONFIG_OVERRIDE && (g = laneValueOf(n)) !== NOT_PENDING)
+    ? g
+    : n._value;
 }
 /** The unflushed guess to `n`, else NOT_PENDING. */
 function pendingGuessOf(n) {
@@ -298,6 +319,33 @@ function pendingGuessOf(n) {
     if (pendingGuesses[i] === n) return pendingGuesses[i + 1];
   return NOT_PENDING;
 }
+/** This module's copy of scheduler.ts `guessing`: its readers here stay
+ * foldable when a bundler splits lanes.ts from scheduler.ts into separate
+ * chunks (a cross-chunk binding is not folded; the compiled live page). */
+let guessed = false;
+/** Guesses another action's lane took over (#4336): the node, its guess,
+ * the guess's lane, its question, the lane that took it. */
+const kept = [];
+/** Lanes a revert dissolved: the guesses they took come back at their
+ * parent's landing (`endLanes`). */
+const reverted = /* @__PURE__ */ new WeakSet();
+/** Lane `l` takes `n`'s guess (another action's), kept to come back if `l`
+ * reverts. Its readers saw the guess: they re-derive at the lane's reveal
+ * (and, a flight's, hold the lane while they would show it). `d`: a guess
+ * `l` takes without writing it (a store target's other slots) — the node
+ * shows its truth in `l`'s world until the guess comes back. */
+function take(n, l, d) {
+  const x = n._x;
+  kept.push(n, x._lane, x._transaction, x._q, l);
+  rerun(n, l);
+  n._config &= d ? -10241 : ~CONFIG_GUESS;
+  if (d) ((x._transaction = null), (x._lane = NOT_PENDING));
+  else list(n, l);
+}
+/** `n`'s readers are stale readers of `t` (re-derived at its landing). */
+function rerun(n, t) {
+  for (let s = n._subs; s !== null; s = s._nextSub) staleReader(s._sub, t);
+}
 function optimisticWrite(n, v) {
   // What the user sees: an unflushed guess to the same node, else the lane's
   // value or the committed one. The updater composes on it; guessing it
@@ -308,6 +356,8 @@ function optimisticWrite(n, v) {
   if (typeof v === "function") v = v(prev);
   if (n._equals && n._equals(prev, v) && !(n._config & CONFIG_GUESS)) return v;
   pendingGuesses.push(n, v, question || nextQuestion());
+  armGuessing();
+  guessed = true;
   schedule();
   return v;
 }
@@ -325,8 +375,8 @@ function optimisticWrite(n, v) {
  * installs the resolver). A17: the guess stands in for the flight. */
 function inFlight$1(n) {
   return (
-    (n._statusFlags & STATUS_PENDING) !== 0 ||
-    ((n._config & CONFIG_SLOT_NODE) !== 0 && GlobalQueue._slotFlight?.(n) === true)
+    n._statusFlags & STATUS_PENDING ||
+    (n._config & CONFIG_SLOT_NODE && GlobalQueue._slotFlight?.(n))
   );
 }
 function applyGuesses(parent) {
@@ -393,24 +443,33 @@ function applyGuesses(parent) {
  * through an ancestor's guess stays its own (the screen plus its own
  * guesses). */
 function enterLane(l, c) {
-  c._flags |= REACTIVE_LANE_READ;
-  const p = passLane;
+  const f = (c._flags |= REACTIVE_LANE_READ),
+    p = passLane;
   if (p === null) {
+    const verdict = l._parent._verdict === l;
+    // A verdict lane's value (a memo of `latest` / `isPending`, F-6) read by
+    // a derivation that already read the frame's staging or joined its
+    // hold, or by any pass a pass that did is creating: the verdict read
+    // does not break it out — it stays the frame's, as the same read inline
+    // does (verdict.ts `markVerdictReader`, `route`; D-25, D-26). An
+    // effect's own reads do not count (its `_type`, 1–3, carries neither bit).
+    if (!(verdict && creatorReads(c, c._type || f))) {
+      setPassLane(l);
+      // The pass read a held write before its first lane read (it joined the
+      // frame's future as mainline would): lane work sees the screen — the
+      // seam re-derives it on the committed world next round (`stagedReaders`,
+      // the park's repair), as it does a lane pass that read a staging. Not a
+      // pass whose held reads were all of nodes born held (no staged read,
+      // `stagedRead`): it has no committed world to re-derive on (#3969).
+      // (A pass not joined: a held write beside a guess, #4336; a leaf of a
+      // verdict lane — its plain reads are the screen's, D-26 `[s(), L()]`.)
+      if (f & REACTIVE_STAGED_READ && (guessed || verdict || f & REACTIVE_JOINED)) stagedRead(c);
+    }
+  } else if (sameLane(p, l)) setPassLane(l);
+  else if (!under(p, l)) {
+    if (!under(l, p)) linkLanes(p, l);
     setPassLane(l);
-    // The pass read a held write before its first lane read (it joined the
-    // frame's future as mainline would): lane work sees the screen — the
-    // seam re-derives it on the committed world next round (`stagedReaders`,
-    // the park's repair), as it does a lane pass that read a staging. Not a
-    // pass whose held reads were all of nodes born held (no staged read,
-    // `stagedRead`): it has no committed world to re-derive on (#3969).
-    if (c._flags & REACTIVE_JOINED && c._flags & REACTIVE_STAGED_READ) stagedRead(c);
-    return;
   }
-  if (sameLane(p, l)) return setPassLane(l);
-  if (under(p, l)) return;
-  if (under(l, p)) return setPassLane(l);
-  linkLanes(p, l);
-  setPassLane(l);
 }
 /** Is `l` nested under `a` (an ancestor lane)? */
 function under(l, a) {
@@ -481,10 +540,21 @@ function laneStage(el, l, create, errored) {
     const x = el._x;
     if (x !== null) {
       const tx = x._transaction;
-      // Cleared before equality, so a return to the committed value notifies
-      // nobody. The seam wakes it unless the frame is still held (#3892).
-      if (tx?._shown && !blocked(resolveTx(tx._parent))) el._flags |= LEFT_SHOWN;
-      if (tx?._lane) x._transaction = null;
+      if (tx?._lane) {
+        // Cleared before equality, so a return to the committed value
+        // notifies nobody. The seam wakes it (#3892) — always for a pass
+        // outside any transaction's flush: its value is the screen's now
+        // (#4367). While a transaction's flush runs the pass and the lane's
+        // frame is still held, what the screen shows stays the screen until
+        // the landing, and `_value` takes it (as `dissolveLane` keeps a shown
+        // lane's), so this pass's answer — the frame's — is a change against
+        // what is seen and reaches the screen with the frame's commit. (Only
+        // a lane is ever `_shown`.)
+        if (tx._shown)
+          if (!flushTransaction || !blocked(resolveTx(tx._parent))) el._flags |= LEFT_SHOWN;
+          else el._value = display(el);
+        x._transaction = null;
+      }
       x._lane = NOT_PENDING;
     }
     el._config &= -1050881;
@@ -502,7 +572,19 @@ function laneStage(el, l, create, errored) {
     // of the lane from here (its value the lane's, its fate the lane's), no
     // longer a written guess. A pass with no answer (pending, errored)
     // leaves the guess.
-    if (!errored) el._config &= ~CONFIG_GUESS;
+    // Nor a pass of another action's guess: the re-ask is this lane's new
+    // question, which the guess (over the old one) does not answer — the
+    // lane waits for its own answer (F-1, F-6, #4336). (A guess of the
+    // lane's own action, D-33's entangled slot, still stands in.)
+    // (Read behind `guessed`: a bundle without optimism drops the reads.)
+    if (
+      guessed &&
+      el._config & CONFIG_GUESS &&
+      el._x._transaction?._lane &&
+      resolveTx(el._x._transaction._parent) !== resolveTx(l._parent)
+    )
+      take(el, l);
+    else if (!errored) el._config &= ~CONFIG_GUESS;
   }
   // A leaf has no lane value to seat it (`recompute`): one left waiting on
   // the lane's flight runs its next pass as the lane's — the landing that
@@ -535,9 +617,14 @@ function laneStage(el, l, create, errored) {
  * at the parent's landing — while the display keeps what it shows until
  * then. A confirmation is silent (A17): the truth stays staged beneath the
  * guess for the parent's commit, the guess stays the value; only a reader
- * of the truth (CONFIG_AUTHORITATIVE) is told its view changed. */
-/** Observe: the correction round is replacing a guess with the value it
- * covered (no landing beneath it) — `optimisticReverted`'s "reverted". */
+ * of the truth (CONFIG_AUTHORITATIVE) is told its view changed. Either way
+ * the parent takes this node, not the tick that carried the truth (D-33):
+ * one landing answering two actions' guesses (a store re-ask over two
+ * rows) must not tie them together; a pass that derives from the held
+ * truth joins the parent on its own (`joinPass`). */
+/** The correction round is replacing a guess with the value it covered (no
+ * landing beneath it): observe's "reverted"; the lane gives back the
+ * guesses it took (#4336, `endLanes`). */
 let reverting = false;
 function supersede(n, value, changed) {
   const l = txOf(n);
@@ -557,6 +644,7 @@ function supersede(n, value, changed) {
     if (l._shown && attrHooks !== null)
       attrHooks.optimisticReverted(n, n._x._lane, value, reverting ? "reverted" : "superseded");
     dissolveLane(l, parent, n);
+    if (guessed && reverting) reverted.add(l);
     // What the screen showed stays the screen until the parent lands (A18
     // (c): display and untracked reads keep the override until the commit).
     if (l._shown) n._value = n._x._lane;
@@ -570,7 +658,6 @@ function supersede(n, value, changed) {
     GlobalQueue._confirmed?.(l);
   }
   n._pendingValue = value;
-  joinFuture(parent);
 }
 /** A lane's end, two ways. `into === null`: the parent landed — the lane's
  * values are the truth now: a guess lands the truth staged beneath it or
@@ -593,6 +680,8 @@ function dissolveLane(l, into, except) {
     l._verdict = null;
     if (lanes.indexOf(v) !== -1) dissolveLane(v, null);
   }
+  // First loads this dissolution leaves loading (below).
+  const loading = [];
   for (let i = 0; i < l._nodes.length; i++) {
     const n = l._nodes[i];
     const x = n._x;
@@ -628,8 +717,20 @@ function dissolveLane(l, into, except) {
       // lane's answer beside inputs that are the truth now: a fresh reader
       // of its flight observes it (#3648, #3651; #3305's commit beneath a
       // flight).
+      // Not a first load the lane produced nothing for whose own flight is
+      // up, nor one pending on such a load kept here (an identity memo of
+      // it, a derived store's derive): committing its empty `_value` would
+      // initialize it as `undefined`, which `latest()` would serve and
+      // `isPending()` call pending. It stays loading until its flight
+      // answers (D-22, A19 exc. 1; async-gen 3289 #929, 91501 #504, #156).
       x._transaction = null;
-      if (!effect && !guess) n._pendingValue = latest;
+      if (!effect && !guess)
+        slot === NOT_PENDING &&
+        (n._statusFlags & (STATUS_UNINITIALIZED | STATUS_PENDING)) ===
+          (STATUS_UNINITIALIZED | STATUS_PENDING) &&
+        (x._inFlight || loading.some(q => x._pendingSources?.has(q)))
+          ? loading.push(n)
+          : (n._pendingValue = latest);
       commitPendingNode(n);
       if (!effect) {
         if (
@@ -639,6 +740,14 @@ function dissolveLane(l, into, except) {
           n._config |= CONFIG_INPUTS_PUBLISHED;
         if (shown !== NOT_PENDING && (!n._equals || !n._equals(shown, n._value))) insertSubs(n);
       }
+      // A stale reader's own error — its pass (a memo's or a render
+      // effect's) threw over the committed value of what the parent held
+      // (A10), served as the screen — is no answer of the world landing now:
+      // it re-derives on it (A15; D-39, the landing is the new answer). The
+      // landing's `reruns` skips an errored reader: its error is an errored
+      // source's (#3945).
+      if (n._flags & REACTIVE_FRAME_READ && n._statusFlags & STATUS_ERROR && x._error.source === n)
+        enqueueSub(n);
     } else if (guess) {
       // A guess of a dissolving lane: its truth — a landing held beneath it,
       // else the value it covered — is the parent's to land, and its readers
@@ -758,14 +867,19 @@ function laneRead(c, el) {
       )
         return el._pendingValue;
       if (l._held || pending) {
-        if (!guess && !l._shown && status & STATUS_UNINITIALIZED) throw new NotReadyError(null);
         // Re-derived at the reveal; once per pass (the pass may also be a stale
         // reader of a transaction, REACTIVE_FRAME_READ — both reruns apply).
+        // Before the throw below: a leaf that waits on a lane that has never
+        // shown has no flight to settle it — only the reveal re-derives it,
+        // and its pending holds its frame until then (#4338).
         if (!(c._flags & REACTIVE_SCREEN_READ)) {
           c._flags |= REACTIVE_FRAME_READ | REACTIVE_SCREEN_READ;
           l._reruns.push(c);
         }
-        return display(el);
+        // Nothing on screen yet (uninitialized: `display` is NOT_PENDING).
+        const v = display(el);
+        if (v === NOT_PENDING) throw new NotReadyError(null);
+        return v;
       }
       // A verdict reader reads ahead of the seam's verdict: re-derived on the
       // screen if the lane holds (#4284).
@@ -837,7 +951,7 @@ function laneSeam(l, leaked) {
   }
   l._held = false;
   l._shown = true;
-  reruns(l);
+  if (reruns(l)) revealing.push(resolveTx(l._parent));
   for (let i = 0; i < l._nodes.length; i++) {
     const n = l._nodes[i];
     if (n._flags & LEFT_SHOWN) {
@@ -861,6 +975,31 @@ function laneSeam(l, leaked) {
 /** The parent landed: its lanes end, nested first. (None is blocked: a
  * blocked lane blocks its parent.) */
 function endLanes(u) {
+  // A revert landing (#4336): the guesses its lane took from another action
+  // that is still out come back in this frame, over the truth it lands —
+  // its readers re-derive with the landing (one frame, no bare truth
+  // between). Taken by a later lane since, a node stays that lane's.
+  if (guessed)
+    for (let i = kept.length - 5; i >= 0; i -= 5)
+      if (resolveTx(kept[i + 4]._parent) === u) {
+        let [n, v, g, q, t] = kept.splice(i, 5);
+        // (A store slot's node now: the one taken, or a read's since.)
+        if (
+          reverted.has(t) &&
+          lanes.includes(g) &&
+          (!(n._config & CONFIG_SLOT_NODE) || (n = GlobalQueue._slotTake(n, true)))
+        ) {
+          const x = ext(n);
+          if (x._transaction === null || txOf(n) === u) {
+            commitPendingNode(n);
+            x._lane = v;
+            x._q = q;
+            n._config |= CONFIG_OVERRIDE | CONFIG_GUESS;
+            list(n, g);
+            rerun(n, u);
+          }
+        }
+      }
   for (let k = lanes.length - 1; k >= 0; k--) {
     const l = lanes[k];
     if (resolveTx(l._parent) !== u) continue;
@@ -876,8 +1015,14 @@ function endLanes(u) {
 function lanesBlocked(t) {
   return (t._lane && linkBlocked(t)) || nestedBlocked(t);
 }
+/** Parents whose lane revealed this seam with readers to re-derive there
+ * (`laneSeam`): the lane shows ahead of its parent (F-6), so the parent lands
+ * a round later — after those readers have shown the lane's answer — even
+ * when nothing else holds it (#4393). */
+const revealing = [];
 /** The lanes under `t` (its own; a link group's are each other's). */
 function nestedBlocked(t) {
+  if (revealing.indexOf(t) !== -1) return true;
   for (let i = 0; i < lanes.length; i++) {
     const l = lanes[i];
     if (resolveTx(l._parent) !== t) continue;
@@ -891,7 +1036,9 @@ function nestedBlocked(t) {
  * latest: its staging once the lane has shown (promoted at the next
  * reveal), its slot before; the lane's members re-derive as its work. */
 function laneWrite(el, v) {
-  if (el._config & CONFIG_GUESS) {
+  // (A store slot's guess its derive's re-ask in another action's lane
+  // writes is that lane's derivation from here — store `_slotTake`, #4336.)
+  if (el._config & CONFIG_GUESS && !(guessed && GlobalQueue._slotTake?.(el))) {
     // Provenance (A18, #3331; Q-D, plan sec. 39): a write asking an OLDER
     // question than the guess's — another action's landing beneath it —
     // is not its answer: held beneath (the truth for the commit; the
@@ -969,29 +1116,79 @@ const applyGuessesAt = parent => {
   judged = lanes.length;
   if (pendingGuesses.length !== 0) applyGuesses(parent);
 };
-const laneSeams = leaks => {
+/** `t` is parked by `r`'s pass alone: each node keeping it — `t`'s own, or
+ * a lane's under it — is `r` itself (its flight, in the verdict lane) or a
+ * render effect pending on `r` only: the frame observing the lane work that
+ * read its staging. Anything else (an open action, a guess's flight,
+ * another flight) holds it on its own. */
+function heldBy(t, r) {
+  if (t._open !== 0 || (t._lane && linkBlocked(t))) return false;
+  for (let k = -1, u = t; u; u = lanes[++k])
+    if (u === t || resolveTx(u._parent) === t) {
+      if (u !== t && guessFlights(u)) return false;
+      for (let i = 0; i < u._nodes.length; i++) {
+        const n = u._nodes[i];
+        if (
+          n === r ||
+          !(n._statusFlags & STATUS_PENDING) ||
+          (n._x._transaction !== null && txOf(n) !== u)
+        )
+          continue;
+        const s = n._x._pendingSources;
+        if (n._type !== EFFECT_RENDER || s?.size !== 1 || !s.has(r)) return false;
+      }
+    }
+  return true;
+}
+const laneSeams = t => {
   // Passes that read a write the parked frame holds as the screen
   // (`stagedReaders`: lane work, a verdict reader before the verdict): they
   // re-derive on the committed world next round (and register as stale
   // readers of the transaction there); a lane's runs wait that round — a
   // lane sees the screen plus its own guesses.
+  if (revealing.length) revealing.length = 0;
   const leaked = [];
-  if (leaks !== null)
-    for (let i = 0; i < leaks.length; i++) {
-      const r = leaks[i];
-      const l = r._x?._transaction;
+  if (t !== null)
+    for (let i = 0; i < stagedReaders.length; i++) {
+      const r = stagedReaders[i],
+        // A pass no transaction holds that read the frame's staging (an
+        // effect, a `[s(), latest(s)]` reader watched before the frame had
+        // a transaction): judged by the frame's — it re-derives only if the
+        // frame stays parked; landing here, what it read is the screen (one
+        // run, D-22).
+        l = r._x?._transaction || (r._flags & REACTIVE_STAGED_READ ? t : null);
       // A verdict reader a later read of the same pass routed into a verdict
       // lane answered for itself: it re-derives at the holder's landing, not
       // now (one run — #3322, #3540). Other verdict-lane work re-derives only
       // if the frame stays parked: a transaction landing at this seam makes
-      // what it read the screen (one run).
+      // what it read the screen (one run). The frame is the transaction that
+      // holds what it read (`t`, this flush's — not always the lane's parent:
+      // a landing that reached a frame held elsewhere joined that one). Nor
+      // when only this pass keeps it parked (`heldBy`): the frame lands with
+      // the pass's answer, so what the pass read is the screen when anything
+      // shows it — re-derived on the committed world, it would ask a question
+      // already asked, over inputs the landing replaces. A reader a
+      // transaction holds that read none of its stagings (a verdict reader
+      // that probed only a flight, held as the frame's pending observer or
+      // its staged derivation) has nothing to re-derive: its re-run
+      // re-enters that transaction and parks it again, every round — it
+      // runs at the landing (#4349). One that read a staging re-derives only
+      // if its frame stays parked: landing at this seam, what it read is the
+      // screen (one run, D-22). Not one born into that frame (a held pass's
+      // child, ruling A): it has no screen, its reads are the transaction's
+      // either way — it runs again at the landing, not now.
       if (
         r._flags & REACTIVE_DISPOSED ||
-        (l != null &&
-          l._parent?._verdict === l &&
-          (r._config & CONFIG_VERDICT
-            ? !(r._flags & REACTIVE_PROBE_UNANSWERED)
-            : !blocked(l._parent)))
+        (l?._lane
+          ? l._parent?._verdict === l &&
+            (r._config & CONFIG_VERDICT
+              ? !(r._flags & REACTIVE_PROBE_UNANSWERED)
+              : !blocked(t) || heldBy(t, r))
+          : l &&
+            !(
+              r._flags & REACTIVE_PROBE_UNANSWERED ||
+              (r._flags & REACTIVE_STAGED_READ && blocked(l) && !bornInto(r, l))
+            ))
       )
         continue;
       // A leaked effect re-derives seated in its lane from its first read: it
@@ -1000,12 +1197,48 @@ const laneSeams = leaks => {
       // the staging, then re-enters the lane at its guess read and leaks
       // again — every round (#4014). A computed is already seated by its
       // override, and a written guess's own pass stays the frame's.
-      if (l != null && l._lane && r._type) r._flags |= REACTIVE_LANE_DIRTY;
+      if (l?._lane && r._type) r._flags |= REACTIVE_LANE_DIRTY;
+      // R5 for an async reader: its frame pass asked the frame's question
+      // (F-6's lane gets its own pass now). That flight is the frame's
+      // answer: the landing adopts it rather than asking it again (F-9: a
+      // re-ask of the same question is no new question; `reruns`). A frame
+      // landing at this seam has nothing to re-derive: the pass was the
+      // landing's, its flight the screen's answer. Sync or async, the
+      // reader's lane pass is still to come: the verdict lane it joins does
+      // not reveal this seam (F-6: the lane's readers show its answer
+      // together, D-23: atomic with the value) — revealed now, it showed a
+      // verdict beside the frame pass's value, before the pass that answers
+      // for the lane, and a reader of the re-derived memo read it outside
+      // the shown lane and waited for the frame (#4393).
+      else if (!l?._lane && r._flags & REACTIVE_PROBE_UNANSWERED) {
+        if (isThenable(r._x?._inFlight)) {
+          if (!blocked(t)) continue;
+          r._x._parked = r._x._inFlight;
+        } else if (blocked(t))
+          // A sync reader's lane pass re-derives the async memos over it (a
+          // memo over a verdict memo is a verdict reader, D-25 #4050; D-22:
+          // `latest()` extracted into a memo reads as inline). The flight
+          // each asked over its frame staging, up and held by `t`, is the
+          // frame's answer too: the landing adopts it (F-9).
+          for (let s = r._subs, n; s; s = s._nextSub)
+            if (
+              isThenable((n = s._sub)._x?._inFlight) &&
+              n._x._pendingSources?.has(n) &&
+              n._config & CONFIG_HELD &&
+              txOf(n) === t
+            )
+              n._x._parked = n._x._inFlight;
+        if (t?._verdict && leaked.indexOf(t._verdict) === -1) leaked.push(t._verdict);
+      }
       enqueueSub(r);
-      if (l != null && l._lane && leaked.indexOf(l) === -1) leaked.push(l);
-    }
-  for (let k = Math.min(judged, lanes.length) - 1; k >= 0; k--)
-    laneSeam(lanes[k], leaked.indexOf(lanes[k]) !== -1);
+      if (l?._lane && leaked.indexOf(l) === -1) leaked.push(l);
+    }
+  // A verdict lane born at this seam is judged with it: it exists only once
+  // a pass routed into it — the park seam's zombie verdict readers re-run
+  // as its work so that this seam reveals them (#3444).
+  for (let k = lanes.length - 1; k >= 0; k--)
+    if (k < judged || lanes[k]._parent?._verdict === lanes[k])
+      laneSeam(lanes[k], leaked.indexOf(lanes[k]) !== -1);
   // A verdict reader that entered a lane this seam held: its run waits with
   // the lane, and the verdict beside it would freeze — it re-derives next
   // round from the frame's seat, a stale reader of the lane (#4284).
@@ -1015,6 +1248,36 @@ const laneSeams = leaks => {
       enqueueSub(r);
     }
 };
+/** The landing's re-derive of a reader whose frame flight the seam parked
+ * (R5): the flight asked the question the landing would — adopted, it is
+ * asked once (F-9). Not over a pass already queued: that one asks anew.
+ * Registered as if this pass had returned it — the node pending on it, its
+ * landing the answer — through a promise of its own: the frame pass's
+ * registration still listens to the flight, and must not land it a second
+ * time. */
+const adoptParked = r => {
+  const parked = r._x?._parked;
+  if (!parked || r._flags & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP)) return false;
+  r._x._parked = undefined;
+  releaseFlightTeardown(r);
+  try {
+    handleAsync(r, parked.then());
+  } catch {}
+  r._x._blocked = true;
+  notifyStatus(r, STATUS_PENDING, new NotReadyError(r));
+  return true;
+};
+/** A15: lane work or a verdict reader was served `el`'s committed value
+ * (core.ts `frameRead`), so its pass does not wait on `el`'s flight: what
+ * `el`'s pending propagated onto it before the pass (its origins, `el`
+ * included) is not this pass's — the landing re-derives it (`reruns`).
+ * Kept, a pass that went pending on another source never woke when that
+ * source settled (#4397). Only a reader something made pending has anything
+ * to drop. */
+const laneServed = (c, el) => {
+  const from = el._x?._pendingSources;
+  if (from && c._x?._pendingSources) for (const s of from) removePendingSource(c, s);
+};
 /** Render effects that read a verdict and entered a lane before its seam (#4284). */
 const entered = [];
 installLaneHooks(
@@ -1026,7 +1289,9 @@ installLaneHooks(
   laneSeams,
   () => lanes.length !== 0 && laneCorrections(),
   endLanes,
-  lanesBlocked
+  lanesBlocked,
+  adoptParked,
+  laneServed
 );
 GlobalQueue._laneGuesses = t => {
   const out = [];
@@ -1067,7 +1332,7 @@ function watchVerdict(c, unanswered = false) {
  * does not rescue it: its result shows at the landing, re-derived). A lane
  * read, for `recompute`'s tail (REACTIVE_LANE_READ). */
 function route(c, t) {
-  if (passLane === null && !(c._flags & (REACTIVE_JOINED | REACTIVE_STAGED_READ)))
+  if (!passLane && !(c._flags & (REACTIVE_JOINED | REACTIVE_STAGED_READ)))
     setPassLane(verdictLane(t));
   c._flags |= REACTIVE_LANE_READ;
 }
@@ -1134,40 +1399,41 @@ function verdictRead(c, t, plain) {
  * watches the seam and runs again if the flush parks (a plain sync write
  * never glitches it true).
  *
- * `latest` has its answer either way — the proposal — and only the reader's
- * membership was open, so it is settled now: the frame gets its transaction
- * (`joinFuture(null)`; nothing holds it at the seam and it lands there, the
- * lane dissolving into it — a plain commit) and the reader is its verdict
- * lane's. One pass: a provisional pass re-derived at the seam ran everything
- * downstream of it twice (#3540 web). A pass that also read the frame's own
- * stagings plainly (REACTIVE_STAGED_READ) stays the frame's (`route` does
- * not move it); a verdict reader's plain read AFTER the window sees the
- * screen (`read`: `stagedScreen`). */
+ * `latest` has its answer either way — the proposal — but its reader's
+ * membership is the seam's too: the frame opens no transaction for it
+ * (#4365 — one opened for the read alone made a plain read after the window
+ * take it for a hold, `stagedScreen`, and serve the screen beside the
+ * staging in a frame nothing held). The reader watches the seam like a
+ * probe before anything joined: its pass is the frame's, and runs again in
+ * the verdict lane if the flush parks. Once the flush has joined a
+ * transaction, the reader is its verdict lane's at once; a pass that also
+ * read the frame's own stagings plainly (REACTIVE_STAGED_READ) stays the
+ * frame's (`route` does not move it). */
 function provisionalVerdict(c, notFinal) {
-  if (!probing) {
-    joinFuture(null);
+  if (flushTransaction) {
+    if (probing && notFinal) probeFound = true;
     verdictRead(c, flushTransaction);
-    return;
-  }
-  if (flushTransaction !== null) {
-    if (notFinal) probeFound = true;
-    verdictRead(c, flushTransaction);
-    if (c._flags & REACTIVE_STAGED_READ) watchVerdict(c);
+    if (probing && c._flags & REACTIVE_STAGED_READ) watchVerdict(c);
     return;
   }
   // Before anything joined, a staging that would not be final held has no
   // answer yet: whatever the seam decides, the pass runs again — a later
   // plain read of the same pass may route it into the verdict lane
   // (`observeFlight`), which the seam must not take as this probe's answer.
-  watchVerdict(c, notFinal);
+  // `latest` opens no transaction for its answer either (#4365): the plain
+  // read of a staging after it took one opened for it for a hold and paired
+  // the staging with the screen, in a frame nothing held. Its pass is the
+  // frame's — whole — and re-derives once if the flush parks (unanswered:
+  // its membership is the seam's, not the transaction it joins).
+  watchVerdict(c, !probing || notFinal);
 }
 /** A19 exc. 2 / A24: a flight that re-asks the question already answered
  * (a `refresh()`, a poll) is quiet; a node pending through others is quiet
  * when every flight it waits on is. */
 function quietPending(el) {
   const x = el._x;
-  if (x === null) return false;
-  if (x._pendingSources !== undefined) {
+  if (!x) return false;
+  if (x._pendingSources) {
     for (const source of x._pendingSources) if (!source._x?._reask) return false;
     return true;
   }
@@ -1199,9 +1465,17 @@ function heldNotFinal(owner) {
 function pendingVerdict(c, el) {
   if (el._statusFlags & STATUS_UNINITIALIZED) return;
   if (probing && !quietPending(el)) probeFound = true;
-  if (c !== null && tracking) {
+  if (c && tracking) {
     if (el._config & CONFIG_HELD) verdictRead(c, txOf(el));
-    else if (globalQueue._running) provisionalVerdict(c, false); // decided above
+    else if (globalQueue._running) {
+      // `latest` of a flight serves the committed value, the frame's and the
+      // lane's alike (D-22): nothing is the seam's, so the reader is the
+      // verdict lane's now, as a plain read of a flight makes it
+      // (`observeFlight`). Its frame pass re-derived in the lane (R5) asked
+      // its question again (F-9, #4397). A staging's is the seam's (#4365).
+      if (!probing) joinFuture(null);
+      provisionalVerdict(c, false); // decided above
+    }
   }
 }
 /** The pass entering a verdict window is a verdict reader (CONFIG_VERDICT):
@@ -1210,11 +1484,21 @@ function pendingVerdict(c, el) {
  * a router's link claim probing inside the computation that creates the
  * anchor). A throw still reaches the pass through `untrack`. */
 function markVerdictReader(window) {
-  let c = context;
-  if (c?._root) c = c._parentComputed;
-  if (c !== null && tracking) {
-    c._config |= CONFIG_VERDICT;
-    c._flags |= REACTIVE_PROBED;
+  const c = creatorPass(context);
+  if (c && tracking) {
+    // A pass run inside passes still running — its creator's, theirs — one
+    // of which read the future or a staging (a branch a held or staged
+    // condition opened, and whatever that branch creates) has no screen: the
+    // branch exists only in that world. It reads that world as any
+    // derivation of it does (`bornInto` once held) and stays its pass
+    // (`route`); a verdict reader from its next pass. #4341: a memo born in
+    // a newly opened <Match> read the screen, where its branch was closed.
+    // Not such a pass: a verdict reader now.
+    c._config &= ~CONFIG_ASYNC;
+    c._flags |=
+      REACTIVE_PROBED |
+      REACTIVE_WINDOW |
+      (creatorReads(c, 0) || ((c._config |= CONFIG_VERDICT), 0));
     // Observe tier: which windows this pass entered (1 `isPending`, 2
     // `latest`) — the hold census names the affordance (attribution.ts).
     c._devWindows = (c._devWindows ?? 0) | window;
@@ -1305,7 +1589,7 @@ function staged(el) {
 function heldLatest(el, c) {
   const u = unflushedValue(el);
   if (u === NOT_PENDING) return staged(el);
-  if (c !== null) markLateLinker(c);
+  if (c) markLateLinker(c);
   return u;
 }
 /** The verdict windows' read — `latest(fn)` and `isPending(fn)` — in one
@@ -1318,7 +1602,9 @@ function heldLatest(el, c) {
  *   differs (A24, A18 provenance). A derivation: `latest` sees the lane's
  *   latest (a landing a blocked lane holds has answered its question — the
  *   checkout's shipping text updates independently of the tax in flight),
- *   `isPending` the screen; not final while its own flight is up;
+ *   `isPending` the screen; not final while its own flight is up. A
+ *   derivation's first load in flight (nothing produced yet — an async memo
+ *   over a verdict memo, F-6) reads as the flight below: loading (D-22);
  * - a held node: the reader breaks out as the holder's verdict lane's and
  *   re-derives at the landing; `latest` serves the proposal (`heldLatest`),
  *   `isPending` answers `heldNotFinal`;
@@ -1331,49 +1617,70 @@ function heldLatest(el, c) {
  * - an errored derivation throws for every reader (#2897). */
 function verdictValue(el, c) {
   const owner = el;
-  const owned = c !== null && !(c._config & CONFIG_CHILDREN_FORBIDDEN);
+  const owned = !!c && !(c._config & CONFIG_CHILDREN_FORBIDDEN);
   const tracked = owned && tracking;
-  if (c !== null && tracking) {
+  // A31: the pulled memo's pass is its own, not the probe's — it reads
+  // outside the window, and the probe's read below answers for what the pass
+  // produced. So is a lazy or dormant memo's wake (an unowned memo with no
+  // reader left, #4366): woken inside the window, it read its sources as the
+  // probe does, the committed value under a landing. (A signal has no
+  // `_flags`: the wake is a no-op for it.)
+  setVerdict(null);
+  prepareComputed(owner);
+  if (c && tracking) {
     link(el, c);
-    if (owner._fn !== undefined) {
-      // A31: the pulled memo's pass is its own, not the probe's — it reads
-      // outside the window, and the probe's read below answers for what
-      // the pass produced.
-      setVerdict(null);
-      pullComputed(owner, c);
-      setVerdict(verdictValue);
-    }
+    if (el._fn) pullComputed(owner, c);
   }
+  setVerdict(verdictValue);
   // A live `affects()` mark on the node or a dependency (affects.ts): not
   // final by declaration — the value itself is read as below. The verdict is
   // display-ahead like any: in a transaction's flush (the declaring action's
   // body) the reader is its verdict lane's, not a staging the frame parks.
-  if (probing && GlobalQueue._marked !== undefined && GlobalQueue._marked(owner)) {
+  if (probing && GlobalQueue._marked?.(owner)) {
     probeFound = true;
-    if (tracked && flushTransaction !== null) verdictRead(c, flushTransaction);
+    if (tracked && flushTransaction) verdictRead(c, flushTransaction);
   }
   if (
     el._config & CONFIG_OVERRIDE &&
     !(owner._statusFlags & STATUS_ERROR && !(el._config & CONFIG_GUESS))
   ) {
-    const l = txOf(el);
-    if (tracked) verdictRead(c, l._parent ?? l);
-    const flying = (owner._statusFlags & STATUS_PENDING) !== 0 && !quietPending(owner);
-    if (el._config & CONFIG_GUESS) {
+    const l = txOf(el),
+      flying = (owner._statusFlags & STATUS_PENDING) !== 0 && !quietPending(owner),
+      guess = el._config & CONFIG_GUESS,
+      // NOT_PENDING: a node born in the lane with nothing in it yet has no
+      // value in either view — loading, not pending, and no verdict to read
+      // ahead: it is read as any uninitialized node, NotReady below (A7, A19
+      // exc. 1; #4363), its reader not moved into the verdict lane.
+      v = guess ? 0 : latestActive && !flying ? laneValueOf(el) : display(el);
+    if (v !== NOT_PENDING) {
+      if (tracked) verdictRead(c, l._parent ?? l);
+      if (guess) {
+        if (
+          probing &&
+          (flying ||
+            (el._pendingValue !== NOT_PENDING &&
+              (!el._equals || !el._equals(el._x._lane, el._pendingValue))))
+        )
+          probeFound = true;
+        // A lane a correction folded under (D-34): `latest()` shows the hold's
+        // world whole — the truth beneath each guess, else what it covered.
+        if (latestActive && l.folded) return l.folded(null, el);
+        return el._x._lane;
+      }
+      // A first load in flight with nothing produced yet: loading, for
+      // `latest` (D-22) as for `isPending` (A19 exc. 1) — unless an error
+      // answered it first: its re-ask is pending, the error its display
+      // (D-41, #4375).
       if (
-        probing &&
-        (flying ||
-          (el._pendingValue !== NOT_PENDING &&
-            (!el._equals || !el._equals(el._x._lane, el._pendingValue))))
+        flying &&
+        v === el._value &&
+        owner._statusFlags & STATUS_UNINITIALIZED &&
+        (latestActive || !owner._x._shownError)
       )
-        probeFound = true;
-      // A lane a correction folded under (D-34): `latest()` shows the hold's
-      // world whole — the truth beneath each guess, else what it covered.
-      if (latestActive && l.folded) return l.folded(null, el);
-      return el._x._lane;
+        throw owner._x._error;
+      if (probing && flying) probeFound = true;
+      return v;
     }
-    if (probing && flying) probeFound = true;
-    return latestActive && !flying ? laneValueOf(el) : display(el);
   }
   // Dev strict-read scopes (a component body, an effect callback) warn on a
   // verdict read as on any untracked read; the pending throw they add for a
@@ -1398,9 +1705,8 @@ function verdictValue(el, c) {
         tracked &&
         !probing &&
         c._type === EFFECT_RENDER &&
-        passLane === null &&
-        t._verdict !== null &&
-        t._verdict._held &&
+        !passLane &&
+        t._verdict?._held &&
         flushTransaction !== t
       ) {
         staleReader(c, t._verdict);
@@ -1412,7 +1718,7 @@ function verdictValue(el, c) {
         // An action body reading another transaction's proposal derives
         // from it: the two settle as one (A15; posture C, 2026-09-15). An
         // untracked read elsewhere has no transaction to entangle.
-        if (!tracked && flushTransaction !== null && !globalQueue._running) joinFuture(txOf(el));
+        if (!tracked && flushTransaction && !globalQueue._running) joinFuture(txOf(el));
         return heldLatest(el, tracked ? c : null);
       }
       return el._value;
@@ -1441,7 +1747,7 @@ function verdictValue(el, c) {
       // reader derived from the flushed world runs again in the carrying
       // flush.
       if (globalQueue._running) return staged(el);
-      if (c !== null) markLateLinker(c);
+      if (c) markLateLinker(c);
     }
     return el._value;
   }
@@ -1453,16 +1759,51 @@ function verdictValue(el, c) {
     // As `read()`: an untracked read of a pending node still re-runs its
     // reader when the node settles (a projection's pull reads its firewall
     // untracked, store/store.ts).
-    if (c !== null && !tracking && !spectating && el !== c) link(el, c);
+    if (c && !tracking && !spectating && el !== c) link(el, c);
     throw owner._x?._error;
   }
-  if (owner._fn !== undefined && owner._statusFlags & STATUS_ERROR) throw owner._x._error;
+  if (el._fn && owner._statusFlags & STATUS_ERROR) throw owner._x._error;
   return el._value;
 }
+/** D-25: a node whose fetch a hold is waiting on is that hold's work, not a
+ * verdict reader — a pass that re-runs it reads plainly — and a memo's
+ * posture is what it reads: one that reads a verdict reader's value is a
+ * verdict reader itself (#4050). An async memo with no verdict window of its
+ * own (REACTIVE_WINDOW: it read a verdict memo, it called neither `latest`
+ * nor `isPending`) is a verdict reader between its flights, and the hold's
+ * work while one is up or its hold re-runs it.
+ *
+ * At a pass's head (core.ts `recompute`): a pending node's pass — its
+ * flight is the transition's own work (#3884) — and a held one's re-run of
+ * such a memo read plainly: the write that re-ran it is its hold's, and
+ * served the screen it re-asked a question it had answered (A10, #4397).
+ * Only a memo that never asked: D-25's "a verdict posture outlives the pass
+ * that asked" is a pass that called `latest`/`isPending`, which clears
+ * CONFIG_ASYNC and stays a verdict reader whoever dirties it.
+ *
+ * On `source` going pending (`propagateStatus`): such a memo waits on it
+ * like any derivation (F-9) instead of re-deriving — what it read changed
+ * no value, so its re-run re-asked the question it was answering. Unless
+ * its own flight is up outside a lane on a new question of the source's:
+ * its re-run supersedes a flight asked of a value the source has moved past
+ * (re-asked by a `refresh()`, the source's question is the same one). */
+function holdWork(n, source) {
+  // CONFIG_ASYNC records an async memo with no window of its own: its last
+  // answering pass registered a flight (`handleAsync`) and called neither
+  // `latest` nor `isPending`. A window (`markVerdictReader`), a sync answer or
+  // an error clears it; a pass left pending keeps the last answer's.
+  const own = n._config & CONFIG_ASYNC;
+  return (
+    own &&
+    (!(n._statusFlags & STATUS_PENDING) ||
+      n._x._transaction?._lane ||
+      source._flags & REACTIVE_REASK)
+  );
+}
 // Installed at module evaluation — present exactly when something imports
 // `latest` or `isPending`. (`read` dispatches to `verdictValue` through
 // `verdict`, set while a window is open.)
-installVerdictHooks(observeFlight);
+installVerdictHooks(observeFlight, holdWork);
 /** A store read inside an untracked `isPending` probe found a live mark on
  * a record with no node to carry it (store/affects.ts): not final. */
 GlobalQueue._witnessMark = () => {
@@ -1906,7 +2247,8 @@ function effect(compute, effect, error, options) {
     !node._x?._transaction?._lane &&
     (node._type === EFFECT_USER || options?.schedule
       ? globalQueue.enqueue(node._type, runEffect.bind(null, node))
-      : runEffect(node, node._type));
+      : // Type 0: the synchronous first render, not a queued run (D-19).
+        runEffect(node, 0));
   if (!node._parent) {
     const message =
       "[NO_OWNER_EFFECT] Effects created outside a reactive context will never be disposed";
@@ -1945,11 +2287,12 @@ function notifyEffectStatus() {
       return;
     }
     // Dev locates the halt at the node that threw: the StatusError's
-    // source, upstream of this effect when a computed failed.
+    // source, upstream of this effect when a computed failed. The rethrow is
+    // the user's error, not the wrapper: the wrapper's `source` is a node, and
+    // a reporter that serializes the throw walks the reactive graph.
     escalate(
       this,
       unwrapStatusError(actualError),
-      actualError,
       actualError instanceof StatusError ? actualError.source : this
     );
   } else if (this._type === EFFECT_RENDER) {
@@ -1981,11 +2324,11 @@ function notifyEffectStatus() {
   }
 }
 /** An effect's error no boundary takes halts the system (boundary-or-halt):
- * halted with `cause`, `thrown` rethrown; dev locates it at `subject`. */
-function escalate(node, cause, thrown = cause, subject = node) {
+ * halted with `cause` and rethrown; dev locates it at `subject`. */
+function escalate(node, cause, subject = node) {
   if (!globalQueue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
     haltReactivityAt(cause, subject);
-    throw thrown;
+    throw cause;
   }
 }
 function runEffect(node, type) {
@@ -1995,10 +2338,12 @@ function runEffect(node, type) {
   // effect's update too (maintainer, 2026-10-02: "we held the queue but let
   // the sync renders through… we definitely shouldn't be showing portals
   // early") — a Portal's or head-tag's render effect writes outside the
-  // hidden subtree. The synchronous first render on creation is not a queued
-  // run and goes through. `_modified` stays set; the boundary re-queues the
-  // run (`release`).
-  if (heldRunHook?.(node)) return;
+  // hidden subtree. The synchronous first render on creation (`type` 0) is
+  // not a queued run and goes through, whichever boundary above is on its
+  // fallback then — an outer one about to reveal in this flush included
+  // (#4343). `_modified` stays set; the boundary re-queues the run
+  // (`release`).
+  if (type && heldRunHook?.(node)) return;
   // Error arm (#2840), user effects only: a compute-phase error that is still
   // the node's settled state at effect time runs the bundle's error handler in
   // this same imperative, writable scope. Unwrap the StatusError used for
@@ -2334,6 +2679,15 @@ let writeOverride = false;
 function setWriteOverride(value) {
   writeOverride = value;
 }
+/** The list driver's view of a shallow store (map.ts): the backing a read of
+ * every slot serves this reader, or `undefined` when the list is no shallow
+ * store or a slot read could differ from it. Installed by store.ts's top
+ * level, so a `<For>` in an app without stores carries none of it; it lives
+ * beside `$TRACK` so map.ts reaches no other store module. */
+let shallowView = null;
+function installShallowView(view) {
+  shallowView = view;
+}
 
 /**
  * Deferred hydration, dependency edges for stores. Only the frames client
@@ -3439,9 +3793,12 @@ function updateKeyedMap() {
   // vanishing. Set per pass: the first pass runs inside `computed()`, before
   // the node exists to the caller.
   this._owner._parentComputed = getOwner();
-  const newItems = this._list() || [],
-    newLen = newItems.length;
+  let newItems = this._list() || [];
   newItems[$TRACK]; // top level tracking (a store array's container node)
+  // A shallow store array diffs its backing: its slots are raw records, and
+  // a trap per slot read was most of a one-row write on a 1k-row list.
+  newItems = shallowView?.(newItems[$TARGET]) ?? newItems;
+  const newLen = newItems.length;
   runWithOwner(this._owner, () => {
     let i,
       j,
@@ -4199,6 +4556,7 @@ const storePark = t => {
     const target = foldList[i];
     if (target.k === null && target.pb !== null) holdNode(getContainerNode(target), t);
   }
+  optHooks?.park(t);
 };
 function getDeepNode(target) {
   let dk = target.dk;
@@ -4274,17 +4632,26 @@ function cloneRaw(source, t) {
     clone[$OWNER] = t;
     return clone;
   }
-  const descs = Object.getOwnPropertyDescriptors(source);
-  for (const key of Reflect.ownKeys(descs)) {
-    const d = descs[key];
-    if (key === "length" && Array.isArray(source)) continue;
-    d.configurable = true;
-    if (!d.get && !d.set) d.writable = true;
-    else t.a = true;
-  }
-  const clone = Array.isArray(source)
-    ? Object.defineProperties([], descs)
-    : Object.create(Object.getPrototypeOf(source), descs);
+  // A plain array with no accessors and no named keys beyond `length`
+  // (`kc` counts own keys) clones by `slice()`: the descriptor path
+  // allocates one descriptor per element, O(n) per first draft write (10k
+  // rows: ~10 ms per push).
+  let clone;
+  if (!t.a && t.kc <= source.length + 1 && Object.getPrototypeOf(source) === Array.prototype)
+    clone = source.slice();
+  else {
+    const descs = Object.getOwnPropertyDescriptors(source);
+    for (const key of Reflect.ownKeys(descs)) {
+      const d = descs[key];
+      if (key === "length" && Array.isArray(source)) continue;
+      d.configurable = true;
+      if (!d.get && !d.set) d.writable = true;
+      else t.a = true;
+    }
+    clone = Array.isArray(source)
+      ? Object.defineProperties([], descs)
+      : Object.create(Object.getPrototypeOf(source), descs);
+  }
   clone[$OWNER] = t;
   return clone;
 }
@@ -4783,13 +5150,18 @@ function notifyWrites(t) {
   // Optimistic channel: a user's writes on an optimistic family become
   // guesses on the nodes (lanes); the draft is discarded, the committed
   // backing never touched.
-  if (optHooks && userWrite && t.fam?.opt === true) {
-    // The draft is discarded first: the diff reads the target (its nodes
-    // are born from the committed frame, not the draft).
-    t.pb = null;
-    t.wk = null;
-    t.pb = optHooks.writes(t, pb);
-    return;
+  if (optHooks && t.fam?.opt === true) {
+    if (userWrite) {
+      // The draft is discarded first: the diff reads the target (its nodes
+      // are born from the committed frame, not the draft).
+      t.pb = null;
+      t.wk = null;
+      t.pb = optHooks.writes(t, pb);
+      return;
+    }
+    // The derive's draft: new rows under guessed rows are paired with them
+    // first (D-34, #4329).
+    optHooks.pair(t, pb);
   }
   const old = t.v;
   // Devtools mutation hook: full-key diff (dev-only cost) so unobserved
@@ -4966,7 +5338,10 @@ function notifyKeyDiff(node, key, old, neu, probe = true) {
   } else {
     const ov = old[key];
     const nv = neu[key];
-    if (!isEqual(ov, nv) && !targetsEqual(ov, nv))
+    // A live chained `old` (a store proxy, §7b) already reads the inner
+    // store's next frame, not what the node was last told: written, the
+    // node's own equality judging it (#4361).
+    if (old[$TARGET] || (!isEqual(ov, nv) && !targetsEqual(ov, nv)))
       setSignal(node, typeof nv === "function" ? () => nv : nv);
   }
 }
@@ -4992,7 +5367,8 @@ function notifyKeyValue(node, key, ov, nv, old, neu) {
  * unrelated `a.value` stayed stale until the action settled). A real
  * change still writes, and on a held node still proposes. A live chained
  * `old` (a store proxy, §7b) reflects the inner store, not what the node
- * was last told — written unconditionally, as before.
+ * was last told — written unconditionally, as before; its container too
+ * (#4361).
  *
  * The container is told of an arrangement change when it has structural
  * subscribers OR carries an arrangement guess (S4): for a guessed
@@ -5004,17 +5380,18 @@ function notifyKeyValue(node, key, ov, nv, old, neu) {
  * lane, by accident of being unconditional. */
 function notifyFoldTail(t, old, neu) {
   const has = t.h;
+  const live = old[$TARGET];
   if (has !== null) {
-    const live = old[$TARGET];
     for (const key of Reflect.ownKeys(has))
       if (live || key in old !== key in neu) setSignal(has[key], key in neu);
   }
   const k = t.k;
   if (k !== null && (k._subs !== null || k._config & CONFIG_OVERRIDE)) {
     const changed =
-      Array.isArray(neu) && Array.isArray(old)
+      live ||
+      (Array.isArray(neu) && Array.isArray(old)
         ? arrayStructureChanged(old, neu)
-        : membershipChanged(old, neu);
+        : membershipChanged(old, neu));
     if (changed) notifyContainer(k, neu);
   }
 }
@@ -5302,16 +5679,27 @@ function changedBetween(target, v, pb, key, shape) {
 }
 /** Value of a key with a leaf: core's — `read()` links a tracked reader and,
  * tracked or not, applies the hold and A28 rules a signal's read does. A
- * projection's unheld staging is ahead for a handler (`familyAhead`). */
+ * projection's unheld staging is ahead for a handler (`familyAhead`), and is
+ * the only value while its derive has never committed: the committed side
+ * is the seed, never observable (A25) — a reader core serves the screen (a
+ * verdict reader, #4355) is served the staging, as for a memo born staged
+ * (core `serve`). */
 function nodeValue(node, backing, target) {
-  let v = read(node);
+  let v;
   if (
     node._pendingValue !== NOT_PENDING &&
     !(node._config & CONFIG_HELD) &&
-    context === null &&
-    target.fam !== null
-  )
+    target.fam !== null &&
+    (context === null || target.fam.node?._statusFlags & STATUS_UNINITIALIZED)
+  ) {
+    // A pass over a derive that has never committed: the staging is its
+    // first answer, not a change — linked and served with no verdict (a
+    // first landing is loading, not pending: A19 exc. 1, F-9, as for a memo
+    // born staged; core's verdict would call the leaf's staging pending).
+    devRead(node); // read()'s dev diagnostics, which this read skips
+    if (context !== null && tracking) link(node, context);
     v = node._pendingValue;
+  } else v = read(node);
   return v === FORCE ? backing : v;
 }
 /** Serve a present data key: link the leaf for a tracked reader (creating it
@@ -5398,15 +5786,9 @@ function pullFamily(target) {
     // (committed plus the guesses) and does not suspend on the derive; a
     // verdict window still asks it (`isPending` is true while the flight is
     // up). The family's, not the target's: the edit stands in for the one
-    // flight the family has.
-    const overlaid = target.fam.overlaid;
-    if (
-      verdict === null &&
-      fw._statusFlags & STATUS_PENDING &&
-      overlaid !== undefined &&
-      overlaid.size !== 0
-    )
-      return;
+    // flight the family has — not over a new question they do not answer
+    // (optimistic.ts `stands`, #4336).
+    if (verdict === null && fw._statusFlags & STATUS_PENDING && optHooks?.stands(target)) return;
     read(fw);
   } else untrack(() => read(fw));
 }
@@ -5531,6 +5913,7 @@ function warnWriteOutsideSetter(target, key, operation) {
 }
 const traps = {
   get(target, key, receiver) {
+    if (getObserver() === null) checkForeignRead();
     // One typeof gates every brand-symbol compare off the hot string path.
     if (typeof key !== "string") {
       if (key === $TARGET) return target;
@@ -5679,7 +6062,8 @@ const traps = {
       // Reading a currently-absent own key subscribes to it (R12) — for any
       // target OUTSIDE its own draft scope, even mid-setter (#3037, above).
       if (v === undefined && !inDraft(target)) {
-        if (getObserver() !== null) read(getNode(target, key, accProbe));
+        // (`nodeValue` reads — and links — the node it creates.)
+        if (getObserver() !== null) getNode(target, key, accProbe);
         const node = target.n?.[key];
         if (node) {
           const nv = nodeValue(node, undefined, target);
@@ -6009,6 +6393,17 @@ function createStore$1(initialValue, options) {
   const setter = fn => storeSetter(proxy, fn);
   return [proxy, setter];
 }
+/** The list driver's slot view of a shallow store (types.ts `shallowView`):
+ * one `readSource` for the container instead of a trap per slot. A shallow
+ * store's slots hold raw records, so the backing the container read serves
+ * is what each slot read would — except where a slot's own leaf can answer
+ * differently: an optimistic family's guesses, a chained backing, accessor
+ * keys, or a read inside a draft or write scope. Those keep the trap. */
+installShallowView(t => {
+  // Any open write scope keeps the trap (it covers `inDraft`).
+  if (t?.s && !(t.ch || t.a || writeScopes || writeOverride || t.fam?.opt))
+    return (t.fam && pullFamily(t), readSource(t));
+});
 /** True when `proxy` is a SHALLOW store (children served verbatim, slots
  * replaced by reference — #2932). The list driver uses this to choose the
  * slot-patch channel (collected row bodies) over per-record registration. */
@@ -6358,7 +6753,10 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
   if (shallow) markRawIngest(incoming);
   // The deep witness is bumped once per adoption (none to bump: done).
   let bumped = t.dk === null;
-  if (Array.isArray(prevView) !== nextArr) {
+  // A live chained base (a store proxy, §7b) reads the inner store's
+  // current frame, not what the nodes were last told — nothing to diff
+  // against: the fold writes every node (#4361).
+  if (Array.isArray(prevView) !== nextArr || old[$TARGET]) {
     notifyFold(t, old, incoming);
     return;
   }
@@ -6476,7 +6874,10 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
   let nodesHit = 0;
   for (const k in incoming) {
     const nv = incoming[k];
-    const ov = old[k];
+    let ov = old[k];
+    // A key under a guess is judged against the guess too (D-34): a truth
+    // equal to the value the guess covered still answers it.
+    if (optHooks && ov === nv && prevView !== old) ov = prevView[k];
     const isObj = nv !== null && typeof nv === "object";
     if (
       ov === nv &&
@@ -6676,6 +7077,7 @@ function wakeFamily(fam) {
   // reader the landing leaves unchanged does not re-run to clear it (#4305).
   const error = new NotReadyError(fw);
   fam.woke = true;
+  optHooks?.ask(fam);
   forEachFamilyNode(fam, n => {
     if (n._subs === null) return;
     // The leaf carries the derive's pending as a propagated copy, as a memo
@@ -6711,6 +7113,10 @@ function settleFamily(fam) {
   forEachFamilyNode(fam, n => {
     if (n._subs !== null) settlePendingSource(n, fw);
   });
+  // The landing is the derive's change for a reader parked on the derive
+  // itself, whatever status the landing pass began from (an errored derive
+  // re-asked: a reader that met the error has no leaf to learn it from).
+  insertSubs(fw);
 }
 /** A source's status reached the derive by propagation (core
  * `propagateStatus`), its pass not re-run: the family learns it as from the
@@ -6771,7 +7177,7 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, aroundDraftWri
       draft,
       s => {
         result = fn(shadow ?? s);
-        const commit = v => {
+        const commit = (v, wake = 1) => {
           // Shadow run: commit a detached snapshot, never the shadow itself
           // (adoption takes the value by identity — handing it the live
           // shadow would fuse the draft to the observable store).
@@ -6794,8 +7200,11 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, aroundDraftWri
           // A commit is the derive's change for the readers that observed its
           // flight (linked by `pullFamily`; a settled pull does not link), as
           // a memo's landing is for its readers: one that caught the NotReady
-          // (a fallback value, not pending) re-runs too (#4070).
-          insertSubs(owner);
+          // (a fallback value, not pending) re-runs too (#4070). A pass of a
+          // settled derive has none (`wake` 0): a link left is a stale one a
+          // held frame keeps (A30), from a reader that re-ran since. Woken by
+          // every pass, a reader feeding a key the pass peeks at looped (#4342).
+          if (wake) insertSubs(owner);
         };
         const sync = handleAsync(owner, result, commit, (error, pending) => {
           // The flight rejected: the leaves' readers learn it from here —
@@ -6808,7 +7217,8 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, aroundDraftWri
           if (pending) wakeFamily(fam);
           else errorFamily(fam);
         });
-        if (!owner._loading) commit(sync);
+        // (The status is the one before this pass: `recompute` sets it after.)
+        if (!owner._loading) commit(sync, owner._statusFlags & (STATUS_PENDING | STATUS_ERROR));
       },
       false
     );
@@ -7027,21 +7437,23 @@ function arrangement(t, a, b) {
   const av = a instanceof LaneView;
   const bv = b instanceof LaneView;
   if (!av && !bv) return false;
-  return arrangementEqual(av ? a.rows : a, bv ? b.rows : b, t.fam?.key ?? null);
+  return arrangementEqual(av ? a.rows : a, bv ? b.rows : b, t.fam);
 }
-function rowSame(a, b, keyFn) {
+function rowSame(a, b, fam) {
   if (isEqual(a, b) || targetsEqual(a, b)) return true;
-  if (keyFn === null || !isWrappable(a) || !isWrappable(b)) return false;
-  const ka = keyFn(unwrapValue(a));
-  const kb = keyFn(unwrapValue(b));
-  // Keyless rows are identified by position — reconcile's fallback when the
-  // key is missing. The caller already paired these by index, so two keyless
-  // rows are the same row and the landing confirms the arrangement instead of
-  // dissolving it. Dissolving held an external echo under the action, and a
-  // mainline `until` then timed out on a source that already contained it
-  // (#3898). Keyed rows still match only on the key.
-  if (ka === undefined && kb === undefined) return true;
-  return ka !== undefined && sameKey(ka, kb);
+  const keyFn = fam.key;
+  if (!keyFn || !isWrappable(a) || !isWrappable(b)) return false;
+  // A row the store already serves is its proxy's row: a reader (a list)
+  // holds that proxy, so another object at the index is another row, by key
+  // or contents alike — a guess's fresh object wraps a new proxy. A landing's
+  // object has been adopted by the row it pairs with, so it serves that
+  // row's proxy. Only rows no proxy serves yet pair by key, keyless rows by
+  // position — reconcile's fallback (#3898).
+  const ta = lookupTarget((a = unwrapValue(a)), fam);
+  const tb = lookupTarget((b = unwrapValue(b)), fam);
+  if (ta || tb) return ta === tb;
+  // (Two keyless rows: `undefined` is the same key.)
+  return sameKey(keyFn(a), keyFn(b));
 }
 /** Whether reconcile would write anything into `a` from `b`: wrappable
  * pairs descend, leaves compare as its writes do. A key mismatch is a
@@ -7066,11 +7478,11 @@ GlobalQueue._echoes = (a, b) => {
     return false;
   }
 };
-function arrangementEqual(a, b, keyFn) {
+function arrangementEqual(a, b, fam) {
   if (Array.isArray(a) !== Array.isArray(b)) return false;
   if (Array.isArray(a)) {
     if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) if (!rowSame(a[i], b[i], keyFn)) return false;
+    for (let i = 0; i < a.length; i++) if (!rowSame(a[i], b[i], fam)) return false;
     return true;
   }
   const ak = Reflect.ownKeys(a).filter(k => k !== $OWNER);
@@ -7130,6 +7542,33 @@ function reconcileDraft(draft, incoming, keyFn) {
   }
   for (const k of Object.keys(draft)) if (!(k in incoming)) delete draft[k];
 }
+/** Core asks (lanes `laneWrite`): the family's derive, re-asking in a lane of
+ * another action than the one that guessed this slot, writes it — that
+ * lane's new question, which the guess (over the old one) does not answer:
+ * the slot is the lane's derivation from here (F-6, #4336; lanes
+ * `laneStage` for a node's own pass). */
+GlobalQueue._slotTake = (n, back) => {
+  const t = n._host;
+  if (back) {
+    // The guess comes back (lanes `endLanes`): on the slot's node now — the
+    // node itself, or the one a read made after it was released.
+    const k = n._key;
+    markOverlaid(t);
+    return k === $TRACK
+      ? getContainerNode(t)
+      : n._equals === isEqual
+        ? getHasNode(t, k)
+        : getNode(t, k);
+  }
+  const d = t?.fam?.node?._x?._transaction;
+  const g = txOf(n);
+  if (!d?._lane || sameAction(d, g)) return false;
+  // The re-ask takes the target's guess whole: the slot is the lane's
+  // derivation; its other guessed slots show their truth in the lane's
+  // world (lanes `take`).
+  for (const m of nodesOf(t)) if (m?._config & CONFIG_GUESS && txOf(m) === g) take(m, d, m !== n);
+  return true;
+};
 /** Q-D (plan sec. 39): an OLDER question's truth landed beneath an arrangement
  * guess (`laneWrite` held it — another action's landing is not this guess's
  * answer). The guess is re-based over it: order from the guess, rows from
@@ -7272,7 +7711,30 @@ function laneSet(node, value, lane) {
     laneDirty(node, lane);
   }
 }
+/** D-34 for a per-key guess (#4329): the derive's draft wrote new objects
+ * over a target holding guessed rows (`d.length = 0; d.push(...rows)`, or
+ * `d.issues = rows`). The container on the way down to each guessed row
+ * reconciles the new object at its slot — in a keyed list, the one with
+ * the row's key — exactly as a returned landing would: rows match by key,
+ * a guessed row keeps its target, and its leaves are judged against their
+ * guesses. Rows nothing guessed are left as the draft wrote them. */
+function pairRows(t, pb) {
+  const keyFn = t.fam.key;
+  for (let c of t.fam.overlaid ?? []) {
+    // The guessed row, or its ancestor directly under `t` (none: skip).
+    while (c.u !== t) if ((c = c.u) === null) break;
+    if (c === null) continue;
+    const k = keyFn?.(c.v);
+    const nv = Array.isArray(pb)
+      ? k !== undefined && pb.find(r => isWrappable(r) && sameKey(keyFn(r), k))
+      : pb[c.pk];
+    // A new object only: not `c`'s own, nor one another row serves
+    // (pairing it would alias the two).
+    if (isWrappable(nv) && !lookupTarget(nv, t.fam)) reconcileState(nv, c.px, keyFn, true);
+  }
+}
 installOptHooks({
+  pair: pairRows,
   draft: optimisticDraft,
   writes: notifyOptimisticWrites,
   arrangement,
@@ -7281,8 +7743,55 @@ installOptHooks({
     writer ? optimisticView(t, src, laneValueOf, true) : optimisticView(t, src),
   has: optimisticHas,
   descriptor: optimisticOwnDescriptor,
-  sweep: sweepOverlaid
+  sweep: sweepOverlaid,
+  // A new question (not a `refresh()`) asked over guesses an earlier frame
+  // opened, which answer the old one (D-34, #4336). Stamped on `fam.asked`
+  // with this flush's `clock`, so it lapses when the flush ends: `clock + 1`
+  // from mainline over a live guess — a frame still reading a guess at the
+  // seam shows it beside the new input, so the flush holds with the guess's
+  // action (`park`); `~clock` from a lane with no guess of its own, or with
+  // no live guess left — the lane waits for its answer (F-6), as for a
+  // guessed `createOptimistic` (lanes `laneStage`). The guess's own lane
+  // asks nothing new and stamps nothing.
+  ask: fam => {
+    if (fam.node._flags & REACTIVE_REASK || !fam.overlaid?.size) return;
+    // Stamped with the flush (`clock`): it lapses when the flush ends.
+    let a = ~clock;
+    for (const g of fam.overlaid) {
+      const n = laneNodeOf(g);
+      if (n) {
+        if (passLane === null) a = clock + 1;
+        else if (sameAction(txOf(n), passLane)) return;
+      }
+    }
+    if ((fam.asked = a) > 0) joinFuture(null);
+  },
+  // Over a new question the guesses do not answer (`asked`): from mainline
+  // only a target carrying a guess stands in — a read of one with none is an
+  // ordinary pending read (F-2), so a keyed store's other keys wait for their
+  // answer, not for the guess's action; in a lane with no guess of its own,
+  // or with no live guess left, none does (F-6).
+  stands: t => {
+    const o = t.fam.overlaid;
+    const a = t.fam.asked;
+    return !!o?.size && (a !== clock + 1 || passLane !== null || o.has(t)) && a !== ~clock;
+  },
+  // Mainline hold (`clock + 1`): the flush joins the action of each guess a
+  // reader still reads at the seam; a reader that moved off it (a keyed
+  // store's other key) holds nothing.
+  park: t => {
+    for (const fam of overlaidFamilies)
+      if (fam.asked === clock + 1)
+        for (const g of fam.overlaid) {
+          const n = laneNodeOf(g, true);
+          if (n) merge$1(txOf(n)._parent, t);
+        }
+  }
 });
+/** Two lanes of one action (their parents resolved through merges). */
+function sameAction(a, b) {
+  return resolveTx(a._parent) === resolveTx(b._parent);
+}
 function shallowKeys(o) {
   const out = {};
   for (const k of Reflect.ownKeys(o)) if (k !== $OWNER) out[k] = unwrapValue(o[k]);
@@ -7304,7 +7813,7 @@ function sweepOverlaid() {
   for (const fam of overlaidFamilies) {
     const set = fam.overlaid;
     for (const t of set)
-      if (!carriesLane(t)) {
+      if (!laneNodeOf(t)) {
         set.delete(t);
         if (t.ch) rebaseChained(t);
         // The container shows its backing again (a shown arrangement guess
@@ -7359,23 +7868,27 @@ function rebaseChained(t) {
     k._notifiedAt !== notifyEpoch
   ) {
     const rows = Array.isArray(inner) ? untrack(() => inner.map(unwrapValue)) : inner;
-    if (!arrangementEqual(k._value.rows, rows, t.fam?.key ?? null)) {
+    if (!arrangementEqual(k._value.rows, rows, t.fam)) {
       insertSubs(k);
       changed = true;
     }
   }
   if (changed) schedule();
 }
-function carriesLane(t) {
-  if (t.k !== null && t.k._config & CONFIG_OVERRIDE) return true;
-  if (t.dk !== null && t.dk._config & CONFIG_OVERRIDE) return true;
-  const nodes = t.n;
-  if (nodes !== null)
-    for (const key of Reflect.ownKeys(nodes)) if (nodes[key]._config & CONFIG_OVERRIDE) return true;
-  const has = t.h;
-  if (has !== null)
-    for (const key of Reflect.ownKeys(has)) if (has[key]._config & CONFIG_OVERRIDE) return true;
-  return false;
+/** `t`'s nodes (a missing container or deep node: null). */
+function nodesOf(t) {
+  const all = [t.k, t.dk];
+  for (const r of [t.n, t.h]) if (r !== null) for (const k of Reflect.ownKeys(r)) all.push(r[k]);
+  return all;
+}
+/** A node of `t` carrying a lane value, if any (`read`: one a reader's
+ * last pass read). */
+function laneNodeOf(t, read) {
+  for (const n of nodesOf(t))
+    if (n?._config & CONFIG_OVERRIDE) {
+      if (!read) return n;
+      for (let s = n._subs; s !== null; s = s._nextSub) if (s._gen === s._sub._depGen) return n;
+    }
 }
 function overlaid(t) {
   const fam = t.fam;
@@ -8770,7 +9283,8 @@ function releaseMarkScope(carrier) {
 // A mark is a declared in-flight change: the marked node — and everything
 // derived from it — reads pending (`isPending` → true) from the declaration
 // until the surrounding transaction lands (an ambient mark, declared outside
-// one, releases at the next seam). The marked values stay readable: no reader
+// one, releases at the next seam; either, on a node whose own flight is
+// still up then, at the seam after that flight lands). The marked values stay readable: no reader
 // suspends on a mark, a mark holds nothing and entangles nothing — it is not
 // a node of its transaction (`blocked` never sees it), and a reader of marked
 // data joins nothing through it. A mark is never a re-ask, so a declared
@@ -8845,30 +9359,42 @@ function invalid(detail) {
   emitDiagnostic({ code: "INVALID_AFFECTS_TARGET", kind: "write", severity: "error", message });
   throw new Error(message);
 }
-installMarkHooks(release$1, parked => {
-  if (ambient.length === 0) return;
-  // The flush parked: the declaration's window is the frame's — the marks
-  // are its transaction's ("nothing async below ⇒ no window").
-  if (parked !== null) {
-    const list = (parked._marks ??= []);
-    for (let i = 0; i < ambient.length; i++) list.push(ambient[i]);
-    ambient.length = 0;
-    return;
+installMarkHooks(
+  nodes => {
+    // A landing's mark on a node whose own flight is up (a declared reload's
+    // quiet re-ask the action did not wait for) stays to the seam after
+    // that flight lands, as an ambient one does: the reload's window is the
+    // flight's (#4349). The rest release with the transaction.
+    const done = [];
+    for (let i = 0; i < nodes.length; i++) (inFlight(nodes[i]) ? ambient : done).push(nodes[i]);
+    nodes.length = 0;
+    release$1(done);
+  },
+  parked => {
+    if (ambient.length === 0) return;
+    // The flush parked: the declaration's window is the frame's — the marks
+    // are its transaction's ("nothing async below ⇒ no window").
+    if (parked !== null) {
+      const list = (parked._marks ??= []);
+      for (let i = 0; i < ambient.length; i++) list.push(ambient[i]);
+      ambient.length = 0;
+      return;
+    }
+    // Nothing parked, but a marked node's own flight is up (a declared
+    // reload's quiet re-ask — the node's, or a store leaf's family derive):
+    // the window is the flight's; the mark stays to the seam after the
+    // landing. The rest release: verdict-only, nothing to show.
+    let kept = 0;
+    const done = [];
+    for (let i = 0; i < ambient.length; i++) {
+      const n = ambient[i];
+      if (inFlight(n)) ambient[kept++] = n;
+      else done.push(n);
+    }
+    ambient.length = kept;
+    if (done.length !== 0) release$1(done);
   }
-  // Nothing parked, but a marked node's own flight is up (a declared
-  // reload's quiet re-ask — the node's, or a store leaf's family derive):
-  // the window is the flight's; the mark stays to the seam after the
-  // landing. The rest release: verdict-only, nothing to show.
-  let kept = 0;
-  const done = [];
-  for (let i = 0; i < ambient.length; i++) {
-    const n = ambient[i];
-    if (inFlight(n)) ambient[kept++] = n;
-    else done.push(n);
-  }
-  ambient.length = kept;
-  if (done.length !== 0) release$1(done);
-});
+);
 function inFlight(n) {
   return (
     (n._statusFlags & STATUS_PENDING) !== 0 ||
@@ -9410,27 +9936,37 @@ const boundaryOf = node => node._context[BOUNDARY];
  * has shown content, or while re-armed. */
 const isCollecting = b => b._type === STATUS_ERROR || !b._initialized || b._armed;
 /** A reader `b` waits on: recorded for its `on`, and `b` visited at the seam. */
-function record(b, node) {
-  b._readers.add(node);
+function record(b, node, source = node) {
+  b._readers.set(node, source);
   collecting.add(b);
 }
 /** The reader goes to the fallback: recorded, and the output re-derives
  * (a no-op while the output's own pass is running — its post-check
  * decides). */
-function caught(b, node, error) {
+function caught(b, node, error, source = node) {
   if (b._type === STATUS_ERROR) {
     // An error boundary waits on what THREW (`StatusError.source`), not on
-    // the reader that saw it: the reader recovers the moment a refetch
-    // starts (its boundary catches the pending), while the error is settled
-    // only when its source is neither errored nor in flight. `reset` re-runs
-    // the same node.
+    // the reader that saw it, while the error is settled only when its
+    // source is neither errored nor in flight and the reader is not pending
+    // on the answer that replaces it (`prune`) — or when the
+    // reader is disposed: a source no live reader holds holds nothing
+    // (#4373). A source that died (a memo its reader owned, kept past the
+    // pass that disposed it) settles nothing: the reader is waited on.
+    // `reset` re-runs the source.
     error ??= node._x?._error;
-    node = error?.source ?? node;
+    source = error?.source ?? node;
+    if (source._flags & REACTIVE_DISPOSED) source = node;
     const caught = unwrapStatusError(error);
     setSignal(b._error, caught);
-    reportClientError(caught, b._owner, node);
-  }
-  record(b, node);
+    reportClientError(caught, b._owner, source);
+  }
+  record(b, node, source);
+  // A loading fallback behind an error fallback is hidden: the error stays
+  // the display until what the fallback waits on answers (D-39) — the
+  // error boundary waits on it too.
+  // (`_type`: STATUS_PENDING 1 < STATUS_ERROR 2 — an error boundary above a
+  // loading one.)
+  for (let p = b; (p = p._parent); ) if (p._fallback && p._type > b._type) record(p, node);
   if (b._armed) flip(b);
   // Already showing the fallback: one more reader to wait on changes
   // nothing on screen. The fallback is instantiated once per show — a later
@@ -9463,16 +9999,20 @@ function redraw(b) {
 function catchStatus(node, flags, error) {
   if (flags === 0) {
     // A status cleared. Judged by the node's status now, against each
-    // boundary's own rule (`unsettled`) — the error path clears pending
+    // boundary's own rule (`prune`'s mask) — the error path clears pending
     // first and the node is still errored then. The last reader a fallback
     // waited on settling re-derives the output now, in the same heap (a
     // held reader's landing has joined its transaction, so the content
     // lands with its run, not a round after). Others still waiting: nothing
-    // on screen changes, the fallback stays as it is.
+    // on screen changes, the fallback stays as it is. `node` here is an
+    // effect reporting its own status. An error boundary records an effect
+    // only while it is errored, and a staged error keeps STATUS_ERROR on a
+    // node that had it (`stageError`), so `prune`'s CONFIG_STAGED_ERROR case
+    // cannot reach this path (#4364).
     if (collecting.size !== 0)
       for (let b = boundaryOf(node); b; b = b._parent)
         if (
-          !(node._statusFlags & unsettled(b)) &&
+          !(b._readers.get(node)?._statusFlags & (b._type | STATUS_PENDING)) &&
           b._readers.delete(node) &&
           b._readers.size === 0
         ) {
@@ -9541,16 +10081,28 @@ function release(b) {
  * that landed but is held (its value staged in a transaction) is not: the
  * content reveals at the commit, with its run. The tree is: the output reads
  * it and enters the transaction itself (its committed value shows until the
- * landing). */
-const unsettled = b => (b._type === STATUS_ERROR ? STATUS_ERROR | STATUS_PENDING : STATUS_PENDING);
+ * landing). The statuses that keep a reader: pending — and its error, for an
+ * error boundary (`_type` is the status it catches) — on the reader or its
+ * source. A reader pending again after the source that threw answered (it
+ * re-asks through a memo that carried the error) has no new answer yet: the
+ * error stays the display (D-39: a pending is not a value; async-gen 91501
+ * #1831). */
 function prune(b, pass) {
-  const mask = unsettled(b);
-  for (const r of b._readers) {
-    if (r._flags & REACTIVE_DISPOSED) b._readers.delete(r);
-    else if (!(r._statusFlags & mask)) {
+  const mask = b._type | STATUS_PENDING;
+  for (const [r, s] of b._readers) {
+    if (!((r._flags | s._flags) & REACTIVE_DISPOSED)) {
+      // An error staged on its source (D-41, `stageError`) is not settled:
+      // it publishes with the commit. A reader that threw it now (a lane
+      // pass, a reader of a node born staged) reached the boundary first
+      // (#4364).
       if (
-        (r !== b._tree || b._armed) &&
-        (r._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD
+        (r._statusFlags | s._statusFlags) & mask ||
+        (mask & STATUS_ERROR && s._config & CONFIG_STAGED_ERROR)
+      )
+        continue;
+      if (
+        (s !== b._tree || b._armed) &&
+        (s._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD
       ) {
         // Landed, held: the content is that transaction's — the output's
         // pass enters it and the reveal lands with the reader's run. The
@@ -9560,10 +10112,10 @@ function prune(b, pass) {
         // the reader is committed (#3540: what a fresh boundary catches holds
         // nothing outside it).
         if (!pass || !b._initialized) continue;
-        joinFuture(txOf(r));
+        joinFuture(txOf(s));
       }
-      b._readers.delete(r);
     }
+    b._readers.delete(r);
   }
   return b._readers.size;
 }
@@ -9595,12 +10147,17 @@ function boundarySeam() {
     if (flags & REACTIVE_ZOMBIE) continue;
     prune(b, false);
     const o = b._output;
+    // A fallback staged into the very hold its readers landed in folds back
+    // (D-16, U-9): the content is ready when that hold commits (D-15). Not
+    // only at the re-arm's own seam: readers pending then land, held, a
+    // flush later (#4379 — the staged fallback otherwise commits with the
+    // hold, and a quiet refresh then caught keeps it up, F-9).
     if (
-      b._armed &&
       !b._initialized &&
       o._config & CONFIG_HELD &&
       [...b._readers].every(
-        r => !(r._statusFlags & STATUS_PENDING) && r._config & CONFIG_HELD && txOf(r) === txOf(o)
+        ([, s]) =>
+          !(s._statusFlags & STATUS_PENDING) && s._config & CONFIG_HELD && txOf(s) === txOf(o)
       )
     ) {
       b._readers.clear();
@@ -9636,7 +10193,7 @@ function reportOutsideHold(b) {
     for (let o = boundaryOf(reader); o; o = o._parent) if (o === b) return false;
     return true;
   };
-  for (const r of b._readers) {
+  for (const r of b._readers.keys()) {
     const sources = r._x?._pendingSources;
     if (sources === undefined) continue;
     for (const source of sources) {
@@ -9707,7 +10264,7 @@ function arm(b) {
   collecting.add(b);
   const n = b._readers.size;
   heldUnder(b._owner, flushTransaction, r => record(b, r));
-  for (const r of b._readers) {
+  for (const [r] of b._readers) {
     if (
       b._readers.size !== n ||
       (r._statusFlags & STATUS_PENDING && !(r._flags & REACTIVE_DISPOSED))
@@ -9717,7 +10274,9 @@ function arm(b) {
       // It is this boundary's alone now (B5, the nearest catcher): an outer
       // re-armed by the same tick does not wait for it (D-14, U-4).
       for (let a = b._parent; a !== null; a = a._parent)
-        for (const o of b._readers) a._readers.delete(o);
+        // An outer error boundary keys its readers too, but waits on their
+        // sources: a re-armed Loading taking the pending does not settle it.
+        if (a._type & STATUS_PENDING) for (const [o] of b._readers) a._readers.delete(o);
       flip(b);
       redraw(b);
       return;
@@ -9728,10 +10287,32 @@ function arm(b) {
  * names a signal — nothing to re-run). */
 function reset(b) {
   // A snapshot: a source failing again is caught — and re-added — mid-walk.
-  for (const r of [...b._readers])
+  for (const r of new Set(b._readers.values()))
     if (r._fn !== undefined && !(r._flags & REACTIVE_DISPOSED)) recompute(r);
   schedule();
 }
+/**
+ * Dev CHECK: the `on` dependencies evaluated to a function — `<Loading
+ * on={route}>` or `on={() => route()}` passes the accessor itself, a stable
+ * value that is never called, so nothing is read and the boundary never
+ * re-arms. Checked on the first run only: the shape is static.
+ */
+function reportOnAccessor(b) {
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "LOADING_ON_ACCESSOR",
+        kind: "async",
+        severity: "warn",
+        message:
+          "[LOADING_ON_ACCESSOR] A Loading boundary's `on` received a function. `on` takes the " +
+          "dependency's value — `on={route()}`, or `on={[query(), page()]}` for several — and an " +
+          "accessor passed instead is never called, so nothing is read and the boundary never re-arms."
+      },
+      b._owner
+    )
+  );
+}
 function createBoundary(type, fn, show, onFn) {
   if (!getOwner()) {
     const message =
@@ -9753,7 +10334,7 @@ function createBoundary(type, fn, show, onFn) {
     _owner: owner,
     _tree: null,
     _output: null,
-    _readers: new Set(),
+    _readers: new Map(),
     _initialized: false,
     _armed: false,
     _armLane: null,
@@ -9783,7 +10364,8 @@ function createBoundary(type, fn, show, onFn) {
     runWithOwner(owner, () =>
       computed(() => {
         try {
-          onFn();
+          const deps = onFn();
+          if (true && !mounted && typeof deps === "function") reportOnAccessor(b);
         } catch (e) {
           if (!(e instanceof NotReadyError)) {
             if (!globalQueue.notify(getOwner(), STATUS_ERROR, STATUS_ERROR, e)) {
@@ -9954,12 +10536,14 @@ function createBoundary(type, fn, show, onFn) {
   return accessor(output);
 }
 function fallback(b) {
+  // (The output's pass.)
+  const out = getOwner();
   // The swap a display-ahead re-arm asked for: this pass is the lane's — a
   // lane read by construction (REACTIVE_LANE_READ: `recompute`'s tail keeps
   // the pass in the lane).
   if (b._lane !== null) {
     setPassLane(b._lane);
-    b._output._flags |= REACTIVE_LANE_READ;
+    out._flags |= REACTIVE_LANE_READ;
     b._lane = null;
   }
   // Observe: a loading boundary starts showing its fallback — the swap lands
@@ -9987,11 +10571,18 @@ function fallback(b) {
   // outside the boundary, as the output is: its errors and runs are the
   // enclosing boundary's — with the output's id, so what it builds gets the
   // ids a build under the output would; disposed once content is on screen.
-  if (b._fb === null) {
-    const out = getOwner();
+  if (b._fb === null)
     b._fb = runWithOwner(out._parent, () => computed(() => b._show(b), { id: out.id }));
-  }
-  return read(b._fb);
+  // The swap is structure (#3540): what the fallback reads ahead — a
+  // verdict (`latest()`), a lane — is the fallback's display-ahead, not the
+  // swap's: the output's pass stays where it was (F-6 stays inside the
+  // fallback, #4337).
+  const p = passLane;
+  const f = out._flags;
+  const v = read(b._fb);
+  setPassLane(p);
+  out._flags ^= (out._flags ^ f) & (REACTIVE_PROBED | REACTIVE_LANE_READ);
+  return v;
 }
 const ERROR_SIGNAL = { ownedWrite: true, _noSnapshot: true };
 /**