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

package/dist/dev-shared.js

@@ -152,6 +152,11 @@ const REACTIVE_SCREEN_READ = 1 << 18;
  * later read of the same pass routed it into a verdict lane — that was not
  * the probe's answer (lanes.ts). Per pass. */
 const REACTIVE_PROBE_UNANSWERED = 1 << 19;
+/** The pass opened a verdict window of its own (`isPending`/`latest`) — not
+ * only read a verdict memo (F-6, core.ts `read`). An async memo whose pass
+ * did not is D-25's hold work while its flight is up (verdict.ts
+ * `holdWork`). Per pass (1 << 20 is lanes.ts's LEFT_SHOWN). */
+const REACTIVE_WINDOW = 1 << 21;
 // Static configuration bits packed into Owner/Computed/Signal _config.
 const CONFIG_OWNED_WRITE = 1 << 0;
 const CONFIG_NO_SNAPSHOT = 1 << 1;
@@ -299,6 +304,9 @@ const CONFIG_KEY_BAG = 1 << 28;
  * joins nothing, so two mounts under one boundary made in separate flushes
  * keep their holds apart (D-4, S-5 rows 1′–3′, #4283). */
 const CONFIG_FRAME = 1 << 23;
+/** The node's last answering pass registered a flight: an async memo. Kept
+ * by the verdict engine alone (verdict.ts `holdWork`), which reads it. */
+const CONFIG_ASYNC = 1 << 29;
 const STATUS_NONE = 0;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
@@ -328,6 +336,69 @@ const $REFRESH = Symbol("refresh");
 
 const NewSet = Set;
 
+const COPY = { rooted: false };
+let warned = false;
+let shared;
+{
+  shared = globalThis.Solid$$copies ||= { copies: 0, running: undefined };
+  shared.copies++;
+}
+function warnOnce(detail) {
+  if (warned) return;
+  warned = true;
+  console.warn(
+    `You appear to have multiple instances of Solid: ${detail} Make sure every package resolves the same solid-js (e.g. \`resolve.dedupe\` in Vite) and that libraries keep solid-js external.`
+  );
+}
+function markCopyRooted() {
+  COPY.rooted = true;
+}
+/**
+ * Marks this copy as the one running; returns the slot's previous value. A
+ * nested run of the same copy (most runs inside a flush) only reads the slot.
+ */
+function enterCopy() {
+  if (shared.copies < 2) return COPY;
+  const prev = shared.running;
+  if (prev !== COPY) shared.running = COPY;
+  return prev;
+}
+function exitCopy(prev) {
+  if (prev !== COPY) shared.running = prev;
+}
+/** @internal Runs `fn` with this copy marked as the one running. */
+function runAsSolidCopy(fn) {
+  if (shared.copies < 2) return fn();
+  const prev = enterCopy();
+  try {
+    return fn();
+  } finally {
+    exitCopy(prev);
+  }
+}
+/** @internal An ownerless component or context read: warns if another copy is running. */
+function checkForeignOwnerless() {
+  if (shared.copies < 2) return;
+  const running = shared.running;
+  if (running && running !== COPY)
+    warnOnce(
+      "a component or useContext() from one copy ran inside a component rendered by another, so it has no owner and will not react or find its providers."
+    );
+}
+/**
+ * An untracked read: warns if another copy's computation is running, unless
+ * both copies render through roots of their own (an app calling into an
+ * isolated copy's API, which reads its own state untracked by design).
+ */
+function checkForeignRead() {
+  if (shared.copies < 2) return;
+  const running = shared.running;
+  if (running && running !== COPY && !(running.rooted && COPY.rooted))
+    warnOnce(
+      "a signal or store from one copy was read inside a computation of another, so the read is not tracked and will not update."
+    );
+}
+
 let attrHooks = null;
 /**
  * The installed engine, registered on `globalThis` as well (the records
@@ -1560,6 +1631,7 @@ function createOwner(options) {
  */
 function createRoot(init, options) {
   const owner = createOwner(options);
+  markCopyRooted();
   // A bound function, not an arrow: an arrow would share this scope, which
   // holds `init`, so keeping `dispose` would keep `init` and all it closes
   // over alive (#4095).
@@ -1582,6 +1654,19 @@ let laneSeamsHook = null;
 let laneCorrectionsHook = null;
 let endLanesHook = null;
 let lanesBlockedHook = null;
+/** R5 (lanes.ts `laneSeams` parks a frame flight): the landing's re-derive
+ * of a reader adopts the flight instead (true: adopted, nothing to queue). */
+let laneAdoptHook = null;
+/** core.ts `frameRead` served lane work or a verdict reader a held node's
+ * committed value (lanes.ts `laneServed`). */
+let laneServedHook = null;
+/** A guess was written (lanes.ts `optimisticWrite`): the arms only a guess
+ * reaches (CONFIG_GUESS) — a build without `createOptimistic` or
+ * `createOptimisticStore` never sets it, and its bundler folds them. */
+let guessing = false;
+function armGuessing() {
+  guessing = true;
+}
 function installLaneHooks(
   read,
   stage,
@@ -1591,7 +1676,9 @@ function installLaneHooks(
   seams,
   corrections,
   end,
-  blocked
+  blocked,
+  adopt,
+  served
 ) {
   laneReadHook = read;
   laneStageHook = stage;
@@ -1602,6 +1689,8 @@ function installLaneHooks(
   laneCorrectionsHook = corrections;
   endLanesHook = end;
   lanesBlockedHook = blocked;
+  laneAdoptHook = adopt;
+  laneServedHook = served;
 }
 // Boundaries (boundaries.ts): the display consumers between an observer
 // and the root. `catch` — status from a frame reader, nearest boundary
@@ -1650,8 +1739,12 @@ function installMarkHooks(release, releaseAmbient) {
 }
 /** Verdicts (verdict.ts). */
 let observeFlightHook = null;
-function installVerdictHooks(observeFlight) {
+/** D-25's hold work (verdict.ts `holdWork`): on `source` going pending,
+ * whether verdict reader `n` waits on it instead of re-deriving. */
+let holdWorkHook = null;
+function installVerdictHooks(observeFlight, holdWork) {
   observeFlightHook = observeFlight;
+  holdWorkHook = holdWork;
 }
 /** External-source bridge (wired by enableExternalSource(); undefined while
  * no config is active — including after _resetExternalSourceConfig()). */
@@ -1712,6 +1805,10 @@ function setPassLane(l) {
  * schedules the seam that consumes it: membership is the tick's — the same
  * synchronous frame — and the next tick's writes are not this one's. */
 let flushTransaction = null;
+/** The flush's transaction while only a `latest()` read of a staging opened
+ * it (verdict.ts `provisionalVerdict`): it holds nothing, and a verdict
+ * reader's plain read of a staging in it is the frame's read (D-22). */
+let latestOpened = null;
 /** The transaction the passes running OUTSIDE a flush this tick derive from
  * (a mainline mount, a mainline re-pass): the passes' own (A29, creation-
  * time form — "the entry is the pass's alone"): their results are staged
@@ -2213,7 +2310,7 @@ class GlobalQueue {
     // pure round — the parent's flights before the parent is judged below.
     if (laneCorrectionsHook?.()) runHeap(dirtyQueue, GlobalQueue._update);
     const joined = flushTransaction;
-    flushTransaction = null;
+    flushTransaction = latestOpened = null;
     // The frame's verdict is in: the guesses written since the last seam
     // open their lane under the frame's transaction (a lane's own flush
     // parents a nested lane to it), or are dropped — the frame commits, and
@@ -2331,7 +2428,7 @@ class GlobalQueue {
     // world (a lane's runs wait this round).
     if (laneSeamsHook) {
       this._queues = lanes;
-      laneSeamsHook(t !== null ? stagedReaders : null);
+      laneSeamsHook(t);
       if (stagedReaders.length) stagedReaders.length = 0;
     }
     this._queues = [[], []];
@@ -2464,17 +2561,46 @@ function reruns(u) {
     const r = u._reruns[i];
     // An errored reader's display is its error (D-39): the landing gives it
     // nothing to re-derive, and a re-run would be a read that retries the
-    // errored source (#3945).
-    if (r._flags & REACTIVE_DISPOSED || r._statusFlags & STATUS_ERROR) continue;
-    if (r._flags & REACTIVE_FRAME_READ || r._config & CONFIG_VERDICT) {
-      frame ||= r._type;
-      r._flags &= ~REACTIVE_FRAME_READ;
+    // errored source (#3945) — unless that source is errored no longer: the
+    // reader was served a shown error the landing replaces (`throwShown`).
+    // Nor is the reader's own error: its pass threw over the committed value
+    // of what the landing carries, served as the screen (A10; a lane's node
+    // reading its parent's hold, or a pass with no value yet reading a
+    // staging, `stagedScreen`) — the landing is the new answer, and the
+    // reader re-derives on it (A15; D-39). A first load read so has no other
+    // run: its error would stay the screen (async-gen 91501 #1158, #119).
+    // A boundary's structure (its tree, its output: CONFIG_FRAME, no effect
+    // type) re-derives all the same: what it read as the screen is the
+    // content the landing replaces, and only its pass links the new content
+    // whose recovery must reach it (D-3, D-39, #4405).
+    const s = r._x?._error?.source;
+    if (
+      r._flags & REACTIVE_DISPOSED ||
+      (r._statusFlags & STATUS_ERROR &&
+        (r._type || !(r._config & CONFIG_FRAME)) &&
+        s !== r &&
+        (s?._statusFlags ?? STATUS_ERROR) & STATUS_ERROR)
+    )
+      continue;
+    if (r._flags & REACTIVE_FRAME_READ || (observeFlightHook && r._config & CONFIG_VERDICT)) {
+      // A memo re-deriving its own error holds the release as an effect
+      // does (`land`): run first, the held runs showed that error beside a
+      // frame about to replace it (#4407; #4284: the grouping never changes
+      // the screen).
+      frame ||= r._type || s === r;
+      // A lane's reveal leaves the mark to the transaction: a reader that
+      // also read a held node as committed (`staleReader`) still observes
+      // that flight until it re-runs — cleared here, the transaction landed
+      // at this seam with the flight up and voided the reveal's run (#4397).
+      if (!u._lane) r._flags &= ~REACTIVE_FRAME_READ;
       r._modified = false;
       // Its frame is replaced by the re-derivation: a run one of its
       // children queued this flush (re-run by the same landing) is for the
       // frame being replaced — void too (#3404).
       for (let c = r._firstChild; c !== null; c = c._nextSibling) if (c._type) c._modified = false;
-      enqueueSub(r);
+      // A frame flight the seam parked (lanes.ts `laneSeams`, R5) asked the
+      // question this landing would: adopted, it is asked once (F-9).
+      if (!laneAdoptHook?.(r)) enqueueSub(r);
     }
   }
   u._reruns.length = 0;
@@ -2598,11 +2724,22 @@ function insertSubs(node) {
  * inert for its pass (`recompute` seats a lane only from its own `_x`), it
  * is a live write if the effect becomes a zombie later this flush — an
  * on-screen reader whose removal an adopted write stages follows the lane
- * (the lane-membership ruling, 2026-10-05; `_update`). */
+ * (the lane-membership ruling, 2026-10-05; `_update`).
+ *
+ * A render effect re-run by a verdict memo's change (`createMemo(() =>
+ * latest(x))`, CONFIG_VERDICT) is the verdict reader the same read inline
+ * makes it, for that pass (F-6; D-26 `[s(), L()]`, #4284): a frame reader
+ * of its other reads — a staging's screen, a flight's committed value. One
+ * an earlier propagation this flush seated in another lane leaves that
+ * seat: its pass starts from the frame's, as the inline effect's does, and
+ * `laneRead` re-derives it on the screen if that lane holds (`entered`). */
 function laneDirty(node, l) {
   for (let s = node._subs; s !== null; s = s._nextSub) {
-    const t = s._sub._x?._transaction;
-    if (t?._lane ? sameLane(t, l) : s._sub._type) s._sub._flags |= REACTIVE_LANE_DIRTY;
+    const c = s._sub,
+      t = c._x?._transaction;
+    if (c._type === EFFECT_RENDER && node._config & CONFIG_VERDICT)
+      ((c._config |= CONFIG_VERDICT), (c._flags &= ~REACTIVE_LANE_DIRTY));
+    if (t?._lane ? sameLane(t, l) : c._type) c._flags |= REACTIVE_LANE_DIRTY;
   }
 }
 /** One lane, or two of one link group (#3335): one reveal unit. */
@@ -2630,7 +2767,7 @@ function commitPendingNode(n) {
   const inFlight = n._pendingValue === NOT_PENDING && (c._statusFlags & STATUS_PENDING) !== 0;
   const err = n._config & CONFIG_STAGED_ERROR;
   // An answer commits: the error it replaces leaves the display (D-41).
-  if (!inFlight && c._x) c._x._shownError = undefined;
+  if (!inFlight && c._x) c._x._shownError = null;
   n._config = inFlight ? (n._config & -1048833) | CONFIG_INPUTS_PUBLISHED : n._config & -3147137;
   // D-41: the staged answer is an error — published now, when a value would
   // show, through the ordinary error path (`stageError`). Its readers first
@@ -3315,8 +3452,9 @@ function settlePendingSource(el, source = el) {
       // A19: a verdict reader holds no pending of its own (it was re-derived
       // when the source went pending, `propagateStatus`), and a landing
       // equal to the committed value notifies nobody — the source settling
-      // is its verdict changing: it runs again.
-      return node._config & CONFIG_VERDICT && enqueueSub(node);
+      // is its verdict changing: it runs again. (Verdict readers exist only
+      // with the verdict engine installed.)
+      return holdWorkHook && node._config & CONFIG_VERDICT && enqueueSub(node);
     visited.add(node);
     node._time = clock;
     const remaining = node._x?._pendingSources?.values().next().value;
@@ -3416,7 +3554,10 @@ function handleAsync(
     });
   }
   if (!thenable && !iterator) {
-    if (el._x !== null) el._x._inFlight = null;
+    if (el._x !== null) {
+      el._x._inFlight = null;
+      if (holdWorkHook) el._config &= ~CONFIG_ASYNC;
+    }
     // A sync landing is the first real answer for a loadingValue node.
     el._loading = false;
     return result;
@@ -3449,6 +3590,11 @@ function handleAsync(
   // fired _flightTeardown. A future non-recompute registration path must
   // release it here before overwriting _inFlight.
   ext(el)._inFlight = result;
+  // D-25 (verdict.ts `holdWork`): an async memo whose answering pass opened
+  // no verdict window of its own (`markVerdictReader` clears the bit).
+  // Kept by the verdict engine alone (`holdWorkHook`): a build without it
+  // folds the bit's upkeep away.
+  if (holdWorkHook && !(el._flags & REACTIVE_WINDOW)) el._config |= CONFIG_ASYNC;
   // The question this flight answers (A18 provenance, lanes.ts): the action
   // whose slice asked it; mainline is always the current question.
   el._x._q = question || MAINLINE_QUESTION;
@@ -3544,7 +3690,7 @@ function handleAsync(
       // a verdict reader of the next flight would suspend instead of being
       // served the screen; held, both at the derive's commit.
       if (!(el._config & CONFIG_HELD)) {
-        el._x._shownError = undefined;
+        el._x._shownError = null;
         el._config &= ~CONFIG_INPUTS_PUBLISHED;
       }
       if (wasUninitialized) landStatus(el, true);
@@ -3872,8 +4018,7 @@ function notifyStatus(el, status, error) {
     !(error instanceof NotReadyError)
   )
     error = new StatusError(el, error);
-  const pendingSource =
-    status === STATUS_PENDING && error instanceof NotReadyError ? error.source : undefined;
+  const pendingSource = status === STATUS_PENDING && error instanceof NotReadyError && error.source;
   // (CARVE 2: the lane assignment went with the engine.)
   if (status === STATUS_PENDING && pendingSource) {
     // D-41: a re-ask of a shown error keeps it the display (`_shownError`).
@@ -3908,9 +4053,14 @@ function notifyStatus(el, status, error) {
   // status, not its readers': they read the guess. The flight is the parent
   // transition's to wait on — the frame it was asked in holds (A17: "a
   // transition whose optimistic node is still pending on its own fetch is
-  // not complete"), through the node itself (`blocked`).
-  if (status === STATUS_PENDING && el._config & CONFIG_GUESS) {
-    if (passLane === null) joinFuture(null);
+  // not complete"), through the node itself (`blocked`). An input changed
+  // from outside the guess's hold asks a new question: the frame that
+  // changed it is held with that hold (D-34, #4336) — it shows beside the
+  // guess's truth, which reveals at that hold's commit (F-1). A `refresh()`
+  // re-asks the same question: its frame is its own.
+  // (No guess written, no arm.)
+  if (guessing && status === STATUS_PENDING && el._config & CONFIG_GUESS) {
+    if (passLane === null) joinFuture(el._flags & REACTIVE_REASK ? null : txOf(el)._parent);
     return;
   }
   const elNotify = statusNotifierOf(el);
@@ -3926,8 +4076,7 @@ function notifyStatus(el, status, error) {
  * propagates the derive's status from each leaf to the leaf's readers
  * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */
 function propagateStatus(el, status, error) {
-  const pendingSource =
-    status === STATUS_PENDING && error instanceof NotReadyError ? error.source : undefined;
+  const pendingSource = status === STATUS_PENDING && error instanceof NotReadyError && error.source;
   forEachDependent(el, (sub, link) => {
     sub._time = clock;
     // A pending mark on a kept-tail link re-derives the subscriber instead of
@@ -3949,8 +4098,15 @@ function propagateStatus(el, status, error) {
     // Inheriting the error would make a probe's reader errored. A boundary's
     // output (CONFIG_REDERIVE, boundaries.ts) the same: content or fallback
     // is its pass's call.
+    // Not one D-25 makes the hold's work (verdict.ts `holdWork`): an async
+    // memo with no verdict window of its own reads a verdict memo's value,
+    // and that source going pending changes none of its reads — re-derived,
+    // it is served the committed value it already derived from (A10) and
+    // asks that question again. It waits on the source like any derivation
+    // (F-9), and asks its next question once, at the landing (#4397).
     if (
-      sub._config & (CONFIG_REDERIVE | CONFIG_VERDICT) ||
+      sub._config & CONFIG_REDERIVE ||
+      (holdWorkHook && sub._config & CONFIG_VERDICT && !(pendingSource && holdWorkHook(sub, el))) ||
       (status === STATUS_PENDING && link._gen !== sub._depGen)
     ) {
       enqueueSub(sub);
@@ -4183,19 +4339,19 @@ function recompute(el, create = false) {
   // Restored at the end, after this pass's staging and runs have been
   // routed.
   // Lanes exist only with the lane engine installed (`laneStageHook`): a
-  // bundle without it seats every pass on mainline, and folds the seat away.
+  // bundle without it seats every pass on mainline (`passLane` is never set)
+  // and folds the seat, and its restores, away.
   const prevLane = passLane;
   // The mount a first pass belongs to: its creator's lane, or the one its
   // creator's own mount came from — a render effect a verdict lane's mount's
   // content creates is that mount's too (#4166). Lanes only, like the seat.
   const prevMount = laneRoot;
   const mount = laneStageHook && (laneRoot = create && (prevLane || prevMount));
-  setPassLane(
-    !laneStageHook
-      ? null
-      : (el._flags & REACTIVE_LANE_DIRTY ||
-            (el._config & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE) &&
-          el._x?._transaction?._lane
+  if (laneStageHook)
+    setPassLane(
+      (el._flags & REACTIVE_LANE_DIRTY ||
+        (el._config & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE) &&
+        el._x?._transaction?._lane
         ? el._x._transaction
         : // Loose `!=`: false with no creator lane (undefined == null).
           create &&
@@ -4203,7 +4359,7 @@ function recompute(el, create = false) {
             creatorPass(context)?._flags & REACTIVE_RECOMPUTING_DEPS
           ? prevLane
           : null
-  );
+    );
   // Attribution hook: fired before this run touches the dep list — `_deps`
   // still holds the previous run's links (the subscriptions that could have
   // triggered this run, and the baseline for the engine's subscription diff).
@@ -4214,9 +4370,35 @@ function recompute(el, create = false) {
   }
   // CARVE 2: lane posture resolution (OPTIMISTIC_DIRTY, derived-override
   // re-derivation, lane adoption through deps) went with the optimistic engine.
+  // An error a pass staged, which this pass replaces (`valueChanged`).
+  const replaced = el._config & CONFIG_STAGED_ERROR;
   if (!create) {
     deleteFromHeap(el, dirtyQueue);
+    // A pending flight is the transition's own work (#3884), and so is a
+    // held async memo's re-run with no verdict window of its own (D-25,
+    // `holdWork`): a pass that takes no verdict role this time. A probe on
+    // an earlier pass left CONFIG_VERDICT, and a frame read here would serve
+    // the committed screen, settle the flight and drop the hold — a
+    // superseding write's verdict would depend on that probe. Cleared for
+    // this pass, before the flight it judges by is superseded; a probe in
+    // the body re-stamps it after the plain reads. Not an effect: it has no
+    // flight of its own (its pending is a source's), and a verdict memo's
+    // change may have just made it a verdict reader (`laneDirty`). Only a
+    // build with the lane engine (`laneStageHook`; verdict.ts imports it)
+    // ever sets CONFIG_VERDICT: without it the line folds away.
+    if (
+      laneStageHook &&
+      !isEffect &&
+      (el._statusFlags & STATUS_PENDING ||
+        (el._config & (CONFIG_ASYNC | CONFIG_HELD)) === (CONFIG_ASYNC | CONFIG_HELD))
+    )
+      el._config &= ~CONFIG_VERDICT;
     if (el._x !== null) {
+      // The seam's re-derive runs with the parked flight still current; any
+      // later pass asks its own question (`_parked`; only the lane engine
+      // parks one).
+      const p = laneStageHook && el._x._parked;
+      if (p && p !== el._x._inFlight) el._x._parked = undefined;
       el._x._inFlight = null;
       // Supersede is where an iterator flight dies (#3122): close it now.
       // Idempotent with the cleanup-channel close.
@@ -4235,12 +4417,6 @@ function recompute(el, create = false) {
     // A).
     // A boundary's structure (CONFIG_FRAME) is the frame like a render
     // effect: it publishes mainline outside its transaction's flush (#4283).
-    // A pending flight is the transition's own work (#3884). A probe on an
-    // earlier pass left CONFIG_VERDICT, and a frame read here would serve the
-    // committed screen, settle the flight and drop the hold — a superseding
-    // write's verdict would depend on that probe. Cleared for this pass; a
-    // probe in the body re-stamps it after the plain reads.
-    if (el._statusFlags & STATUS_PENDING) el._config &= ~CONFIG_VERDICT;
     if (el._config & CONFIG_HELD) {
       const tx = txOf(el);
       // Held by a blocked lane: the frame joins nothing — a lane never holds
@@ -4264,7 +4440,11 @@ function recompute(el, create = false) {
         // children die below (`disposeChildren`). The landing re-derives a
         // fresh held frame for the reveal (`_reruns`).
         // Not held any more, whichever frame reader it is: its readers read
-        // the value this pass publishes.
+        // the value this pass publishes — those that read the staging it
+        // supersedes re-derive, even when it publishes the committed value
+        // back (no change to notify them by): their held runs carry the
+        // superseded frame, and the landing would apply them (#4378).
+        if (el._pendingValue !== NOT_PENDING) insertSubs(el);
         el._pendingValue = NOT_PENDING;
         el._config &= ~CONFIG_HELD;
       }
@@ -4296,9 +4476,9 @@ function recompute(el, create = false) {
   // Capture both error and pending status before the compute clears them.
   // A conditional can drop its pending source and recover to an unchanged
   // value, leaving blocked dependents outside that source’s settle walk.
-  const outgoingError = el._statusFlags & STATUS_ERROR ? el._x?._error : undefined;
+  const outgoingError = el._statusFlags & STATUS_ERROR && el._x?._error;
   const wasPending = (el._statusFlags & STATUS_PENDING) !== 0;
-  const outgoingPendingSources = wasPending ? el._x?._pendingSources : undefined;
+  const outgoingPendingSources = wasPending && el._x?._pendingSources;
   // Pending SOURCE-hood, captured before the compute clears status: a node
   // whose own flight parked dependents self-registers in _pendingSources
   // (notifyStatus, isSource). If this recompute supersedes that flight and
@@ -4311,9 +4491,15 @@ function recompute(el, create = false) {
   // A19 exc. 2: a `refresh()` re-asks the question already answered — quiet
   // for the verdict — unless the question in flight is a new one, which the
   // re-ask does not launder (a poll during a quiet confirm stays quiet).
+  // Nor a guess's new question whose answer is still held (#4336: an
+  // action's refresh after an outside input change has not committed it).
   const reask =
     (el._flags & REACTIVE_REASK) !== 0 &&
-    !(el._statusFlags & STATUS_PENDING && el._x !== null && !el._x._reask);
+    !(
+      (el._statusFlags & STATUS_PENDING || (guessing && el._pendingValue !== NOT_PENDING)) &&
+      el._x !== null &&
+      !el._x._reask
+    );
   const oldcontext = context;
   context = el;
   el._depsTail = null;
@@ -4343,6 +4529,7 @@ function recompute(el, create = false) {
     prevStrictRead = strictRead;
     strictRead = false;
   }
+  const prevCopy = enterCopy();
   tracking = true;
   try {
     if (!true && el._config & CONFIG_SYNC);
@@ -4356,7 +4543,10 @@ function recompute(el, create = false) {
       const selfRegistered = el._x?._inFlight !== prevInFlight;
       value = selfRegistered || !isAsyncResult ? fnResult : handleAsync(el, fnResult);
       if (!selfRegistered && !isAsyncResult) {
-        if (el._x !== null) el._x._inFlight = null;
+        if (el._x !== null) {
+          el._x._inFlight = null;
+          if (holdWorkHook) el._config &= ~CONFIG_ASYNC;
+        }
         // A sync (non-object) return is the first real answer; async-shaped
         // results clear inside handleAsync at their own landing points, and a
         // self-registered flight clears when its own handleAsync lands.
@@ -4370,6 +4560,10 @@ function recompute(el, create = false) {
     if (el._statusFlags !== 0 || el._x !== null) clearStatus(el, create);
   } catch (e) {
     const notReady = e instanceof NotReadyError;
+    // An error answers, and so does a loading window's unready read (D-25,
+    // verdict.ts `holdWork`): no flight is its own. A pass left pending
+    // keeps the last answer's. (Kept by the verdict engine alone.)
+    if (holdWorkHook && (!notReady || el._loading)) el._config &= ~CONFIG_ASYNC;
     if (notReady && el._loading) {
       // Loading window with an unready sync dependency: register for the
       // source's settle (the settlePendingSource walk runs off
@@ -4406,7 +4600,10 @@ function recompute(el, create = false) {
   } finally {
     tracking = prevTracking;
     if (laneStageHook) laneRoot = prevMount;
-    strictRead = prevStrictRead;
+    {
+      strictRead = prevStrictRead;
+      exitCopy(prevCopy);
+    }
     // Consume the missed-wake latch (#3037, set by insertSubs): a dep write
     // landed beneath this pass on a link it had already validated. The wipe
     // below must not key off DIRTY/CHECK — the read-time pull protocol
@@ -4415,17 +4612,24 @@ function recompute(el, create = false) {
     missedWake = (el._flags & REACTIVE_MISSED_WAKE) !== 0;
     // A mount's staged read joins it — except a nested derivation left
     // pending: no render effect reaches it yet, so it holds nothing and
-    // reaches no boundary (Reader, #4203). A reader that does is caught.
+    // reaches no boundary (Reader, #4203), whatever it read — a memo the
+    // mount bore held over the staging included, at any depth (#4340). A
+    // reader that does is caught.
     joined = !!(
       el._flags &
-      (mount && (prevLane || isEffect || !(el._statusFlags & STATUS_PENDING))
-        ? REACTIVE_JOINED | REACTIVE_STAGED_READ
+      (mount
+        ? prevLane || isEffect || !(el._statusFlags & STATUS_PENDING)
+          ? REACTIVE_JOINED | REACTIVE_STAGED_READ
+          : 0
         : REACTIVE_JOINED)
     );
     // A verdict reader is one for as long as it probes, or reads a memo
     // that does (`read`): a pass that did neither (REACTIVE_PROBED, the same
-    // bit) is an ordinary derivation again.
-    el._config = (el._config & ~CONFIG_VERDICT) | (el._flags & REACTIVE_PROBED);
+    // bit) is an ordinary derivation again. Its async posture is the
+    // verdict engine's to keep (CONFIG_ASYNC, verdict.ts `holdWork`, D-25).
+    // (Only the verdict engine probes: without it the line folds away.)
+    if (observeFlightHook)
+      el._config = (el._config & ~CONFIG_VERDICT) | (el._flags & REACTIVE_PROBED);
     // REACTIVE_DISPOSED survives too (#3621): the pass may have disposed its
     // own owner (a memo calling its root's `dispose()`, a cleanup doing so
     // #3601/#3606), and `disposeChildren` set the flag on this node
@@ -4465,7 +4669,7 @@ function recompute(el, create = false) {
     clearDeps(el);
     if (el._x !== null) el._x._inFlight = null;
     if (attrHooks !== null) attrHooks.recomputeEnd(el, create, false, false, false, false);
-    setPassLane(prevLane);
+    if (laneStageHook) setPassLane(prevLane);
     return;
   }
   // The lane this pass is work of, if any: its seat (the node's, its
@@ -4509,8 +4713,15 @@ function recompute(el, create = false) {
           ? el._x._lane
           : el._value;
     // A throwing comparator is contained inside `isSame` (A3, #2837; #4111).
+    // A pass replacing an error this node staged is a new answer, even the
+    // committed value (D-41: a recovery equal to the last good value is a
+    // change): the slot it publishes to held the error, and the readers that
+    // derived from it — `latest()` throws it — re-derive (#4403).
     const valueChanged =
-      (!isEffect && wasUninitialized) || !!el._x?._shownError || !isSame(el, compareValue, value);
+      (!isEffect && wasUninitialized) ||
+      !!el._x?._shownError ||
+      !!replaced ||
+      !isSame(el, compareValue, value);
     // A committed derived change becomes a cause for this node's subscribers,
     // chaining their attribution through this node to the root write.
     if (attrHooks !== null) {
@@ -4607,6 +4818,10 @@ function recompute(el, create = false) {
         el._value = value;
       } else {
         el._pendingValue = value;
+        // D-39: a staged recovery keeps the error it replaces the display
+        // until it commits (`commitPendingNode`), as a write over one does
+        // (`setMemo`).
+        if (outgoingError) el._x._shownError = outgoingError;
         // Born held: in the transaction from birth, so a read of it this
         // tick is a read of its world (the mount-during-a-hold case), not
         // only after the seam parks it.
@@ -4643,7 +4858,7 @@ function recompute(el, create = false) {
     // recoveries ride insertSubs above; a comparator throw re-errored the node
     // (el._x?._error re-set), so this only runs on a genuinely clean recovery.
     if (!valueChanged && !el._x?._error) {
-      if (outgoingError !== undefined) settleErroredDependents(el, outgoingError);
+      if (outgoingError) settleErroredDependents(el, outgoingError);
       // Self-registration (this node's own superseded flight) is the #3181
       // sweep's business below — retiring it here too would walk twice.
       if (outgoingPendingSources)
@@ -4715,7 +4930,7 @@ function recompute(el, create = false) {
     // Lane work is the lane's to reveal (its seam), not this flush's commit.
     if (lane === null) queuePendingNode(el);
   }
-  setPassLane(prevLane);
+  if (laneStageHook) setPassLane(prevLane);
   // Missed-wake reschedule (see the finally above): values this pass read
   // before the nested commit are stale, so run again now that the heap will
   // accept the node. Equality gates stop same-value landings from cascading,
@@ -4858,7 +5073,7 @@ function ext(el) {
     _q: 0,
     _lane: NOT_PENDING,
     _marks: 0,
-    _shownError: undefined
+    _shownError: null
   });
 }
 /** A tracked read of a held node (the reader derives from its transaction's
@@ -4943,6 +5158,9 @@ function frameRead(c, el) {
   // head), and the pass may then read a guess and become the lane's.
   if ((t === flushTransaction && !lane && !verdict) || bornInto(c, t)) return false;
   staleReader(c, t);
+  // Lane work or a verdict reader no longer waits on `el`'s flight (lanes.ts
+  // `laneServed`, A15).
+  if (lane || verdict) laneServedHook(c, el);
   return true;
 }
 /** A node born into transaction `t`: held by it and never committed (A29,
@@ -4962,6 +5180,15 @@ function bornInto(c, t) {
 function creatorPass(owner) {
   return owner !== null && owner._root ? owner._parentComputed : owner;
 }
+/** What `born` and the passes still running around `p` read — its
+ * creator's, theirs — of the future or a staging (REACTIVE_JOINED |
+ * REACTIVE_STAGED_READ): a pass created by one that did has no screen; its
+ * branch exists only in that world (#4341). */
+function creatorReads(p, born) {
+  return (p = creatorPass(p._parent))?._flags & REACTIVE_RECOMPUTING_DEPS
+    ? creatorReads(p, born | p._flags)
+    : born & (REACTIVE_JOINED | REACTIVE_STAGED_READ);
+}
 /** L2 — park the previous pass's frame for this node's commit: the children
  * (already allocated — nothing new) and the `_disposal` list move to the
  * extension, keep reacting from the heap, and die when the commit publishes
@@ -5426,8 +5653,15 @@ function pullComputed(owner, c) {
   // parent check is shallow, might need to be recursive
   if (height >= c._height && owner._parent !== c) c._height = height + 1;
 }
-function read(el) {
+/**
+ * Dev only: a read's diagnostics — the devtools read hook, the foreign-read
+ * check and the post-await untracked-read check. Every caller guards with
+ * `true`: `read` here, and a store leaf's read that is served without
+ * `read` (`nodeValue`'s first landing), so no read goes unseen in dev.
+ */
+function devRead(el) {
   DEV.hooks.onRead?.(el);
+  if (!tracking) checkForeignRead();
   if (asyncTailFlights !== 0 && !tracking && untrackDepth === 0)
     checkPostAwaitRead(
       el,
@@ -5437,6 +5671,9 @@ function read(el) {
       (el._statusFlags & (STATUS_PENDING | STATUS_UNINITIALIZED)) ===
         (STATUS_PENDING | STATUS_UNINITIALIZED)
     );
+}
+function read(el) {
+  devRead(el);
   let c = context;
   if (c?._root) c = c._parentComputed;
   const computed = el;
@@ -5445,10 +5682,11 @@ function read(el) {
   // as the `||` expression was: a signal's `_statusFlags`/`_height` read as
   // undefined and mask to 0 on every site below.)
   const owner = el;
-  if (typeof computed._fn === "function") prepareComputed(el);
   // The verdict windows (`latest`, `isPending`; verdict.ts): one cold path,
-  // off this one, present only while a window is open.
+  // off this one, present only while a window is open. It wakes a lazy or
+  // dormant memo itself, outside the window (#4366).
   if (verdict !== null) return verdict(el, c);
+  if (typeof computed._fn === "function") prepareComputed(el);
   if (
     !computed._fn &&
     el._x?._snapshotValue === undefined &&
@@ -5507,7 +5745,8 @@ function read(el) {
         // it probed inline: it reads held values as the screen and shows the
         // verdict now. Not an effect: a render effect is a frame reader
         // already, and a user effect's posture is its own reads'.
-        if (!c._type) c._flags |= owner._config & CONFIG_VERDICT;
+        // (A verdict memo exists only with the verdict engine installed.)
+        if (observeFlightHook && !c._type) c._flags |= owner._config & CONFIG_VERDICT;
       }
     }
     // L2, as in the fast block above (tracked or not). A node born into the
@@ -5566,7 +5805,10 @@ function read(el) {
   // — unless the flight committed beneath inputs already on screen
   // (`observeFlight`), or the reader was born into the flight's transaction
   // (#4010): it has no screen, and waits on the flight with its frame.
+  // (A lane, and a verdict reader, exist only with their engines installed —
+  // the verdict engine imports the lane engine: without it the test folds.)
   if (
+    laneStageHook &&
     owner._statusFlags & STATUS_PENDING &&
     !committed &&
     !(el._config & CONFIG_OVERRIDE) &&
@@ -5574,11 +5816,8 @@ function read(el) {
   ) {
     // A reader with no committed value yet sees the flight pending: a
     // boundary a lane mounts shows its fallback (A29's boundary exemption).
-    // (A lane, and a verdict reader, exist only with their engines installed.)
-    if (laneStageHook && passLane !== null && !(c?._statusFlags & STATUS_UNINITIALIZED))
-      committed = true;
-    else if (observeFlightHook && c !== null && c._config & CONFIG_VERDICT)
-      committed = observeFlightHook(c, owner);
+    if (passLane !== null && !(c?._statusFlags & STATUS_UNINITIALIZED)) committed = true;
+    else if (c !== null && c._config & CONFIG_VERDICT) committed = observeFlightHook(c, owner);
   }
   if (owner._statusFlags & STATUS_PENDING && !committed) {
     // A reader landing on a pending node throws; an untracked read of an
@@ -5626,13 +5865,21 @@ function read(el) {
     if (tracking && owner._time < clock) {
       recompute(owner);
       return read(el);
-    } else throw owner._x?._error;
-  }
-  if (committed) return el._value;
-  // D-41: an untracked read reads the screen, and a shown error is on it
-  // until the answer that replaces it commits.
-  if (!c && el._x?._shownError) throw el._x._shownError;
-  const value = serve(el, c);
+    }
+    // D-41: a staged error replacing the shown one is this flush's answer
+    // (`stageError`): a reader served the staging (`serve`) throws it, as it
+    // would read a staged value, and stages its own error with it; one
+    // served the screen throws the shown error. Thrown the shown error, a
+    // reader born this flush published it, and its readers' stale error
+    // committed after the new one (#4404).
+    if (!committed && el._config & CONFIG_STAGED_ERROR) serve(el, c);
+    throw owner._x?._error;
+  }
+  // D-41: an untracked read reads the screen, and so does a frame reader
+  // served the committed value — `serve` hands it that value as it does an
+  // untracked read — a shown error included (`throwShown`).
+  if (committed || !c) throwShown(el);
+  const value = serve(el, committed ? null : c);
   if (
     !c &&
     typeof computed._fn === "function" &&
@@ -5651,6 +5898,12 @@ function read(el) {
   }
   return value;
 }
+/** D-41: a reader served the screen — an untracked read, a frame reader
+ * served the committed value, a verdict reader (`serve`) — reads a shown
+ * error there until the answer that replaces it commits. */
+function throwShown(el) {
+  if (el._x?._shownError) throw el._x._shownError;
+}
 /**
  * Rule 1, the one slow implementation (DESIGN-CONSOLIDATION move 3b, step
  * 6c): the value a reader `c` (null = untracked, no pass) is served from
@@ -5677,12 +5930,13 @@ function serve(el, c) {
     markLateLinker(c);
     return u;
   }
-  if (readerSeesCommitted(el, c)) return el._value;
   if (
-    observeFlightHook &&
-    c._config & CONFIG_VERDICT &&
-    !(el._statusFlags & STATUS_UNINITIALIZED) &&
-    stagedScreen(c)
+    readerSeesCommitted(el, c) ||
+    (observeFlightHook &&
+      c._config & CONFIG_VERDICT &&
+      !(el._statusFlags & STATUS_UNINITIALIZED) &&
+      stagedScreen(c) &&
+      !throwShown(el))
   )
     return el._value;
   stagedRead(c, el);
@@ -5708,7 +5962,14 @@ function serve(el, c) {
 function stagedRead(c, el) {
   if (!(el?._statusFlags & STATUS_UNINITIALIZED)) {
     c._flags |= REACTIVE_STAGED_READ;
-    if (laneSeamsHook && passLane !== null) stagedReaders.push(c);
+    // A verdict reader's too when it is an effect, before the frame has a
+    // transaction (after, `stagedScreen` serves it the screen): the staging
+    // is the frame's read, and the pass re-derives once as a verdict reader
+    // if the flush parks (D-22; D-25: the probe decides the posture in either
+    // read order). A memo's is the frame's derivation either way: a memo is
+    // not a leaf (`frameRead`).
+    if (laneSeamsHook && (passLane !== null || (c._type && c._config & CONFIG_VERDICT)))
+      stagedReaders.push(c);
   }
 }
 /** A10 for a staged node: a verdict reader (the pass entered a window) that
@@ -5722,6 +5983,21 @@ function stagedRead(c, el) {
  * (`bornInto`, #4010): its branch exists only there. */
 function stagedScreen(c) {
   if (flushTransaction === null || bornInto(c, flushTransaction)) return false;
+  // A transaction only a `latest()` read opened holds nothing: the staging
+  // is the frame's read for a pass in the frame's seat, as it is before the
+  // frame has one, and the seam re-derives the pass once only if the flush
+  // parks (D-22, F-10). Lane work sees the screen (D-37). Not a pass with no
+  // value yet: its first answer is nobody's hold (D-6) and would commit the
+  // staging whether or not the frame parks — it reads the screen, and runs
+  // again at the landing.
+  if (
+    observeFlightHook &&
+    flushTransaction === latestOpened &&
+    passLane === null &&
+    c._config & CONFIG_VERDICT &&
+    !(c._statusFlags & STATUS_UNINITIALIZED)
+  )
+    return !stagedReaders.push(c);
   staleReader(c, flushTransaction);
   return true;
 }
@@ -5900,7 +6176,7 @@ function setMemo(el, v) {
   // The error stays the display until the write commits (D-41).
   if (el._statusFlags & STATUS_ERROR) {
     el._x._shownError = el._x._error;
-    notifyStatus(el, STATUS_NONE, undefined);
+    notifyStatus(el, STATUS_NONE);
   }
   v = setSignal(el, v);
   // A write replaces an error a pass staged (D-41): it is a value again.
@@ -6014,203 +6290,216 @@ function markRefresh(node) {
 }
 
 export {
-  merge as $,
-  tracking as A,
-  CONFIG_CHILDREN_FORBIDDEN as B,
+  sameLane as $,
+  REACTIVE_STAGED_READ as A,
+  REACTIVE_DISPOSED as B,
   CONFIG_GUESS as C,
-  passLane as D,
-  EFFECT_RENDER as E,
-  setPassLane as F,
+  CONFIG_VERDICT as D,
+  REACTIVE_PROBE_UNANSWERED as E,
+  blocked as F,
   GlobalQueue as G,
-  sameLane as H,
-  flushTransaction as I,
-  REACTIVE_SCREEN_READ as J,
-  REACTIVE_FRAME_READ as K,
-  attrHooks as L,
-  commitPendingNode as M,
+  bornInto as H,
+  REACTIVE_LANE_DIRTY as I,
+  isThenable as J,
+  CONFIG_HELD as K,
+  clock as L,
+  insertSubs as M,
   NOT_PENDING as N,
-  REACTIVE_IN_HEAP as O,
-  REACTIVE_DIRTY as P,
-  REACTIVE_CHECK as Q,
-  REACTIVE_DISPOSED as R,
+  laneDirty as O,
+  REACTIVE_LANE_READ as P,
+  flushTransaction as Q,
+  REACTIVE_DIRTY as R,
   STATUS_UNINITIALIZED as S,
-  STATUS_PENDING as T,
-  CONFIG_INPUTS_PUBLISHED as U,
-  releaseQueues as V,
-  CONFIG_SLOT_NODE as W,
-  holdNode as X,
-  joinFuture as Y,
-  reruns as Z,
-  CONFIG_STAGED as _,
+  REACTIVE_RECOMPUTING_DEPS as T,
+  queuePendingNode as U,
+  STATUS_ERROR as V,
+  tracking as W,
+  CONFIG_CHILDREN_FORBIDDEN as X,
+  passLane as Y,
+  EFFECT_RENDER as Z,
+  setPassLane as _,
   NotReadyError as a,
-  resetUnhandledAsync as a$,
-  REACTIVE_JOINED as a0,
-  REACTIVE_STAGED_READ as a1,
-  stagedRead as a2,
-  setVerdict as a3,
-  context as a4,
-  installVerdictHooks as a5,
-  REACTIVE_PROBED as a6,
-  verdict as a7,
-  link as a8,
-  pullComputed as a9,
-  signal as aA,
-  setSignal as aB,
-  cleanup as aC,
-  read as aD,
-  DEV as aE,
-  CONFIG_TRANSPARENT as aF,
-  NoOwnerError as aG,
-  ContextNotFoundError as aH,
-  createEffectNode as aI,
-  recompute as aJ,
-  EFFECT_USER as aK,
-  reportDiagnostic as aL,
-  computed as aM,
-  staleValues as aN,
-  CONFIG_AUTO_DISPOSE as aO,
-  EFFECT_TRACKED as aP,
-  heldRunHook as aQ,
-  unwrapStatusError as aR,
-  setStrictRead as aS,
-  queueEvent as aT,
-  StatusError as aU,
-  trimStaleDeps as aV,
-  haltReactivityAt as aW,
-  strictReadEvent as aX,
-  setTrackedQueueCallback as aY,
-  setEffectStatusNotify as aZ,
-  _hitUnhandledAsync as a_,
-  strictRead as aa,
-  strictReadActive as ab,
-  warnStrictReadUntracked as ac,
-  staleReader as ad,
-  globalQueue as ae,
-  joinPass as af,
-  markLateLinker as ag,
-  spectating as ah,
-  unflushedValue as ai,
-  CONFIG_STAGED_ERROR as aj,
-  stagedReaders as ak,
-  bornInto as al,
-  enterAction as am,
-  setEffectCallback as an,
-  exitAction as ao,
-  isThenable as ap,
-  actionDepth as aq,
-  flush as ar,
-  setQuestion as as,
-  emitDiagnostic as at,
-  enterCallback as au,
-  exitCallback as av,
-  getOwner as aw,
-  inEffectCallback as ax,
-  effectCallbackEvent as ay,
-  setExternalHooks as az,
+  heldRunHook as a$,
+  REACTIVE_SCREEN_READ as a0,
+  REACTIVE_FRAME_READ as a1,
+  attrHooks as a2,
+  CONFIG_INPUTS_PUBLISHED as a3,
+  releaseQueues as a4,
+  holdNode as a5,
+  reruns as a6,
+  CONFIG_STAGED as a7,
+  merge as a8,
+  creatorReads as a9,
+  exitAction as aA,
+  actionDepth as aB,
+  flush as aC,
+  setQuestion as aD,
+  emitDiagnostic as aE,
+  enterCallback as aF,
+  exitCallback as aG,
+  getOwner as aH,
+  inEffectCallback as aI,
+  effectCallbackEvent as aJ,
+  setExternalHooks as aK,
+  signal as aL,
+  setSignal as aM,
+  cleanup as aN,
+  read as aO,
+  DEV as aP,
+  CONFIG_TRANSPARENT as aQ,
+  NoOwnerError as aR,
+  ContextNotFoundError as aS,
+  createEffectNode as aT,
+  recompute as aU,
+  EFFECT_USER as aV,
+  reportDiagnostic as aW,
+  computed as aX,
+  staleValues as aY,
+  CONFIG_AUTO_DISPOSE as aZ,
+  EFFECT_TRACKED as a_,
+  REACTIVE_JOINED as aa,
+  stagedRead as ab,
+  setVerdict as ac,
+  context as ad,
+  installVerdictHooks as ae,
+  creatorPass as af,
+  CONFIG_ASYNC as ag,
+  REACTIVE_PROBED as ah,
+  REACTIVE_WINDOW as ai,
+  verdict as aj,
+  prepareComputed as ak,
+  link as al,
+  pullComputed as am,
+  strictRead as an,
+  strictReadActive as ao,
+  warnStrictReadUntracked as ap,
+  globalQueue as aq,
+  joinFuture as ar,
+  joinPass as as,
+  markLateLinker as at,
+  spectating as au,
+  unflushedValue as av,
+  CONFIG_STAGED_ERROR as aw,
+  REACTIVE_REASK as ax,
+  enterAction as ay,
+  setEffectCallback as az,
   CONFIG_AUTHORITATIVE as b,
-  peekNextChildId as b$,
-  ROOT_ERROR_HOOK as b0,
-  registerGraph as b1,
-  runWithOwner as b2,
-  setMemo as b3,
-  $REFRESH as b4,
-  markRefresh as b5,
-  createRoot as b6,
-  getObserver as b7,
-  dispose as b8,
-  TimeoutError as b9,
-  handleAsync as bA,
-  addPendingSource as bB,
-  propagateStatus as bC,
-  forEachDependent as bD,
-  settlePendingSource as bE,
-  joinPassAt as bF,
-  notifyEpoch as bG,
-  SUPPORTS_PROXY as bH,
-  CONFIG_KEY_BAG as bI,
-  releaseMarksHook as bJ,
-  installMarkHooks as bK,
-  CONFIG_LAGS as bL,
-  REACTIVE_REASK as bM,
-  onSupersede as bN,
-  haltReactivity as bO,
-  CONFIG_FRAME as bP,
-  heldUnder as bQ,
-  unhold as bR,
-  laneStageHook as bS,
-  REACTIVE_ZOMBIE as bT,
-  installBoundaryHooks as bU,
-  CAUGHT_REARMED as bV,
-  OBSERVE as bW,
-  clearSnapshots as bX,
-  enforceLoadingBoundary as bY,
-  getNextChildId as bZ,
-  markSnapshotScope as b_,
-  untrack as ba,
-  dirtyQueue as bb,
-  CONFIG_REDERIVE as bc,
-  passTx as bd,
-  CONFIG_FRESH_READ as be,
-  createOwner as bf,
-  writeHook as bg,
-  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as bh,
-  ownedScopeWriteMessage as bi,
-  isEqual as bj,
-  CONFIG_MANUAL_WRITE as bk,
-  snapshotCaptureActive as bl,
-  captureWriteSnapshot as bm,
-  notePromotedWrite as bn,
-  slotSignal as bo,
-  stagedScreen as bp,
-  CONFIG_PROMOTED as bq,
-  setSlotUnobserved as br,
-  installStoreHooks as bs,
-  joinPassTx as bt,
-  asyncTailFlights as bu,
-  untrackDepth as bv,
-  checkPostAwaitRead as bw,
-  disposalDepth as bx,
-  insertIntoHeap as by,
-  isDisposed as bz,
+  heldUnder as b$,
+  unwrapStatusError as b0,
+  setStrictRead as b1,
+  queueEvent as b2,
+  StatusError as b3,
+  trimStaleDeps as b4,
+  haltReactivityAt as b5,
+  strictReadEvent as b6,
+  setTrackedQueueCallback as b7,
+  setEffectStatusNotify as b8,
+  _hitUnhandledAsync as b9,
+  slotSignal as bA,
+  stagedScreen as bB,
+  devRead as bC,
+  CONFIG_PROMOTED as bD,
+  setSlotUnobserved as bE,
+  installStoreHooks as bF,
+  joinPassTx as bG,
+  asyncTailFlights as bH,
+  untrackDepth as bI,
+  checkPostAwaitRead as bJ,
+  disposalDepth as bK,
+  insertIntoHeap as bL,
+  isDisposed as bM,
+  addPendingSource as bN,
+  propagateStatus as bO,
+  forEachDependent as bP,
+  settlePendingSource as bQ,
+  joinPassAt as bR,
+  notifyEpoch as bS,
+  SUPPORTS_PROXY as bT,
+  CONFIG_KEY_BAG as bU,
+  releaseMarksHook as bV,
+  installMarkHooks as bW,
+  CONFIG_LAGS as bX,
+  onSupersede as bY,
+  haltReactivity as bZ,
+  CONFIG_FRAME as b_,
+  resetUnhandledAsync as ba,
+  ROOT_ERROR_HOOK as bb,
+  registerGraph as bc,
+  runWithOwner as bd,
+  setMemo as be,
+  $REFRESH as bf,
+  markRefresh as bg,
+  createRoot as bh,
+  getObserver as bi,
+  dispose as bj,
+  TimeoutError as bk,
+  untrack as bl,
+  dirtyQueue as bm,
+  CONFIG_REDERIVE as bn,
+  passTx as bo,
+  CONFIG_FRESH_READ as bp,
+  createOwner as bq,
+  writeHook as br,
+  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as bs,
+  ownedScopeWriteMessage as bt,
+  isEqual as bu,
+  CONFIG_MANUAL_WRITE as bv,
+  checkForeignRead as bw,
+  snapshotCaptureActive as bx,
+  captureWriteSnapshot as by,
+  notePromotedWrite as bz,
   CONFIG_OVERRIDE as c,
-  releaseSnapshotScope as c0,
-  resetErrorHalt as c1,
-  setConsoleFooter as c2,
-  setSnapshotCapture as c3,
-  setWriteHook as c4,
-  setAttributionHooks as c5,
-  liveRootOwners as c6,
-  ownerPath as c7,
-  isSuppressed as c8,
-  blockersOf as c9,
-  CONFIG_PLUMBING as ca,
-  anyExcluded as cb,
-  isExcluded as cc,
-  CONFIG_WIDE as cd,
-  GRAPH_SIZE_WARN_AT as ce,
-  noteFanOut as cf,
-  CONFIG_SUPERSEDES as cg,
-  newTransaction as d,
+  unhold as c0,
+  laneStageHook as c1,
+  REACTIVE_ZOMBIE as c2,
+  installBoundaryHooks as c3,
+  CAUGHT_REARMED as c4,
+  OBSERVE as c5,
+  checkForeignOwnerless as c6,
+  clearSnapshots as c7,
+  enforceLoadingBoundary as c8,
+  getNextChildId as c9,
+  markSnapshotScope as ca,
+  peekNextChildId as cb,
+  releaseSnapshotScope as cc,
+  resetErrorHalt as cd,
+  runAsSolidCopy as ce,
+  setConsoleFooter as cf,
+  setSnapshotCapture as cg,
+  setWriteHook as ch,
+  setAttributionHooks as ci,
+  liveRootOwners as cj,
+  ownerPath as ck,
+  isSuppressed as cl,
+  blockersOf as cm,
+  CONFIG_PLUMBING as cn,
+  anyExcluded as co,
+  isExcluded as cp,
+  CONFIG_WIDE as cq,
+  GRAPH_SIZE_WARN_AT as cr,
+  noteFanOut as cs,
+  CONFIG_SUPERSEDES as ct,
+  armGuessing as d,
   enqueueSub as e,
-  CONFIG_VERDICT as f,
-  REACTIVE_PROBE_UNANSWERED as g,
-  blocked as h,
+  newTransaction as f,
+  staleReader as g,
+  removePendingSource as h,
   installLaneHooks as i,
-  REACTIVE_LANE_DIRTY as j,
-  CONFIG_HELD as k,
-  clock as l,
-  insertSubs as m,
+  REACTIVE_CHECK as j,
+  REACTIVE_IN_HEAP as k,
+  list as l,
+  releaseFlightTeardown as m,
   nextQuestion as n,
-  ownFlights as o,
-  laneDirty as p,
+  handleAsync as o,
+  notifyStatus as p,
   question as q,
   resolveTx as r,
   schedule as s,
-  txOf as t,
-  REACTIVE_LANE_READ as u,
+  STATUS_PENDING as t,
+  CONFIG_SLOT_NODE as u,
   ext as v,
-  REACTIVE_RECOMPUTING_DEPS as w,
-  queuePendingNode as x,
-  list as y,
-  STATUS_ERROR as z
+  txOf as w,
+  commitPendingNode as x,
+  ownFlights as y,
+  stagedReaders as z
 };