@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.16

package/dist/dev-shared.js

@@ -23,18 +23,18 @@
  * ```
  */
 class NotReadyError extends Error {
-  source;
   constructor(source) {
     super();
     this.source = source;
   }
 }
 class StatusError extends Error {
-  source;
   constructor(source, original) {
-    super(original instanceof Error ? original.message : String(original), {
-      cause: original
-    });
+    // Best-effort message: formatting must never replace the original (#4112).
+    try {
+      var message = String(original instanceof Error ? original.message : original);
+    } catch {}
+    super(message, { cause: original });
     this.source = source;
   }
 }
@@ -149,7 +149,7 @@ const CONFIG_SYNC = 1 << 6;
 // CONFIG_HELD_CHILDREN, CONFIG_INPUTS_PUBLISHED and CONFIG_ADOPTED_UNFLUSHED
 // (transaction holds, zombies, until()'s authoritative view) went with the
 // transactions.
-// L2 (step 2): three bits, all maintained by the node's commit.
+// L2 (step 2): four bits, all maintained by the node's commit.
 /** The node has a pass awaiting commit: its live children (and `_disposal`)
  * are that pass's and were never shown — a re-pass tears them down on the
  * spot, while the frame parked on `_x._pendingFirstChild` keeps waiting for
@@ -162,6 +162,11 @@ const CONFIG_STAGED = 1 << 7;
  * parking flush they see the committed value and hold nothing, and are
  * re-derived at the landing. Set at the park seam on every staged node. */
 const CONFIG_HELD = 1 << 8;
+/** A member of the uncommitted frame a held pass built (ruling A): set at
+ * the park seam on every computed under a staged node (`holdFrame`). Never
+ * shown, it has no screen: its reads are its transaction's, whichever flush
+ * runs it (`bornInto`, #4010). Cleared by its commit. */
+const CONFIG_HELD_FRAME = 1 << 20;
 /** A15's reveal corollary (#3305): a commit published this flight's inputs
  * beneath it — the node was pending, nothing staged, when it committed — so
  * its committed value is torn against the visible frame. A render effect
@@ -186,6 +191,9 @@ const CONFIG_SLOT_NODE = 1 << 12;
  * leaf twin of REACTIVE_MANUAL_WRITE). Set by the user setter, cleared by
  * the derive's own write to the key. */
 const CONFIG_MANUAL_WRITE = 1 << 18;
+/** D-41: the staged value in `_pendingValue` is an error — an
+ * answer of the held frame, published at its landing like a value. */
+const CONFIG_STAGED_ERROR = 1 << 21;
 /** Lanes — the node carries a written guess (`optimisticWrite`): its own
  * source recomputing it, or a plain write landing on it, is the truth
  * (`supersede`). A lane's derived staging is not. */
@@ -194,15 +202,21 @@ const CONFIG_GUESS = 1 << 13;
  * pending is a question for its next pass — the verdict changed — so the
  * propagation re-derives it instead of marking it pending (as a kept-tail
  * link does, A30). Set at the window, never cleared: a reader that stopped
- * asking re-derives once and goes pending through its own read. */
-const CONFIG_VERDICT = 1 << 14;
+ * asking re-derives once and goes pending through its own read. The same
+ * bit as REACTIVE_PROBED: a pass's probe (or a read of a verdict memo,
+ * core.ts `read`) carries into the config at its end without a shift. */
+const CONFIG_VERDICT = 1 << 15;
 /** A dependency's status is a question for this node's pass, not a fact
  * about its current one: the propagation re-derives it instead of marking
  * it, for errors as for pending (as CONFIG_VERDICT). A boundary's output
  * (show the content, or the fallback) and its `on` node (boundaries.ts); a
  * promise over an expression (`resolve`/`until`, signals.ts: the pass reads
  * the error and rejects, or re-asks a pending source). */
-const CONFIG_REDERIVE = 1 << 15;
+const CONFIG_REDERIVE = 1 << 14;
+/** An answered `createDeferred` node (deferred.ts): held because a
+ * downstream hold staged its landing, its re-pass is a lagging question,
+ * not an answer, and joins no transaction (D-40). */
+const CONFIG_LAGS = 1 << 19;
 /** The reader wants the truth, not the lane's guess (`until`, signals.ts):
  * a read of displayed optimism serves the base the guess covers, makes the
  * pass no lane's, and the truth landing wakes it even when it confirms the
@@ -254,9 +268,13 @@ const CONFIG_WIDE = 1 << 26;
  * creation by dev builds only (the observe artifact mangles the option name,
  * as it does `_wide`). */
 const CONFIG_SUPERSEDES = 1 << 27;
+const STATUS_NONE = 0;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
+/** `catchHook`'s answer when the catcher is a boundary re-armed by
+ * `on` (truthy, as any catch): what it collects is its own, not the hold's. */
+const CAUGHT_REARMED = 2;
 const EFFECT_RENDER = 1;
 const EFFECT_USER = 2;
 const EFFECT_TRACKED = 3;
@@ -405,13 +423,21 @@ const diagnostics = {
     };
   }
 };
+// Flight identity → earliest declared start (see `AttributionSlot.markFlight`).
+// Weak: a stamp must not keep a settled promise alive.
+const flightOrigins = new WeakMap();
 const attributionSlot = {
   get installed() {
     return attrHooks;
   },
   withInteraction,
   withOrigin,
-  currentOrigin
+  currentOrigin,
+  markFlight(flight, startedAt = performance.now()) {
+    // Earliest wins (`undefined <= n` is false: the first mark always lands).
+    if (!(flightOrigins.get(flight) <= startedAt)) flightOrigins.set(flight, startedAt);
+  },
+  flightOrigin: flight => flightOrigins.get(flight)
 };
 const RECORDS = Symbol.for("@solidjs/signals/observe/records");
 function recordsChannel() {
@@ -513,10 +539,11 @@ function isSuppressed(entry) {
   return suppressedEvents.has(entry);
 }
 // The repair guide: the `reactivity-diagnostics` skill `solid-js` ships,
-// one section per code, at its stable GitHub path. GitHub heading anchors
-// are lowercased with underscores kept (`### SILENT_HOLD` → `#silent_hold`).
-const GUIDE_URL =
-  "https://github.com/solidjs/solid/blob/main/packages/solid/skills/reactivity-diagnostics/SKILL.md";
+// one page per code on the docs site. The slug is the code lowercased with
+// `_` → `-` (`STRICT_READ_UNTRACKED` → `strict-read-untracked`). The host
+// flips to docs.solidjs.com at stable (one search-and-replace, with the JSDoc
+// links).
+const GUIDE_URL = "https://v2.solidjs.com/reference/solid-js/diagnostics/";
 const DEV = {
   hooks,
   getChildren,
@@ -526,7 +553,7 @@ const DEV = {
   getObservers,
   report: reportDiagnostic,
   guideUrl(code) {
-    return `${GUIDE_URL}#${code.toLowerCase()}`;
+    return GUIDE_URL + code.toLowerCase().replace(/_/g, "-");
   }
 };
 /**
@@ -565,15 +592,29 @@ function ownerPath(subject) {
   }
   return path.length ? path.reverse() : undefined;
 }
+/**
+ * The innermost source location on the subject's chain: the subject's own
+ * `_loc` (a signal or computation created with `{ loc }`), else the first
+ * `_loc` up the owners — a signal hops to its registering owner, then
+ * `_parent` upward (a component root carries its JSX site). The same walk
+ * `ownerPath` makes; `undefined` when nothing on the chain was located.
+ */
+function locationOf(subject) {
+  // Owners have a `_parent` key (null on a root); a signal has none and hops
+  // to its registering `_owner` instead.
+  for (let node = subject; node; node = node._parent !== undefined ? node._parent : node._owner)
+    if (node._loc) return node._loc;
+  return undefined;
+}
 /**
  * Records a diagnostic on the structured channel (listeners, captures) and
  * returns the entry. `subject` locates it: the current reactive `context` by
  * default (right for the synchronous rule checks — they fire inside the
  * scope that misbehaved); pass the node for scheduler-time findings whose
  * ambient context is the flush, or `null` for events that have no location
- * by nature. An `ownerPath` already on the event wins over the subject walk
- * (hosts whose owners are not signals' owners compute their own). Console
- * output is a separate, dev-tier step — see `reportDiagnostic`.
+ * by nature. An `ownerPath` (or `loc`) already on the event wins over the
+ * subject walk (hosts whose owners are not signals' owners compute their
+ * own). Console output is a separate, dev-tier step — see `reportDiagnostic`.
  */
 function emitDiagnostic(event, subject = context) {
   const entry = {
@@ -590,6 +631,10 @@ function emitDiagnostic(event, subject = context) {
     const path = ownerPath(subject);
     if (path) entry.ownerPath = path;
   }
+  if (entry.loc === undefined) {
+    const loc = locationOf(subject);
+    if (loc !== undefined) entry.loc = loc;
+  }
   const live = subject ?? undefined;
   if (live !== undefined) eventSubjects.set(entry, live);
   for (const listener of diagnosticListeners) listener(entry, live);
@@ -626,12 +671,31 @@ function takeFooter(entry) {
  * `reportDiagnostic(emitDiagnostic(…))`. Weak, keyed by the entry.
  */
 const eventSubjects = new WeakMap();
+/**
+ * The `at` line of a console report: the event's `loc` as the compiler wrote
+ * it (`src/App.tsx:18:3`), or — in a browser, where a dev server serves the
+ * project root at `location.origin` — `http://localhost:5173/src/App.tsx:18:3`,
+ * which Chrome and Firefox link to the Sources panel. A path that leaves the
+ * root (`../`) or is absolute is not under the origin and prints as-is.
+ */
+function locationLine(loc) {
+  if (
+    typeof document !== "undefined" &&
+    typeof location !== "undefined" &&
+    !loc.startsWith("..") &&
+    !loc.startsWith("/")
+  )
+    return `${location.origin}/${loc}`;
+  return loc;
+}
 /**
  * The console face of a diagnostic — ONE entry per finding: the message, the
  * owner path (`in <App> › <TodoRow> › effect`) so a human can locate it, the
- * once-per-code footer as trailing lines, and — when the subject is a
- * binding effect the rendering runtime tagged — the element it writes, as a
- * second console argument (hover highlights it, click jumps to Elements).
+ * source location (`at src/App.tsx:18:3` — see `locationLine`) when a node on
+ * the chain was compiled with one, the once-per-code footer as trailing
+ * lines, and — when the subject is a binding effect the rendering runtime
+ * tagged — the element it writes, as a second console argument (hover
+ * highlights it, click jumps to Elements).
  * Severity picks the console method. Call sites report the entry
  * `emitDiagnostic` returned so the structured and console channels never
  * disagree. Dev-tier: in an observe build this is a no-op, so wiring paths
@@ -642,6 +706,7 @@ function reportDiagnostic(entry) {
   if (suppressedEvents.has(entry)) return;
   let text = entry.message;
   if (entry.ownerPath) text += `\n  in ${entry.ownerPath.join(" › ")}`;
+  if (entry.loc) text += `\n  at ${locationLine(entry.loc)}`;
   const footer = takeFooter(entry);
   if (footer) text += `\n${footer}`;
   const element = eventSubjects.get(entry)?._devElement;
@@ -1047,6 +1112,101 @@ function devCheckQuiescent(isQueuedForCommit) {
   return;
 }
 
+// Optional-module hooks: module bindings, not `GlobalQueue` statics, so a
+// bundle that never imports the installing module never assigns them — its
+// minifier folds every guarded call site (and the branch behind it) away.
+// Each module installs its own set at evaluation (pay-for-use).
+//
+// Lanes (lanes.ts; installed when `createOptimistic` — or verdict.ts — is
+// imported; every call site is behind a bit or a `passLane` nothing else sets).
+let laneReadHook = null;
+let laneStageHook = null;
+let laneOutcomeHook = null;
+let laneWriteHook = null;
+let applyGuessesHook = null;
+let laneSeamsHook = null;
+let laneCorrectionsHook = null;
+let endLanesHook = null;
+let lanesBlockedHook = null;
+function installLaneHooks(
+  read,
+  stage,
+  outcome,
+  write,
+  applyGuesses,
+  seams,
+  corrections,
+  end,
+  blocked
+) {
+  laneReadHook = read;
+  laneStageHook = stage;
+  laneOutcomeHook = outcome;
+  laneWriteHook = write;
+  applyGuessesHook = applyGuesses;
+  laneSeamsHook = seams;
+  laneCorrectionsHook = corrections;
+  endLanesHook = end;
+  lanesBlockedHook = blocked;
+}
+// Boundaries (boundaries.ts): the display consumers between an observer
+// and the root. `catch` — status from a frame reader, nearest boundary
+// first (true: caught, the root never hears of it; a clear — flags 0 —
+// settles the reader there); `fresh` — a pass that read a hold (true: a
+// first pass a loading boundary that has not shown content caught,
+// `joinPass`; `held`: the flush's hold owns it, nothing catches it);
+// `hidden` — a frame reader behind a fallback (the boundary showing it)
+// is not on screen and holds nothing; `boundarySeam` — the seam's sweep (readers
+// gone or settled without a pass reveal; an `on` re-arm resolves);
+// `heldRun` — a queued run under a fallback-showing boundary waits for
+// the reveal (true: held; the boundary re-queues it by type). The
+// synchronous first render on creation builds the subtree, attached or
+// not; its updates and the user effects wait.
+let catchHook = null;
+let freshHook = null;
+let hiddenHook = null;
+let boundarySeamHook = null;
+let heldRunHook = null;
+function installBoundaryHooks(caught, fresh, hidden, seam, heldRun) {
+  catchHook = caught;
+  freshHook = fresh;
+  hiddenHook = hidden;
+  boundarySeamHook = seam;
+  heldRunHook = heldRun;
+}
+/** Store (store/store.ts): `park` — the flush parked into `t`: the store
+ * materializes and holds the container node of every staging that had none
+ * (a staging needs the node as its home only when something can read the
+ * frame through it; a hold can); `commit` — fold the pending backings whose
+ * container nodes this flush committed (the owned-raw model's one mutation
+ * point). */
+let storeParkHook = null;
+let storeCommitHook = null;
+function installStoreHooks(park, commit) {
+  storeParkHook = park;
+  storeCommitHook = commit;
+}
+/** `affects()` marks (affects.ts): the releases at a landing and at the seam
+ * (ambient marks). */
+let releaseMarksHook = null;
+let releaseAmbientMarksHook = null;
+function installMarkHooks(release, releaseAmbient) {
+  releaseMarksHook = release;
+  releaseAmbientMarksHook = releaseAmbient;
+}
+/** Verdicts (verdict.ts). */
+let observeFlightHook = null;
+function installVerdictHooks(observeFlight) {
+  observeFlightHook = observeFlight;
+}
+/** External-source bridge (wired by enableExternalSource(); undefined while
+ * no config is active — including after _resetExternalSourceConfig()). */
+let wireExternalSourceHook = undefined;
+let externalUntrackHook = undefined;
+function setExternalHooks(wire, untrack) {
+  wireExternalSourceHook = wire;
+  externalUntrackHook = untrack;
+}
 /** Live transactions — opened, unmerged, not landed. Scanned at every seam
  * while non-empty; nothing on the plain path. */
 const transactions = [];
@@ -1185,10 +1345,7 @@ function blocked(t) {
   judge ??= t;
   // An action still running in it holds it open (action.ts). Its lanes
   // (lanes.ts): a lane under `t` blocks it while blocked itself.
-  const r =
-    t._open !== 0 ||
-    blockedBy(t._nodes, t) ||
-    (!!GlobalQueue._lanesBlocked && GlobalQueue._lanesBlocked(t));
+  const r = t._open !== 0 || blockedBy(t._nodes, t) || !!lanesBlockedHook?.(t);
   judge = prev;
   return r;
 }
@@ -1262,7 +1419,7 @@ function blockedBy(nodes, owner, own = false) {
       // shows nothing — a mount the frame has not revealed — and holds
       // nothing.
       if (
-        (r._type === EFFECT_RENDER ||
+        ((r._type === EFFECT_RENDER && r._statusFlags & STATUS_PENDING) ||
           r._flags & REACTIVE_FRAME_READ ||
           (r._config & CONFIG_REDERIVE && r._statusFlags === STATUS_PENDING)) &&
         (s._gen === r._depGen || r._x?._error != null) &&
@@ -1283,10 +1440,7 @@ function blockedBy(nodes, owner, own = false) {
  * everything under it, so a reader there is not on screen and holds
  * nothing — boundaries.ts). */
 function onScreen(r, t) {
-  return (
-    !(r._flags & REACTIVE_ZOMBIE && removalStagedBy(r, t)) &&
-    !(GlobalQueue._hidden && GlobalQueue._hidden(r))
-  );
+  return !(r._flags & REACTIVE_ZOMBIE && removalStagedBy(r, t)) && !hiddenHook?.(r);
 }
 /** A15 (#3463): a reader whose removal is staged — a zombie, parked by a
  * pass awaiting its commit — is still on screen and live for every hold,
@@ -1296,13 +1450,8 @@ function onScreen(r, t) {
  * the nearest non-zombie ancestor. */
 function removalStagedBy(r, t) {
   let o = r;
-  while (o !== null && o._flags & REACTIVE_ZOMBIE) o = o._parent;
-  return (
-    o !== null &&
-    (o._config & CONFIG_HELD) !== 0 &&
-    o._x?._transaction != null &&
-    txOf(o) === resolveTx(t)
-  );
+  while (o?._flags & REACTIVE_ZOMBIE) o = o._parent;
+  return o?._config & CONFIG_HELD && o._x?._transaction != null && txOf(o) === resolveTx(t);
 }
 /** Unchanged passes this flush whose stale dependency tail awaits the
  * flush's verdict (A30, #3469): trimmed when the flush commits, kept when
@@ -1355,10 +1504,26 @@ function list(n, t) {
 function holdFrame(owner, t) {
   for (let c = owner._firstChild; c !== null; c = c._nextSibling) {
     if (c._x?._transaction?._lane) continue;
-    if (c._fn !== undefined && !(c._config & CONFIG_HELD)) holdNode(c, t);
+    if (c._fn !== undefined) {
+      if (!(c._config & CONFIG_HELD)) holdNode(c, t);
+      c._config |= CONFIG_HELD_FRAME;
+    }
     holdFrame(c, t);
   }
 }
+/** The nodes under `owner` a transaction other than `t` holds (boundaries.ts:
+ * what an earlier hold staged under a re-armed boundary). */
+function heldUnder(owner, t, fn) {
+  for (let c = owner._firstChild; c !== null; c = c._nextSibling) {
+    if ((c._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && txOf(c) !== t) fn(c);
+    heldUnder(c, t, fn);
+  }
+}
+/** `n` leaves the hold it was staged in: its next pass publishes mainline. */
+function unhold(n) {
+  n._x._transaction = null;
+  n._config &= ~CONFIG_HELD;
+}
 const dirtyQueue = {
   _heap: new Array(2000).fill(undefined),
   _marked: false,
@@ -1551,7 +1716,7 @@ class GlobalQueue {
     // Lanes: an ended action body judges its guesses now that their passes
     // have run (lanes.ts); a correction's re-derivations run in one more
     // pure round — the parent's flights before the parent is judged below.
-    if (GlobalQueue._laneCorrections?.()) runHeap(dirtyQueue, GlobalQueue._update);
+    if (laneCorrectionsHook?.()) runHeap(dirtyQueue, GlobalQueue._update);
     const joined = flushTransaction;
     flushTransaction = null;
     // The frame's verdict is in: the guesses written since the last seam
@@ -1559,7 +1724,7 @@ class GlobalQueue {
     // parents a nested lane to it), or are dropped — the frame commits, and
     // there is nothing to be optimistic over. Their passes run next round;
     // a parent landing at this very seam ends the lane before they do.
-    GlobalQueue._applyGuesses?.(joined);
+    applyGuessesHook?.(joined);
     // A lane's own flush (its flight landing, its reveal) parks nothing: the
     // lane's work reached it per pass; the frame's plain writes commit.
     // (Resolved: a guess over another transaction's guess merged them.)
@@ -1599,10 +1764,12 @@ class GlobalQueue {
           if (
             n._pendingValue !== NOT_PENDING &&
             !(n._statusFlags & (STATUS_PENDING | STATUS_UNINITIALIZED)) &&
-            n._equals &&
-            n._equals(n._value, n._pendingValue) &&
             n._x?._pendingFirstChild == null &&
-            n._x?._pendingDisposal == null
+            n._x?._pendingDisposal == null &&
+            // The comparator last: a pass that created children (an object
+            // owning a fresh async memo, #4111) must not have it read them.
+            // A NotReady read there is a change (`isSame`).
+            isSame(n, n._value, n._pendingValue)
           ) {
             n._pendingValue = NOT_PENDING;
             n._config &= ~CONFIG_STAGED;
@@ -1616,7 +1783,7 @@ class GlobalQueue {
         if (n._config & CONFIG_STAGED) holdFrame(n, t);
       }
       pendingNodes.length = 0;
-      GlobalQueue._storePark?.(t);
+      storeParkHook?.(t);
       // (This flush's runs are stashed with `t` below — after the landings,
       // so a `t` that lands at this very seam runs them first, ahead of
       // the runs it held from earlier flushes.)
@@ -1626,13 +1793,17 @@ class GlobalQueue {
       // through like the same read outside): it re-runs now, as the
       // holder's verdict lane's work — before the lane seams, which reveal
       // it (nothing commits this seam that could dispose it).
-      const zombies = deferredZombies.splice(0).sort((a, b) => a._height - b._height);
-      for (let i = 0; i < zombies.length; i++)
-        if (
-          (zombies[i]._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE)) === REACTIVE_ZOMBIE &&
-          zombies[i]._config & CONFIG_VERDICT
-        )
-          recompute(zombies[i]);
+      // (Verdict readers exist only with the verdict engine installed.)
+      const zombies = deferredZombies.splice(0);
+      if (observeFlightHook) {
+        zombies.sort((a, b) => a._height - b._height);
+        for (let i = 0; i < zombies.length; i++)
+          if (
+            (zombies[i]._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE)) === REACTIVE_ZOMBIE &&
+            zombies[i]._config & CONFIG_VERDICT
+          )
+            recompute(zombies[i]);
+      }
       // The unchanged passes' tails stay linked (A30, #3469): their inputs
       // are held, and the committed frame still derives from them — no trim.
     } else {
@@ -1663,14 +1834,16 @@ class GlobalQueue {
     // The passes that read this frame's stagings as the screen read held
     // writes if it parked: the lane seam re-derives them on the committed
     // world (a lane's runs wait this round).
-    GlobalQueue._laneSeams?.(t !== null ? stagedReaders : null);
-    if (stagedReaders.length) stagedReaders.length = 0;
+    if (laneSeamsHook) {
+      laneSeamsHook(t !== null ? stagedReaders : null);
+      if (stagedReaders.length) stagedReaders.length = 0;
+    }
     this._queues = [[], []];
     for (let k = transactions.length - 1; k >= 0; k--) {
       const u = transactions[k];
       if (blocked(u)) continue;
       transactions.splice(k, 1);
-      GlobalQueue._endLanes?.(u);
+      endLanesHook?.(u);
       land(u);
       // A landing's commits can dispose a zombie a transaction judged above
       // was blocked on (#3463: live "until the commit that disposes it") —
@@ -1679,12 +1852,13 @@ class GlobalQueue {
     }
     // The store folds the pending backings whose container nodes committed
     // — this flush's, or a landing's (store/store.ts installs it).
-    GlobalQueue._storeCommit?.();
+    storeCommitHook?.();
     // Marks declared outside a transaction: the flush that carried them
     // parked (something async below) — the window is the frame's, the marks
     // are its transaction's; else they release at the seam, verdict-only,
     // nothing to show (affects.ts).
-    GlobalQueue._releaseAmbientMarks?.(t !== null && transactions.indexOf(t) !== -1 ? t : null);
+    const live = t && liveTx(t);
+    releaseAmbientMarksHook?.(live);
     // The effect phase: lane work first (displayed ahead of the frame), then
     // this flush's runs, then the runs the landings held from earlier
     // flushes — as one pass would have queued them (#3540: a shell
@@ -1692,18 +1866,17 @@ class GlobalQueue {
     // write; #3528: a display-ahead swap before the count it is shown
     // beside). A parked frame's runs wait with its transaction instead: the
     // effect phase applies a committed frame.
-    const u = t && liveTx(t);
-    const parked = u !== null;
+    const parked = live !== null;
     // Attribution hook: this flush found its transaction incomplete — its
     // writes stay staged, its runs are stashed below. Before the effect
     // phase (the lanes' display-ahead runs are the visible acknowledgers);
     // `holdEnd` fires after it (`flush`).
     if (parked && attrHooks !== null) {
-      attrHooks.holdStart(u);
+      attrHooks.holdStart(live);
       holding = true;
     }
     for (let i = 0; i < 2; i++) {
-      if (parked) append(u._queues[i], own[i]);
+      if (parked) append(live._queues[i], own[i]);
       // The plain flush — no reveal, no landing, not parked — has nothing to
       // order around its own runs: they are the queue as they stand (the
       // same array, not a copy; `run` takes it whole). Every other seam
@@ -1723,7 +1896,7 @@ class GlobalQueue {
     }
     // Boundaries: readers that settled, landed or died this flush are
     // dropped; a fallback with none left reveals next round.
-    GlobalQueue._boundarySeam?.();
+    boundarySeamHook?.();
   }
   run(type) {
     const effects = this._queues[type - 1];
@@ -1755,7 +1928,7 @@ class GlobalQueue {
    * first: a fallback catches what is not ready under it, and the root
    * never hears of it. */
   notify(node, mask, flags, error) {
-    if (GlobalQueue._catch && GlobalQueue._catch(node, flags & mask, error)) return true;
+    if (catchHook?.(node, flags & mask, error)) return true;
     if (mask & STATUS_PENDING) {
       if (flags & STATUS_PENDING) {
         if (_enforceLoadingBoundary) _hitUnhandledAsync = true;
@@ -1792,8 +1965,11 @@ class GlobalQueue {
 function reruns(u) {
   for (let i = 0; i < u._reruns.length; i++) {
     const r = u._reruns[i];
-    if (r._flags & REACTIVE_DISPOSED) continue;
-    if (r._flags & REACTIVE_FRAME_READ) {
+    // 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) {
       r._flags &= ~REACTIVE_FRAME_READ;
       r._modified = false;
       // Its frame is replaced by the re-derivation: a run one of its
@@ -1811,7 +1987,7 @@ function land(u) {
   // (`_nodes` still lists them).
   if (attrHooks !== null) attrHooks.transitionSettled(u);
   reruns(u);
-  if (u._marks !== null) GlobalQueue._releaseMarks(u._marks);
+  if (u._marks !== null) releaseMarksHook(u._marks);
   // Old children die in the commits (cleanups first), then the stashed
   // effects run ahead of this flush's own. A node a lane took over since
   // (a guess written over the staged truth) is the lane's to land.
@@ -1821,6 +1997,10 @@ function land(u) {
     n._x._transaction = null;
     commitPendingNode(n);
   }
+  // A cleanup those commits ran that wrote a node `u` still held joined
+  // `u`, which has left `transactions`: the write is this landing's, and
+  // the next flush must not park in it (#4089).
+  if (flushTransaction === u) flushTransaction = null;
   releaseQueues(u);
 }
 /** The held runs join this flush's effect phase after its own runs (the
@@ -1940,8 +2120,20 @@ function commitPendingNode(n) {
   // commit beneath a flight publishes its inputs (A15 reveal corollary,
   // #3305): a reveal of it must observe, not show the pre-flight value.
   const inFlight = n._pendingValue === NOT_PENDING && (c._statusFlags & STATUS_PENDING) !== 0;
-  n._config = inFlight ? (n._config & ~CONFIG_HELD) | CONFIG_INPUTS_PUBLISHED : n._config & -1409;
-  if (n._pendingValue !== NOT_PENDING) {
+  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;
+  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
+  // see it in the cycle after this seam: a tracked re-read there is not a
+  // retry (`read`), or a boundary re-derived by it would retry it forever.
+  if (err) {
+    const e = n._pendingValue;
+    n._pendingValue = NOT_PENDING;
+    n._time = clock + 1;
+    notifyStatus(c, STATUS_ERROR, e);
+  } else if (n._pendingValue !== NOT_PENDING) {
     n._value = n._pendingValue;
     n._pendingValue = NOT_PENDING;
     // A node born staged (recompute) initializes at this commit.
@@ -2432,13 +2624,15 @@ function getOwner() {
 /**
  * Low-level: registers `fn` as a disposal callback on the current owner.
  * Most code should use `onCleanup()` from `solid-js`, which adds dev-mode
- * checks. `cleanup()` is the unchecked primitive used by internals.
+ * checks. `cleanup()` is the unchecked primitive used by internals; `owner`
+ * (internal) targets a specific owner's disposal list instead of the ambient
+ * one.
  */
-function cleanup(fn) {
-  if (!context) return fn;
-  if (!context._disposal) context._disposal = fn;
-  else if (Array.isArray(context._disposal)) context._disposal.push(fn);
-  else context._disposal = [context._disposal, fn];
+function cleanup(fn, owner = context) {
+  if (!owner) return fn;
+  if (!owner._disposal) owner._disposal = fn;
+  else if (Array.isArray(owner._disposal)) owner._disposal.push(fn);
+  else owner._disposal = [owner._disposal, fn];
   return fn;
 }
 /**
@@ -2475,12 +2669,18 @@ function createOwner(options) {
   const parent = context;
   const transparent = options?.transparent ?? false;
   // Prod and observe boilerplates (see core.ts computed()). The observe
-  // literal carries the `_name` slot the rendering layer fills with the
-  // component label (`owner._name = "<App>"`) — a slot, so labelling a root
-  // is a plain store rather than a shape fork between labelled and plain roots.
+  // literal carries the `_name` and `_loc` slots the rendering layer fills
+  // with the component label and JSX site (`owner._name = "<App>"`,
+  // `owner._loc = "src/App.tsx:3:5"`) — slots, so labelling a root is a
+  // plain store rather than a shape fork between labelled and plain roots.
   const owner = {
     id: inheritId(options, transparent, parent),
     _config: transparent ? CONFIG_TRANSPARENT : 0,
+    // Present from birth: disposeChildren marks death here on roots too, and
+    // a first store of a missing property is a shape transition plus a
+    // properties-store allocation per root — on a 100×4 table teardown that
+    // was 12 KB and most of disposal's time (2026-10-17).
+    _flags: REACTIVE_NONE,
     _root: true,
     _parentComputed: parent?._root ? parent._parentComputed : parent,
     _firstChild: null,
@@ -2492,7 +2692,8 @@ function createOwner(options) {
     _x: null,
     _parent: parent,
     dispose: disposeRootSelf,
-    _name: undefined
+    _name: undefined,
+    _loc: undefined
   };
   if (parent && parent._config & CONFIG_CHILDREN_FORBIDDEN) {
     emitDiagnostic({
@@ -2544,11 +2745,14 @@ function createOwner(options) {
  * const detached = runWithOwner(null, () => createRoot(d => d));
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/owner-introspection/create-root
  */
 function createRoot(init, options) {
   const owner = createOwner(options);
-  return runWithOwner(owner, () => init(() => owner.dispose()));
+  // 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).
+  return runWithOwner(owner, () => init(disposeRootSelf.bind(owner, true)));
 }
 
 /** The store's shared slot-node release handler (store/store.ts installs it
@@ -2581,12 +2785,14 @@ function unlinkSubs(link) {
       // read. The settle path runs this same last-one-out check when that
       // observer releases (the untracked-read dormancy sweep guards on
       // pending identically).
+      // During a pass's teardown of its unfinished frame, the release waits
+      // for the pass to end (`deferredReleases`, #4142).
       const c = dep;
       c._fn &&
         c._config & CONFIG_AUTO_DISPOSE &&
         !(c._flags & REACTIVE_ZOMBIE) &&
         !(c._statusFlags & STATUS_PENDING) &&
-        unobserved(c);
+        (deferredReleases ? deferredReleases.push(c) : unobserved(c));
     }
   }
   return nextDep;
@@ -2615,6 +2821,17 @@ function clearDeps(el) {
   el._deps = null;
   el._depsTail = null;
 }
+/**
+ * Last-one-out releases held back while a pass tears down the frame of an
+ * earlier pass that never committed (#4142). The pass is about to rebuild
+ * the same children, which read the same lazy nodes again. Released on the
+ * spot, a lazy async memo whose only reader was the old frame's child memo
+ * was torn down, re-ran on the new child's read, went pending, and the cycle
+ * repeated forever. `recompute` collects them around that teardown and
+ * releases what is still unobserved when the pass ends.
+ */
+let deferredReleases = null;
+const deferReleases = list => (deferredReleases = list);
 function unobserved(el) {
   deleteFromHeap(el, dirtyQueue);
   clearDeps(el);
@@ -2816,6 +3033,43 @@ function releaseSettledDependents(el) {
 // (releaseSettledDependents shape): identity holders can sit below an
 // intermediate whose own error state has since been scrubbed or replaced
 // (e.g. an error boundary's tree node).
+/** D-41: an error a pass of a held node found is an answer of
+ * that frame — it ends the wait like a value and shows when a value would.
+ * Staged like one: `_pendingValue` carries it (CONFIG_STAGED_ERROR), readers
+ * in the hold derive from it (`serve` throws it), and the commit publishes
+ * it through the ordinary error path (`commitPendingNode` → `notifyStatus`),
+ * dependents included. Not for a lane pass, nor a node with no shown value
+ * (born held — its error has no frame to wait behind): those publish now,
+ * as before. Returns whether the error was staged. */
+function stageError(el, error, inPass) {
+  // Held, or — for a pass's own throw — derived from a staging of a flush
+  // (REACTIVE_STAGED_READ is this pass's; a landing after the pass cannot
+  // read it, the flush it read a staging of has committed or parked since).
+  // Staged whether or not the flush has joined a hold yet: a pass that runs
+  // before its async sibling joins is the seam's to decide, like a value
+  // (#4109). A flush that parks nothing publishes it at its commit (S-38).
+  if (
+    !(
+      el._config & CONFIG_HELD ||
+      (inPass && el._flags & REACTIVE_STAGED_READ && globalQueue._running)
+    ) ||
+    passLane
+  )
+    return false;
+  // The node answered (an error ends the wait — no longer pending, nor
+  // blocked); a shown error stays its display until the commit.
+  clearPendingSources(el);
+  if (el._x) el._x._blocked = false;
+  if (!((el._statusFlags &= STATUS_ERROR | STATUS_UNINITIALIZED) & STATUS_ERROR))
+    setPendingError(el);
+  el._pendingValue = error instanceof StatusError ? error : new StatusError(el, error);
+  el._config |= CONFIG_STAGED | CONFIG_STAGED_ERROR;
+  // Readers parked on the flight re-run and derive from the staging; the
+  // verdict readers the walk wakes need a flush (#4106).
+  settlePendingSource(el);
+  schedule();
+  return true;
+}
 function settleErroredDependents(el, error) {
   let scheduled = false;
   const visited = new Set();
@@ -3062,7 +3316,11 @@ function handleAsync(
       el._time = clock;
       return;
     }
-    notifyStatus(el, stillPending ? STATUS_PENDING : STATUS_ERROR, error);
+    // D-41: a held node's error is staged (`stageError`). A derived store's
+    // readers learn its error through the family, not the derive's
+    // dependents: it publishes now.
+    if (stillPending || setter || !stageError(el, error))
+      notifyStatus(el, stillPending ? STATUS_PENDING : STATUS_ERROR, error);
     // A NotReady rejection is a landing into another pending source. The
     // rejected flight will never settle its self entry, so transfer ownership
     // after notifyStatus has propagated the replacement source.
@@ -3080,7 +3338,7 @@ function handleAsync(
     // skip this stale async result — the upcoming flush will recompute the node
     // with the new value, creating a fresh Promise that supersedes this one.
     if (el._flags & REACTIVE_DIRTY) return;
-    const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
+    const wasUninitialized = el._statusFlags & STATUS_UNINITIALIZED;
     landStatus(el);
     // Attribution hook: lets the engine snapshot state before the landing
     // branches, so it can tell whether the plain path's setSignal committed a
@@ -3093,22 +3351,27 @@ function handleAsync(
         handleError(error);
         return;
       }
+      // A store derive's landing commits through its setter: unheld, the
+      // shown error leaves now; held, at the derive's commit.
+      if (!(el._config & CONFIG_HELD)) el._x._shownError = undefined;
       if (wasUninitialized) landStatus(el, true);
+      // Attribution hook: this path landed through the setter (derived
+      // stores, projections), which does not go through setSignal, so the
+      // plain branch's asyncEnd never ran and the flight stayed open — the
+      // next flight counted a committed answer as abandoned (#3947).
+      // direct=true: asyncEnd finalizes either way and stamps an async write
+      // only if the commit moved `_value`/`_time` or parked `_pendingValue`.
+      // A store setter does not move this node's `_value`, so no stamp is
+      // recorded and waterfall chaining through derived stores stays
+      // unmeasured. Outside the try (#2883 — see attribution-hooks.ts).
+      if (attrHooks !== null) attrHooks.asyncEnd(el, undefined, value, true);
     } else {
       // CARVE 2: the override-covered landing (hold + A18 supersession) and the
       // lane-routed landing (derived override, lane effect queue) went with
-      // the optimistic engine; every landing is the plain setSignal. A first
-      // answer born into a hold still live lands into it (A29, #3800).
-      let t = el._x._bornIn;
-      el._x._bornIn = null;
-      if (wasUninitialized && t && (t = liveTx(t))) holdNode(el, t);
-      try {
-        setSignal(el, () => value);
-      } catch (e) {
-        // Same containment as above: setSignal's comparator throw is the only
-        // pre-commit failure here, and there is no user callsite to throw to.
-        notifyStatus(el, STATUS_ERROR, e);
-      }
+      // the optimistic engine; every landing is the plain setSignal. A node
+      // already held stages its answer into that hold (`setSignal`). Its
+      // comparator throw is contained there (`isSame`, A3).
+      setSignal(el, () => value);
       // Attribution hook: this path landed through setSignal, whose write
       // hook already saw any committed change — direct=false lets the engine
       // reclassify that write as an async landing iff it actually committed.
@@ -3153,15 +3416,14 @@ function handleAsync(
   // close registration uses the ambient owner; and DEFERRED (the flattening
   // path — a thenable resolved to an iterable in a later microtask), where
   // there is no caller to serve and no ambient owner: sync-settled steps
-  // write through asyncWrite, and close registration goes through the slot
-  // the thenable branch pre-registered while it still owned the context.
-  // Returns whether a sync answer landed (first yield or empty completion) —
-  // meaningful only in the live posture.
-  const consumeIterator = (source, registerClose) => {
+  // write through asyncWrite, and close registration targets `owner` (el
+  // itself) directly. Returns whether a sync answer landed (first yield or
+  // empty completion) — meaningful only in the live posture.
+  const consumeIterator = (source, owner) => {
     const it = source[Symbol.asyncIterator]();
     let hadValue = false;
     let completed = false;
-    let initialRead = !registerClose;
+    let initialRead = !owner;
     const close = () => {
       if (completed) return;
       completed = true;
@@ -3170,7 +3432,7 @@ function handleAsync(
         if (isThenable(returned)) returned.then(undefined, () => {});
       } catch {}
     };
-    registerClose ? registerClose(close) : cleanup(close);
+    cleanup(close, owner);
     // Flight-identity cancellation (#3122): the registration above is the
     // owner-death backstop; the teardown slot fires at the _inFlight release
     // sites so supersede stops this stream immediately.
@@ -3178,8 +3440,15 @@ function handleAsync(
     // Release check before each next pull: an unobserved lazy node must tear
     // down (its close above runs via disposal, closing the iterator) instead
     // of pumping the stream forever with zero subscribers (#2935).
+    // Later pulls run from an async continuation with no compute catch above
+    // them: a throw invoking the protocol (next(), the step's then) settles
+    // as this flight's error instead of escaping as a rejection (#4112).
     const iterateOrRelease = () => {
-      if (!settleAutodispose()) iterate();
+      try {
+        if (!settleAutodispose()) iterate();
+      } catch (e) {
+        handleError(e);
+      }
     };
     const iterate = () => {
       let syncResult,
@@ -3264,7 +3533,7 @@ function handleAsync(
   // stream itself rather than settling on the iterable object. One level
   // only: A+ `then` already collapses nested thenables, so the resolved
   // value is never itself a thenable.
-  const flattenIfIterable = (value, registerClose) => {
+  const flattenIfIterable = (value, owner) => {
     let innerIterator = false;
     if (typeof value === "object" && value !== null) {
       untrack(() => {
@@ -3272,8 +3541,9 @@ function handleAsync(
       });
     }
     if (!innerIterator) return false;
-    const landed = consumeIterator(value, registerClose);
-    if (!registerClose) liveLanded = landed;
+    syncValue = undefined;
+    const landed = consumeIterator(value, owner);
+    if (!owner) liveLanded = landed;
     return true;
   };
   if (thenable) {
@@ -3281,29 +3551,32 @@ function handleAsync(
       rejected = false,
       syncError,
       isSync = true;
-    // Close registration for the flattening path. Consumption starts in a
-    // microtask where the ambient owner is gone (or worse, someone else's),
-    // so `cleanup()` can't be used — the close targets el's disposal list
-    // directly, exactly where a live cleanup() during this recompute would
-    // have put it. Only a flight that actually flattens becomes
-    // disposal-bearing.
-    const registerDeferredClose = fn => {
-      if (!el._disposal) el._disposal = fn;
-      else if (Array.isArray(el._disposal)) el._disposal.push(fn);
-      else el._disposal = [el._disposal, fn];
-    };
     watchAsyncTail(el, result).then(
       v => {
         if (isSync) {
           syncValue = v;
           resolved = true;
-        } else if (
-          el._x?._inFlight === result &&
-          !(el._flags & REACTIVE_DISPOSED) &&
-          flattenIfIterable(v, registerDeferredClose)
-        );
-        else {
-          asyncWrite(v);
+        } else {
+          // Flattening consumes the stream as the value: each yield lands
+          // through asyncWrite under this flight's identity; the first one
+          // clears pending exactly like a plain promise resolution would.
+          // Disposed nodes never start a pump (their disposal list already
+          // ran, so nothing could close the iterator). Consumption starts in
+          // a microtask where the ambient owner is gone, so the close
+          // registers on el's own disposal list. Iterator setup here has no
+          // compute catch above it: a protocol throw settles as this
+          // flight's error (#4112).
+          try {
+            if (
+              el._x?._inFlight === result &&
+              !(el._flags & REACTIVE_DISPOSED) &&
+              flattenIfIterable(v, el)
+            )
+              return;
+            asyncWrite(v);
+          } catch (e) {
+            handleError(e);
+          }
           settleAutodispose();
         }
       },
@@ -3407,6 +3680,8 @@ function notifyStatus(el, status, error, blockStatus) {
   // (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`).
+      if (el._statusFlags & STATUS_ERROR) el._x._shownError = el._x._error;
       addPendingSource(el, pendingSource);
       el._statusFlags = STATUS_PENDING | (el._statusFlags & STATUS_UNINITIALIZED);
       // Preserve the current source on this propagation so readers park on
@@ -3486,7 +3761,8 @@ function propagateStatus(el, status, error, downstreamBlockStatus) {
       if (
         passLane === null &&
         (sub._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD &&
-        globalQueue._running
+        globalQueue._running &&
+        !freshHook?.(sub, pendingSource._time === clock)
       )
         joinFuture(txOf(sub));
       return;
@@ -3501,7 +3777,7 @@ function propagateStatus(el, status, error, downstreamBlockStatus) {
       // the dependent's pending is the lane's own flight (`laneStage`).
       {
         // (No answer: a pending propagation leaves a written guess a guess.)
-        if (passLane !== null) GlobalQueue._laneStage(sub, passLane, true, el);
+        if (laneStageHook && passLane !== null) laneStageHook(sub, passLane, true, el);
         else {
           queuePendingNode(sub);
           // A15 (#3443): pending propagates onto a held memo without
@@ -3543,8 +3819,29 @@ GlobalQueue._update = el => {
   // (REACTIVE_LANE_DIRTY — a lane shows ahead of any park): it runs now, as
   // the lane's work, for the reveal this seam (#3463).
   else if (el._flags & REACTIVE_ZOMBIE && !(el._flags & REACTIVE_LANE_DIRTY)) deferZombie(el);
-  else recompute(el);
+  // A lane frame's member (parked by a lane pass, #3698) follows mainline
+  // writes only: a lane's dirty on it is cancelled — the lane's apply retires
+  // it, and the pass that replaced it already decided what that screen shows
+  // (#4137: a `<Show>` branch withdrawn by its own lane re-ran on a falsy
+  // condition).
+  // (Lanes exist only with the lane engine installed: folded away without.)
+  else if (laneStageHook && el._flags & REACTIVE_ZOMBIE && laneFrameMember(el)) {
+    deleteFromHeap(el, dirtyQueue);
+    el._flags &= -65540;
+  } else recompute(el);
 };
+/** The zombie's frame was parked by lane work: the nearest non-zombie owner
+ * (the one whose pass parked it) carries a lane's derived value — or, an
+ * effect (no lane value: `laneStage`), is listed in a lane (an `insert()`
+ * hole's render effect). */
+function laneFrameMember(el) {
+  let o = el._parent;
+  while (o._flags & REACTIVE_ZOMBIE) o = o._parent;
+  return (
+    (o._config & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE ||
+    (o._type && o._x?._transaction?._lane)
+  );
+}
 GlobalQueue._dispose = disposeChildren;
 const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE =
   "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
@@ -3579,6 +3876,10 @@ const REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE =
 let tracking = false;
 let context = null;
 let snapshotCaptureActive = false;
+/** The lane at the root of the running chain of first passes: the lane whose
+ * pass created the chain's first node (a mount), inherited by every first
+ * pass nested under it, whose seats are mainline (`recompute`, #4166). */
+let laneRoot;
 let snapshotSources = null;
 function ownerInSnapshotScope(owner) {
   while (owner) {
@@ -3638,6 +3939,7 @@ function recompute(el, create = false) {
   // §12d: any recompute can clean a marked subscriber — invalidate skips.
   bumpNotifyEpoch();
   const isEffect = el._type;
+  let released;
   // Lanes (plan sec. 28): the seat of a pass is its node's. A node carrying a lane's
   // derived value runs as the lane's whoever dirtied it — a sync write, a
   // boundary reset, a frame rerun — so its children and its result are the
@@ -3653,18 +3955,27 @@ function recompute(el, create = false) {
   // derivation's pass into the lane (`read`); a leaf's never moves.
   // 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.
   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(
-    (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 &&
-          prevLane?._parent._verdict != prevLane &&
-          (creatorPass(context)?._flags ?? 0) & REACTIVE_RECOMPUTING_DEPS
-        ? prevLane
-        : null
+    !laneStageHook
+      ? null
+      : (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 &&
+            prevLane?._parent._verdict != prevLane &&
+            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
@@ -3691,17 +4002,30 @@ function recompute(el, create = false) {
     // joins all the same. Not a render effect (rule 3): it is the frame.
     // Re-run outside its transaction's flush it publishes mainline — the
     // value it staged there is superseded (`frameRead` remembers it for the
-    // landing). A frame born into the transaction (uninitialized: never run,
-    // A29) keeps staging: live writes keep it current, it effects at the
-    // swap (ruling A).
+    // landing). A frame born into the transaction (`bornInto`: never run,
+    // A29, or mounted by a pass of it still awaiting its commit, #4010) keeps
+    // staging: live writes keep it current, it effects at the swap (ruling
+    // A).
+    // 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
       // a sync write (#3460). The pass is the lane's if it reads the lane's
       // world (`read`), and has left it otherwise.
-      if (tx._lane);
-      else if (isEffect !== EFFECT_RENDER && !(el._config & CONFIG_VERDICT)) joinPassTx(tx);
-      else if (tx !== flushTransaction && !(el._statusFlags & STATUS_UNINITIALIZED)) {
+      // An answered deferred node's re-pass is a lagging question (D-40):
+      // it joins nothing, so the write that reached it commits mainline.
+      if (tx._lane || el._config & CONFIG_LAGS);
+      else if (isEffect !== EFFECT_RENDER && !(el._config & CONFIG_VERDICT))
+        joinPassTx(tx, freshHook?.(el, el._statusFlags & STATUS_UNINITIALIZED));
+      else if (
+        tx !== flushTransaction &&
+        !(el._statusFlags & STATUS_UNINITIALIZED || el._config & CONFIG_HELD_FRAME)
+      ) {
         // Published mainline, it is not held: the frame this pass builds is
         // replaced on the spot (#3404) — this flush's commit retires the
         // committed frame the held pass had parked (`commitPendingNode`),
@@ -3717,8 +4041,20 @@ function recompute(el, create = false) {
     // frame parked before it stays parked. Otherwise they ARE the frame:
     // park them until this pass commits. Tracked effects run after the seam
     // and own nothing to park.
-    if (isEffect === EFFECT_TRACKED || el._config & CONFIG_STAGED) disposeChildren(el);
-    else if (el._firstChild !== null || el._disposal !== null) parkChildren(el);
+    if (isEffect === EFFECT_TRACKED || el._config & CONFIG_STAGED) {
+      // A lazy node only those children read is released when this pass
+      // ends, if the pass doesn't read it again (#4142).
+      const prev = deferredReleases;
+      deferReleases((released = []));
+      disposeChildren(el);
+      deferReleases(prev);
+    } else if (el._firstChild !== null || el._disposal !== null) parkChildren(el);
+    // An error a pass staged (D-41) is replaced by this pass's answer: a
+    // value, a flight, or an error of its own (#4109, #4145).
+    if (el._config & CONFIG_STAGED_ERROR) {
+      el._pendingValue = NOT_PENDING;
+      el._config ^= CONFIG_STAGED_ERROR;
+    }
     clearSignals(el);
   }
   const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
@@ -3735,6 +4071,8 @@ function recompute(el, create = false) {
   // settlePendingSource walk never runs for a landing that was preempted
   // (#3181).
   const wasPendingSource = el._x?._pendingSources?.has(el);
+  // D-41: this pass's error is staged, not published (`stageError`).
+  let stagedErr = 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).
@@ -3749,19 +4087,20 @@ function recompute(el, create = false) {
   // frame, and the splice/reawaken paths key off it. A zombie reruns for
   // live writes until the commit that disposes it, so every per-pass wipe
   // — here, the finally below, updateIfNecessary — carries it (#3543).
-  el._flags = REACTIVE_RECOMPUTING_DEPS | (el._flags & REACTIVE_ZOMBIE);
+  el._flags = REACTIVE_RECOMPUTING_DEPS | (el._flags & (REACTIVE_ZOMBIE | REACTIVE_REASK));
   el._time = clock;
-  // The pass's previous value: its staging, else the lane's value for a
-  // lane's node (lanes.ts), else the committed one.
+  // The pass's previous value: its staging, else a lane node's lane value
+  // when it has one (lanes.ts), else the committed one.
   let value =
     el._pendingValue !== NOT_PENDING
       ? el._pendingValue
-      : el._config & CONFIG_OVERRIDE
+      : el._config & CONFIG_OVERRIDE && el._x._lane !== NOT_PENDING
         ? el._x._lane
         : el._value;
   let oldHeight = el._height;
   let missedWake = false;
-  // L2: did this pass read the future (REACTIVE_JOINED, set by read)?
+  // L2: did this pass read the future (REACTIVE_JOINED, set by read) — or,
+  // a lane's mount, a staging of this flush (#3851, #4166)?
   let joined = false;
   let prevTracking = tracking;
   let prevStrictRead = false;
@@ -3806,11 +4145,15 @@ function recompute(el, create = false) {
       // retry can actually run.
       parkLoadingWindow(el, e);
     } else {
-      if (notReady) ext(el)._blocked = true;
-      notifyStatus(el, notReady ? STATUS_PENDING : STATUS_ERROR, e);
-      // The replacement source is fully propagated now. If no new flight
-      // re-owned self, retire the superseded flight and its dependent copies.
-      if (notReady && wasPendingSource && !el._x?._inFlight) settlePendingSource(el);
+      // D-41: a pass of a held node, or one that read a staging of this
+      // flush, stages its error (`stageError`).
+      if (notReady || !(stagedErr = stageError(el, e, true))) {
+        if (notReady) ext(el)._blocked = true;
+        notifyStatus(el, notReady ? STATUS_PENDING : STATUS_ERROR, e);
+        // The replacement source is fully propagated now. If no new flight
+        // re-owned self, retire the superseded flight and its dependent copies.
+        if (notReady && wasPendingSource && !el._x?._inFlight) settlePendingSource(el);
+      }
       // A re-park drops what the earlier pass carried (#3456): a source this
       // pass no longer reaches — its branch switched, or a fresh flight
       // replaced the inputs' pending with its own — stays copied onto
@@ -3818,14 +4161,16 @@ function recompute(el, create = false) {
       // stops at this node (nothing left to retire) before it finds them. A
       // dependent then waits forever on a flight it has no path to. The
       // re-park twin of the unchanged-value recovery sweep below; dependents
-      // with another path keep the source (retryReaches).
-      if (notReady && outgoingPendingSources)
+      // with another path keep the source (retryReaches). A staged error
+      // answered what the pass carried: the same.
+      if ((notReady || stagedErr) && outgoingPendingSources)
         for (const source of outgoingPendingSources)
           if (source !== el && !el._x?._pendingSources?.has(source))
             settlePendingSource(el, source);
     }
   } finally {
     tracking = prevTracking;
+    if (laneStageHook) laneRoot = prevMount;
     strictRead = prevStrictRead;
     // 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
@@ -3833,10 +4178,11 @@ function recompute(el, create = false) {
     // (markNode(c) in read()) marks the running node as part of ordinary
     // bookkeeping, and those marks are correctly discarded here.
     missedWake = (el._flags & REACTIVE_MISSED_WAKE) !== 0;
-    joined = (el._flags & REACTIVE_JOINED) !== 0;
-    // A verdict reader is one for as long as it probes: a pass that entered
-    // no window (REACTIVE_PROBED) is an ordinary derivation again.
-    if (!(el._flags & REACTIVE_PROBED)) el._config &= ~CONFIG_VERDICT;
+    joined = !!(el._flags & (mount ? REACTIVE_JOINED | REACTIVE_STAGED_READ : 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);
     // 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
@@ -3855,6 +4201,7 @@ function recompute(el, create = false) {
           REACTIVE_PROBE_UNANSWERED)) |
       (create ? el._flags & REACTIVE_SNAPSHOT_STALE : 0);
     context = oldcontext;
+    if (released) for (const node of released) releaseIfSettledUnobserved(node);
     // A19 exc. 2: a pass that went pending on a `refresh()` re-asks the
     // question already answered — quiet for the verdict; any other pending
     // pass is a new question. Settled, there is nothing to classify.
@@ -3883,15 +4230,15 @@ function recompute(el, create = false) {
   // seat that read none of the lane's world has left it: its result is the
   // frame's (a derivation whose branch no longer reaches the guess). A
   // guess is written, not derived — it never leaves this way.
-  let lane = passLane;
+  let lane = !laneStageHook ? null : passLane;
   // Listed before its staging, a pending pass included (the lane's own
   // flight is the lane's); false: the pass left the lane (lanes.ts).
-  const errored = !!el._x?._error;
-  if (lane !== null) {
-    if (GlobalQueue._laneStage(el, lane, create, errored)) setPassLane(lane);
+  const errored = !!el._x?._error || stagedErr;
+  if (laneStageHook && lane !== null) {
+    if (laneStageHook(el, lane, create, errored)) setPassLane(lane);
     else lane = null;
   }
-  if (!el._x?._error) {
+  if (!errored) {
     // Observe-tier fan-in (HUGE_FAN_IN): the validated prefix [_deps.._depsTail]
     // IS this pass's distinct sources — count it here rather than per link. A
     // begin/end bracket around the pass plus a per-link increment measured
@@ -3918,17 +4265,9 @@ function recompute(el, create = false) {
         : el._config & CONFIG_OVERRIDE && el._x._lane !== NOT_PENDING
           ? el._x._lane
           : el._value;
-    let valueChanged = false;
-    try {
-      valueChanged =
-        (!isEffect && wasUninitialized) || !el._equals || !el._equals(compareValue, value);
-    } catch (e) {
-      // A throwing user comparator is an error of this node's computation.
-      // Route it through the same status path as a compute-phase throw so
-      // error boundaries contain it; otherwise it unwinds the scheduler
-      // flush, bypassing every boundary and wedging the queue (#2837).
-      notifyStatus(el, STATUS_ERROR, e);
-    }
+    // A throwing comparator is contained inside `isSame` (A3, #2837; #4111).
+    const valueChanged =
+      (!isEffect && wasUninitialized) || !!el._x?._shownError || !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) {
@@ -3972,7 +4311,7 @@ function recompute(el, create = false) {
       !create &&
       lane === null &&
       el._config & CONFIG_GUESS &&
-      GlobalQueue._laneOutcome(el, value, errored)
+      laneOutcomeHook(el, value, errored)
     );
     else if (errored);
     else if (valueChanged) {
@@ -4006,9 +4345,7 @@ function recompute(el, create = false) {
         create
           ? !(
               (flushTransaction !== null || passTx !== null) &&
-              (joined ||
-                (prevLane && el._flags & REACTIVE_STAGED_READ) ||
-                (creatorPass(oldcontext)?._flags ?? 0) & REACTIVE_JOINED)
+              (joined || creatorPass(oldcontext)?._flags & REACTIVE_JOINED)
             )
           : isEffect && el._pendingValue === NOT_PENDING
       ) {
@@ -4035,6 +4372,14 @@ function recompute(el, create = false) {
           // derives from the future (`read`), an untracked one throws
           // (A19 exc. 1).
           el._statusFlags |= STATUS_UNINITIALIZED;
+          // A boundary that has not shown content catches it: its fallback
+          // waits for the commit (#3540). (The pass's own status clear above
+          // dropped what the read recorded.) Not when the flush has joined
+          // the hold and the pass is its own (not a verdict lane's mount,
+          // #3851): the mount is part of the hold, and the boundary appears
+          // at its commit, its fallback never seen (D-13, U-3) — a `<Show>`
+          // mounting it over a landing included.
+          freshHook?.(el, !mount && flushTransaction);
         }
       }
       // insertSubs only walks _subs (no scheduling of its own), so a
@@ -4068,16 +4413,16 @@ function recompute(el, create = false) {
   }
   // A first pass that went pending where the born-held arm would have held
   // its value (it read a held node, or a verdict lane's mount read a staging,
-  // #3851) is born into that transaction without holding it: the hold never
-  // waits for a first load (the direction rule), but the answer lands into it
-  // while it is live (A29, #3800).
-  if (
-    create &&
-    lane === null &&
-    (joined || (prevLane && el._flags & REACTIVE_STAGED_READ)) &&
-    el._statusFlags & STATUS_PENDING
-  )
-    ext(el)._bornIn = flushTransaction ?? passTx;
+  // #3851) is held like it: its answer is the hold's, and the hold waits
+  // for it (A29, #3800). A boundary that has not shown content catches it
+  // and it is held all the same — its answer reveals no earlier than the
+  // hold's commit (D-12) — but the hold does not wait for it: its only
+  // readers are behind the fallback (`_hidden`; F-4, #3540). A boundary
+  // re-armed by `on` owns what it collects outright (D-14): not held.
+  if (create && lane === null && joined && el._statusFlags & STATUS_PENDING) {
+    const t = flushTransaction ?? passTx;
+    if (t && !t._lane && freshHook?.(el) !== CAUGHT_REARMED) holdNode(el, t);
+  }
   // Dependencies are the committed frame's until it is replaced (A30, #3410):
   // a pass that staged its value leaves the previous pass's tail linked for
   // `commitPendingNode` to trim, so a write to a dependency the committed
@@ -4188,12 +4533,12 @@ function computed(fn, options) {
   const loading = options !== null && typeof options === "object" && "loadingValue" in options;
   // Two literals, one per tier, selected at build time (the observe flag is
   // a literal after replacement; the untaken branch is dead code). The observe
-  // literal is the prod literal plus its `_name` slot — a slot in the
-  // boilerplate, because a post-construction `self._name = …` forces a
+  // literal is the prod literal plus its `_name` and `_loc` slots — slots in
+  // the boilerplate, because a post-construction `self._name = …` forces a
   // hidden-class transition and an out-of-object property store on EVERY node
   // (measured: the whole of the observe tier's creation overhead). Keep the
   // two in sync — the dist artifact test pins observe's key set to prod's
-  // plus `_name`.
+  // plus the slots.
   const self = {
     id: inheritId(options, transparent, context),
     _config:
@@ -4235,6 +4580,7 @@ function computed(fn, options) {
     // The slot is always present (hidden class); plumbing leaves it
     // unset, which `ownerPath` skips.
     _name: options?._plumbing ? undefined : (options?.name ?? "computed"),
+    _loc: options?.loc,
     // Observe: the verdict windows this pass entered (verdict.ts) — a
     // slot, so the stamp is never a write after construction.
     _devWindows: 0
@@ -4261,13 +4607,13 @@ function ext(el) {
     _pendingFirstChild: null,
     _pendingDisposal: null,
     _transaction: null,
-    _bornIn: null,
     _reask: false,
     _flushed: NOT_PENDING,
     _flushedAt: -1,
     _q: 0,
     _lane: NOT_PENDING,
-    _marks: 0
+    _marks: 0,
+    _shownError: undefined
   });
 }
 /** A tracked read of a held node (the reader derives from its transaction's
@@ -4283,8 +4629,13 @@ function ext(el) {
  * boundary's, not the tick's (A29's boundary exemption, #3540). */
 function joinPass(c, el) {
   c._flags |= REACTIVE_JOINED;
+  // A new memo's first pass is the hold's work (born held) but not the
+  // tick's: a render effect that reads it decides — under a boundary that
+  // catches it, the boundary's; otherwise the tick joins the hold (#3540:
+  // the reader's position, not where the memo was created). Its catch, if
+  // any, is at its staging.
   if (el._statusFlags & STATUS_UNINITIALIZED || c._type !== EFFECT_RENDER)
-    joinPassTx(txOf(el), GlobalQueue._fresh?.(c));
+    joinPassTx(txOf(el), (!c._type && c._statusFlags & STATUS_UNINITIALIZED) || freshHook?.(c));
 }
 /** A15's stale reader (shared-hole and reveal corollaries): a render effect
  * reading a node held by a transaction that is not the flush's. It is served
@@ -4292,11 +4643,11 @@ function joinPass(c, el) {
  * re-derived after that transaction's landing (`_reruns`,
  * REACTIVE_FRAME_READ) so the frame catches up with it once it is the
  * committed world. Not a frame born into that transaction (held and never
- * committed — created by one of its held passes, A29): that one reads its
- * transaction's values and keeps staging. Not of a flight whose inputs are
- * already visible (CONFIG_INPUTS_PUBLISHED, #3305): its committed value
- * would tear against them, so the reveal observes the flight instead. Once
- * per pass.
+ * committed — created by one of its held passes, A29; `bornInto`): that
+ * one reads its transaction's values and keeps staging. Not of a flight
+ * whose inputs are already visible (CONFIG_INPUTS_PUBLISHED, #3305): its
+ * committed value would tear against them, so the reveal observes the
+ * flight instead. Once per pass.
  *
  * Lane work is a stale reader too (maintainer, 2026-10-01: a lane sees the
  * screen plus its own guesses). A held write is held because showing it
@@ -4321,10 +4672,11 @@ function frameRead(c, el) {
   // read the screen. Lane work with no committed value yet reads a flight
   // as a mount's memo does: it enters, and the boundary it mounts catches
   // the pending (#3540).
-  const verdict = c._config & CONFIG_VERDICT;
+  // (Verdict readers and lanes exist only with their engines installed.)
+  const verdict = observeFlightHook && c._config & CONFIG_VERDICT;
+  const lane = laneStageHook && passLane !== null;
   if (
-    (passLane === null ||
-      (c._statusFlags & STATUS_UNINITIALIZED && el._statusFlags & STATUS_PENDING)) &&
+    (!lane || (c._statusFlags & STATUS_UNINITIALIZED && el._statusFlags & STATUS_PENDING)) &&
     !verdict &&
     (c._type !== EFFECT_RENDER || el._config & CONFIG_INPUTS_PUBLISHED)
   )
@@ -4333,14 +4685,22 @@ function frameRead(c, el) {
   // Lane work and verdict readers are never the transaction's pass, whichever
   // flush runs it: a node T holds re-enters T when it re-runs (`recompute`'s
   // head), and the pass may then read a guess and become the lane's.
-  if (
-    (t === flushTransaction && passLane === null && !verdict) ||
-    (c._statusFlags & STATUS_UNINITIALIZED && c._config & CONFIG_HELD && txOf(c) === t)
-  )
-    return false;
+  if ((t === flushTransaction && !lane && !verdict) || bornInto(c, t)) return false;
   staleReader(c, t);
   return true;
 }
+/** A node born into transaction `t`: held by it and never committed (A29,
+ * ruling A) — uninitialized (born held), or a member of the frame one of its
+ * held passes built (CONFIG_HELD_FRAME). Its branch exists only in `t`: it
+ * has no screen to read, so it reads `t`'s values, whichever flush runs it,
+ * and keeps staging (#4010). */
+function bornInto(c, t) {
+  return (
+    (c._statusFlags & STATUS_UNINITIALIZED || c._config & CONFIG_HELD_FRAME) &&
+    c._config & CONFIG_HELD &&
+    txOf(c) === t
+  );
+}
 /** The computed whose pass a creation under `owner` belongs to (a root's is
  * its nearest computed ancestor's), or null outside every pass. */
 function creatorPass(owner) {
@@ -4412,6 +4772,7 @@ function createEffectNode(fn, effectFn, errorFn, type, options) {
     _type: type,
     _x: null,
     _name: options?.name ?? "effect",
+    _loc: options?.loc,
     _devWindows: 0
   };
   // Effects dispatch status through the SHARED notifier (statusNotifierOf,
@@ -4463,7 +4824,7 @@ function setupComputedNode(self, options) {
   if (context) linkChild(context, self);
   DEV.hooks.onOwner?.(self);
   if (parent) self._height = parent._height + 1;
-  GlobalQueue._wireExternalSource?.(self);
+  wireExternalSourceHook?.(self);
   !options?.lazy && recompute(self, true);
   if (snapshotCaptureActive && !options?.lazy) {
     if (!(self._statusFlags & STATUS_PENDING) && !(self._config & CONFIG_NO_SNAPSHOT)) {
@@ -4475,7 +4836,7 @@ function setupComputedNode(self, options) {
 }
 function signal(v, options) {
   // Prod and observe boilerplates — see computed(). The observe literal adds
-  // `_name` and `_owner` (the creating owner, stamped by registerGraph for
+  // `_name`, `_loc` and `_owner` (the creating owner, stamped by registerGraph for
   // createSignal nodes so ownerPath can locate signal subjects; null here,
   // and staying null on internal signals — one shape either way).
   const s = {
@@ -4491,6 +4852,7 @@ function signal(v, options) {
     _notifiedAt: -1,
     _x: null,
     _name: options?.name ?? "signal",
+    _loc: options?.loc,
     _owner: null
   };
   s._internal = false;
@@ -4514,7 +4876,8 @@ function isEqual(a, b) {
  * object, no NodeExtension, no post-construction expandos. `ownedWrite` is
  * baked in: the setter carries the owned-scope guard; node-level writes are
  * the store's notification machinery. The observe literal adds the label
- * slot (the store relabels it `store.<key>` when the engine is installed). */
+ * and location slots (the store relabels `store.<key>` and stamps the
+ * store's `loc` when the engine is installed). */
 function slotSignal(v, equals, host, key, acc) {
   const s = {
     _equals: equals,
@@ -4532,6 +4895,7 @@ function slotSignal(v, equals, host, key, acc) {
     px: undefined,
     pxv: undefined,
     _name: "signal",
+    _loc: undefined,
     _owner: null
   };
   s._internal = false;
@@ -4568,7 +4932,11 @@ function exitCallback() {
 }
 /**
  * Dev-only: > 0 while owner teardown runs cleanups (`_disposal` entries and
- * effect-returned cleanups — owner.ts), for the same reason. Kept apart from
+ * effect-returned cleanups — owner.ts), for the same reason. The owned-scope
+ * write guard (setSignal, markRefresh, the store setter) stands down here
+ * too: a cleanup is teardown, not part of whichever computation is disposing
+ * its owner (a list pass removing a row, a branch switching away), so its
+ * writes are imperative like an effect callback's (#4165). Kept apart from
  * `callbackDepth` because its sites cannot use try/finally (the frame would
  * survive into prod): a throwing cleanup leaves it raised, and dev.ts resets
  * it on the next microtask, which teardown — synchronous — never spans.
@@ -4595,6 +4963,16 @@ function setStrictRead(v) {
  * Use `untrack` inside a memo or effect when you need to read a signal once
  * without making the surrounding computation depend on its future changes.
  *
+ * `untrack` stops dependency tracking, not async settlement. Reading an
+ * uninitialized async source still suspends the owning computation; it runs
+ * again when that source first resolves. Afterward, the untracked read is a
+ * snapshot and does not subscribe the computation to later changes.
+ *
+ * If the first read must return immediately, give the async source a
+ * `loadingValue` before reading it with `untrack`. `isPending` and `latest`
+ * inspect updates to an existing value; neither supplies a missing initial
+ * value.
+ *
  * Pass a `strictReadLabel` string to enable a dev-mode warning: any reactive
  * read inside `fn` that isn't inside a nested tracking scope will log a
  * warning naming the label.
@@ -4608,17 +4986,12 @@ function setStrictRead(v) {
  *     log(snapshot);
  *   }
  * );
+ *
+ * const color = createMemo<string>(() => fetchColor(), { loadingValue: "gray" });
+ * const initialColor = untrack(color); // "gray" while the fetch is unresolved
  * ```
  */
 function untrack(fn, strictReadLabel) {
-  if (
-    GlobalQueue._externalUntrack === null &&
-    !tracking &&
-    !strictRead &&
-    !strictReadLabel &&
-    asyncTailFlights === 0
-  )
-    return fn();
   const prevTracking = tracking;
   const prevStrictRead = strictRead;
   tracking = false;
@@ -4627,7 +5000,7 @@ function untrack(fn, strictReadLabel) {
     untrackDepth++;
   }
   try {
-    if (GlobalQueue._externalUntrack) return GlobalQueue._externalUntrack(fn);
+    if (externalUntrackHook) return externalUntrackHook(fn);
     return fn();
   } finally {
     tracking = prevTracking;
@@ -4699,7 +5072,7 @@ function prepareComputed(comp, refresh) {
  * False means the reader derives from the staged value.
  */
 function readerSeesCommitted(el, c) {
-  return !!(!c || el._pendingValue === NOT_PENDING || c._config & CONFIG_CHILDREN_FORBIDDEN);
+  return !c || el._pendingValue === NOT_PENDING || c._config & CONFIG_CHILDREN_FORBIDDEN;
 }
 /** A28 — set when a node is staged (queuePendingNode) OUTSIDE a flush;
  * cleared when the next flush begins. The read sites test this one module
@@ -4778,6 +5151,7 @@ function pullComputed(owner, c) {
   if (height >= c._height && owner._parent !== c) c._height = height + 1;
 }
 function read(el) {
+  DEV.hooks.onRead?.(el);
   if (asyncTailFlights !== 0 && !tracking && untrackDepth === 0)
     checkPostAwaitRead(
       el,
@@ -4828,7 +5202,7 @@ function read(el) {
     if (!c || el._pendingValue === NOT_PENDING || c._config & CONFIG_CHILDREN_FORBIDDEN)
       return el._value;
     // (A plain signal is never uninitialized — the carve-out is `serve`'s.)
-    if (c._config & CONFIG_VERDICT && stagedScreen(c)) return el._value;
+    if (observeFlightHook && c._config & CONFIG_VERDICT && stagedScreen(c)) return el._value;
     stagedRead(c);
     return el._pendingValue;
   }
@@ -4844,7 +5218,15 @@ function read(el) {
   if (c) {
     if (tracking) {
       link(el, c);
-      if (owner._fn) pullComputed(owner, c);
+      if (owner._fn) {
+        pullComputed(owner, c);
+        // F-6 (#4050): a memo over a verdict reader's value derives from a
+        // display-ahead read — a verdict reader from this pass's end, as if
+        // 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;
+      }
     }
     // L2, as in the fast block above (tracked or not). A node born into the
     // future (uninitialized) has no committed value: every reader derives
@@ -4861,8 +5243,9 @@ function read(el) {
   }
   // Lanes: a lane's node (after the pull — the node is current). NOT_PENDING
   // falls through: lane work's read of a pending member throws like any.
-  if (el._config & CONFIG_OVERRIDE) {
-    const v = GlobalQueue._laneRead(c, el);
+  // (CONFIG_OVERRIDE is the lane engine's: no engine, no lane's node.)
+  if (laneReadHook && el._config & CONFIG_OVERRIDE) {
+    const v = laneReadHook(c, el);
     if (v !== NOT_PENDING) return v;
   }
   // A stale reader of a held flight (rule 3, A15's reveal corollary) is served
@@ -4877,7 +5260,8 @@ function read(el) {
   // effect keeps its DOM by throwing, a memo has no DOM and is handed the
   // value. `[isPending(x), x()]` reads `[true, stale]` in either order (A10)
   // — unless the flight committed beneath inputs already on screen
-  // (`observeFlight`).
+  // (`observeFlight`), or the reader was born into the flight's transaction
+  // (#4010): it has no screen, and waits on the flight with its frame.
   if (
     owner._statusFlags & STATUS_PENDING &&
     !committed &&
@@ -4886,9 +5270,11 @@ 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).
-    if (passLane !== null && !(c?._statusFlags & STATUS_UNINITIALIZED)) committed = true;
-    else if (c !== null && c._config & CONFIG_VERDICT)
-      committed = GlobalQueue._observeFlight(c, owner);
+    // (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 (owner._statusFlags & STATUS_PENDING && !committed) {
     // A reader landing on a pending node throws; an untracked read of an
@@ -4957,6 +5343,9 @@ function read(el) {
     }
   }
   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);
   if (
     !c &&
@@ -5003,9 +5392,16 @@ function serve(el, c) {
     return u;
   }
   if (readerSeesCommitted(el, c)) return el._value;
-  if (c._config & CONFIG_VERDICT && !(el._statusFlags & STATUS_UNINITIALIZED) && stagedScreen(c))
+  if (
+    observeFlightHook &&
+    c._config & CONFIG_VERDICT &&
+    !(el._statusFlags & STATUS_UNINITIALIZED) &&
+    stagedScreen(c)
+  )
     return el._value;
   stagedRead(c, el);
+  // D-41: the staged answer is an error (`stageError`).
+  if (el._config & CONFIG_STAGED_ERROR) throw el._pendingValue;
   return el._pendingValue;
 }
 /** A pass read a staging of this flush: it derives from what the flush may
@@ -5017,11 +5413,14 @@ function serve(el, c) {
  * write never shows through the lane. A verdict lane's work likewise: the
  * lane holds verdicts, not the frame's other stagings (#3851) — except a
  * verdict reader, which answered for itself (the lane seam, lanes.ts). Not
- * a read of a node born staged: it has no committed value to re-derive on,
- * and a re-run would read the same staging and re-queue every round. */
+ * a read of a node born staged at all: it has no committed value to
+ * re-derive on, and a re-run would read the same staging and re-queue every
+ * round (#3969: nor does it make a later lane read a re-derive, `enterLane`). */
 function stagedRead(c, el) {
-  c._flags |= REACTIVE_STAGED_READ;
-  if (passLane !== null && !(el?._statusFlags & STATUS_UNINITIALIZED)) stagedReaders.push(c);
+  if (!(el?._statusFlags & STATUS_UNINITIALIZED)) {
+    c._flags |= REACTIVE_STAGED_READ;
+    if (laneSeamsHook && passLane !== null) stagedReaders.push(c);
+  }
 }
 /** A10 for a staged node: a verdict reader (the pass entered a window) that
  * also reads a frame's proposal plainly sees the screen — `[latest(q), q()]`
@@ -5030,9 +5429,10 @@ function stagedRead(c, el) {
  * #3322 — one run, on the committed world), or with the hold. Before any
  * transaction the answer is the seam's and the reader watches it
  * (verdict.ts). A node born into the future has no screen: its staging is
- * its only value (A29). */
+ * its only value (A29). Nor has a reader born into the flush's transaction
+ * (`bornInto`, #4010): its branch exists only there. */
 function stagedScreen(c) {
-  if (flushTransaction === null) return false;
+  if (flushTransaction === null || bornInto(c, flushTransaction)) return false;
   staleReader(c, flushTransaction);
   return true;
 }
@@ -5050,9 +5450,10 @@ function notePromotedWrite(el) {
   el._config |= CONFIG_PROMOTED;
   promotedWrites.push(el);
 }
-/** Cold half of setSignal's snapshot arm (see there): first write during
- * capture to a plain signal without a live snapshot records the pre-write
- * value. Only plain user signals qualify. Computeds reach setSignal from an
+/** Cold half of setSignal's snapshot arm (see there), shared with a store
+ * container's structural notify: first write during capture to a plain
+ * signal without a live snapshot records the pre-write value. Only plain
+ * user signals qualify. Computeds reach setSignal from an
  * async landing (asyncWrite), and a value arriving from async during the pass
  * REVEALS — the creation-time arm skips pending computeds for the same
  * reason. Firewall leaves belong to a projection whose compute is the tree's
@@ -5068,11 +5469,46 @@ function captureWriteSnapshot(el, current) {
   el._config |= CONFIG_HAS_SNAPSHOT;
   snapshotSources.add(el);
 }
+/**
+ * A callback run before every signal or store write lands, while set, with
+ * the written signal or the store proxy whose setter runs. The
+ * server-components client sets it while slot occurrences are left
+ * unmounted after hydration (deferred hydration): a write may be one an
+ * unmounted component would have observed, so the client mounts what is
+ * left before the write applies, and clears the hook. `null` otherwise.
+ */
+let writeHook = null;
+/** @internal */
+function setWriteHook(hook) {
+  writeHook = hook;
+}
+/**
+ * `el`'s comparator verdict (`_equals`), the one guarded call for recompute,
+ * setSignal (user setters and async landings) and the seam's
+ * staged-equals-committed check.
+ * - A comparator that read an unresolved async source has not shown the
+ *   values equal (#4111): falsy, a change, whose readers suspend in their own
+ *   tracked context.
+ * - Any other throw is an error of `el`'s computation (A3, #2837): routed
+ *   through the status path so error boundaries contain it, instead of
+ *   unwinding a flush or a setter; answered "same" so nothing commits.
+ * @internal
+ */
+function isSame(el, a, b) {
+  if (el._equals === isEqual) return a === b;
+  try {
+    return el._equals && el._equals(a, b);
+  } catch (e) {
+    if (!(e instanceof NotReadyError)) return (notifyStatus(el, STATUS_ERROR, e), true);
+  }
+}
 function setSignal(el, v) {
+  if (writeHook !== null) writeHook(el);
   if (
     !(el._config & CONFIG_OWNED_WRITE) &&
     !(context && context._config & CONFIG_CHILDREN_FORBIDDEN) &&
-    context
+    context &&
+    !disposalDepth
   ) {
     emitDiagnostic({
       code: "REACTIVE_WRITE_IN_OWNED_SCOPE",
@@ -5091,7 +5527,7 @@ function setSignal(el, v) {
   // Lanes: a write landing on a guess is its truth (A18 — an async guess's
   // own landing), judged against the guess; one landing on a lane's
   // derivation (its flight) is the lane's staging (lanes.ts).
-  if (el._config & CONFIG_OVERRIDE) return GlobalQueue._laneWrite(el, v);
+  if (laneWriteHook && el._config & CONFIG_OVERRIDE) return laneWriteHook(el, v);
   // L2 (T4) / A34 (1): a write to a node whose staged state is held is a
   // second proposal for the slot — the same value again or another — and
   // the two cannot finish at different times: the writer's tick joins the
@@ -5099,8 +5535,12 @@ function setSignal(el, v) {
   if (el._config & CONFIG_HELD) joinFuture(txOf(el));
   // Uninitialized check first: the first commit has no previous value, so the
   // user comparator must not run against `undefined` (matches recompute).
+  // D-41: a write over a shown error is a change whatever the last good
+  // value was — the error leaves at its commit (`commitPendingNode`).
   const valueChanged =
-    !!(el._statusFlags & STATUS_UNINITIALIZED) || !el._equals || !el._equals(currentValue, v);
+    !!(el._statusFlags & STATUS_UNINITIALIZED) ||
+    !!el._x?._shownError ||
+    !isSame(el, currentValue, v);
   if (!valueChanged) return v;
   // Attribution hook: this committed write is where a re-run chain begins.
   if (attrHooks !== null) attrHooks.write(el, currentValue, v);
@@ -5158,8 +5598,21 @@ function setMemo(el, v) {
     !(el._flags & REACTIVE_MANUAL_WRITE) &&
     txOf(el) !== flushTransaction;
   // The writer read the committed frame; its updater composes on it.
-  if (held && typeof v === "function") v = v(el._value);
-  const result = setSignal(el, v);
+  if (held && typeof v === "function") {
+    const value = v(el._value);
+    v = () => value;
+  }
+  // #4110: the write replaces a failed derivation's outcome. It lands without
+  // re-running `_fn`, and nothing else clears STATUS_ERROR, so without this
+  // every later read keeps throwing the error the derivation left behind.
+  // 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);
+  }
+  v = setSignal(el, v);
+  // A write replaces an error a pass staged (D-41): it is a value again.
+  el._config &= ~CONFIG_STAGED_ERROR;
   if (held) {
     // The one write that re-runs: the staging it replaced was derived from
     // inputs the writer never saw, so the hold re-derives over the write.
@@ -5167,7 +5620,7 @@ function setMemo(el, v) {
     insertIntoHeap(el, dirtyQueue);
     schedule();
   } else if (el._pendingValue !== NOT_PENDING) el._flags |= REACTIVE_MANUAL_WRITE;
-  return result;
+  return v;
 }
 /**
  * Executes `fn` with the given `owner` set as the current owner. Any reactive
@@ -5234,7 +5687,8 @@ function markRefresh(node) {
   if (
     context &&
     !((node._config ?? 0) & CONFIG_OWNED_WRITE) &&
-    !(context._config & CONFIG_CHILDREN_FORBIDDEN)
+    !(context._config & CONFIG_CHILDREN_FORBIDDEN) &&
+    !disposalDepth
   ) {
     emitDiagnostic({
       code: "REACTIVE_WRITE_IN_OWNED_SCOPE",
@@ -5268,171 +5722,194 @@ function markRefresh(node) {
 }
 
 export {
-  CONFIG_INPUTS_PUBLISHED as $,
-  list as A,
-  clock as B,
+  setPassLane as $,
+  tracking as A,
+  CONFIG_CHILDREN_FORBIDDEN as B,
   CONFIG_GUESS as C,
-  insertSubs as D,
-  EFFECT_RENDER as E,
-  laneDirty as F,
+  passLane as D,
+  STATUS_PENDING as E,
+  EFFECT_RENDER as F,
   GlobalQueue as G,
-  merge as H,
-  newTransaction as I,
-  reruns as J,
-  CONFIG_STAGED as K,
-  releaseQueues as L,
-  ownFlights as M,
+  sameLane as H,
+  flushTransaction as I,
+  REACTIVE_SCREEN_READ as J,
+  REACTIVE_FRAME_READ as K,
+  attrHooks as L,
+  commitPendingNode as M,
   NOT_PENDING as N,
-  setPassLane as O,
-  REACTIVE_JOINED as P,
-  stagedRead as Q,
+  REACTIVE_IN_HEAP as O,
+  REACTIVE_DIRTY as P,
+  REACTIVE_CHECK as Q,
   REACTIVE_DISPOSED as R,
-  STATUS_PENDING as S,
-  attrHooks as T,
-  holdNode as U,
-  joinFuture as V,
-  CONFIG_SLOT_NODE as W,
-  commitPendingNode as X,
-  REACTIVE_IN_HEAP as Y,
-  REACTIVE_DIRTY as Z,
-  REACTIVE_CHECK as _,
-  CONFIG_OVERRIDE as a,
-  CONFIG_REDERIVE as a$,
-  setVerdict as a0,
-  context as a1,
-  REACTIVE_PROBED as a2,
-  globalQueue as a3,
-  staleReader as a4,
-  REACTIVE_STAGED_READ as a5,
-  verdict as a6,
-  link as a7,
-  pullComputed as a8,
-  strictRead as a9,
-  EFFECT_USER as aA,
-  reportDiagnostic as aB,
-  computed as aC,
-  staleValues as aD,
-  CONFIG_AUTO_DISPOSE as aE,
-  EFFECT_TRACKED as aF,
-  unwrapStatusError as aG,
-  haltReactivity as aH,
-  setStrictRead as aI,
-  StatusError as aJ,
-  trimStaleDeps as aK,
-  setTrackedQueueCallback as aL,
-  setEffectStatusNotify as aM,
-  _hitUnhandledAsync as aN,
-  resetUnhandledAsync as aO,
-  ROOT_ERROR_HOOK as aP,
-  registerGraph as aQ,
-  runWithOwner as aR,
-  setMemo as aS,
-  $REFRESH as aT,
-  markRefresh as aU,
-  createRoot as aV,
-  getObserver as aW,
-  dispose as aX,
-  TimeoutError as aY,
-  untrack as aZ,
-  dirtyQueue as a_,
-  warnStrictReadUntracked as aa,
-  markLateLinker as ab,
-  spectating as ac,
-  STATUS_ERROR as ad,
-  unflushedValue as ae,
-  stagedReaders as af,
-  enterAction as ag,
-  setEffectCallback as ah,
-  exitAction as ai,
-  isThenable as aj,
-  actionDepth as ak,
-  flush as al,
-  setQuestion as am,
-  emitDiagnostic as an,
-  enterCallback as ao,
-  exitCallback as ap,
-  getOwner as aq,
-  inEffectCallback as ar,
-  signal as as,
-  setSignal as at,
-  cleanup as au,
-  read as av,
-  NoOwnerError as aw,
-  ContextNotFoundError as ax,
-  createEffectNode as ay,
-  recompute as az,
-  CONFIG_VERDICT as b,
-  passTx as b0,
-  CONFIG_FRESH_READ as b1,
-  createOwner as b2,
-  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as b3,
-  ownedScopeWriteMessage as b4,
-  DEV as b5,
-  isEqual as b6,
-  CONFIG_MANUAL_WRITE as b7,
-  notePromotedWrite as b8,
-  slotSignal as b9,
-  setSnapshotCapture as bA,
-  setAttributionHooks as bB,
-  liveRootOwners as bC,
-  ownerPath as bD,
-  isSuppressed as bE,
-  blockersOf as bF,
-  CONFIG_PLUMBING as bG,
-  anyExcluded as bH,
-  isExcluded as bI,
-  CONFIG_WIDE as bJ,
-  GRAPH_SIZE_WARN_AT as bK,
-  noteFanOut as bL,
-  CONFIG_SUPERSEDES as bM,
-  stagedScreen as ba,
-  CONFIG_PROMOTED as bb,
-  setSlotUnobserved as bc,
-  joinPassTx as bd,
-  asyncTailFlights as be,
-  untrackDepth as bf,
-  checkPostAwaitRead as bg,
-  insertIntoHeap as bh,
-  isDisposed as bi,
-  handleAsync as bj,
-  addPendingSource as bk,
-  propagateStatus as bl,
-  forEachDependent as bm,
-  settlePendingSource as bn,
-  notifyEpoch as bo,
-  SUPPORTS_PROXY as bp,
-  REACTIVE_ZOMBIE as bq,
-  OBSERVE as br,
-  clearSnapshots as bs,
-  enforceLoadingBoundary as bt,
-  getNextChildId as bu,
-  markSnapshotScope as bv,
-  peekNextChildId as bw,
-  releaseSnapshotScope as bx,
-  resetErrorHalt as by,
-  setConsoleFooter as bz,
-  REACTIVE_PROBE_UNANSWERED as c,
-  blocked as d,
+  STATUS_UNINITIALIZED as S,
+  CONFIG_INPUTS_PUBLISHED as T,
+  releaseQueues as U,
+  CONFIG_SLOT_NODE as V,
+  holdNode as W,
+  joinFuture as X,
+  reruns as Y,
+  CONFIG_STAGED as Z,
+  merge as _,
+  NotReadyError as a,
+  setMemo 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,
+  cleanup as aA,
+  read as aB,
+  DEV as aC,
+  CONFIG_TRANSPARENT as aD,
+  NoOwnerError as aE,
+  ContextNotFoundError as aF,
+  createEffectNode as aG,
+  recompute as aH,
+  EFFECT_USER as aI,
+  reportDiagnostic as aJ,
+  computed as aK,
+  staleValues as aL,
+  CONFIG_AUTO_DISPOSE as aM,
+  EFFECT_TRACKED as aN,
+  heldRunHook as aO,
+  unwrapStatusError as aP,
+  haltReactivity as aQ,
+  setStrictRead as aR,
+  StatusError as aS,
+  trimStaleDeps as aT,
+  setTrackedQueueCallback as aU,
+  setEffectStatusNotify as aV,
+  _hitUnhandledAsync as aW,
+  resetUnhandledAsync as aX,
+  ROOT_ERROR_HOOK as aY,
+  registerGraph as aZ,
+  runWithOwner as a_,
+  strictRead as aa,
+  warnStrictReadUntracked as ab,
+  staleReader as ac,
+  globalQueue as ad,
+  joinPass as ae,
+  markLateLinker as af,
+  spectating as ag,
+  unflushedValue as ah,
+  CONFIG_STAGED_ERROR as ai,
+  stagedReaders as aj,
+  bornInto as ak,
+  enterAction as al,
+  setEffectCallback as am,
+  exitAction as an,
+  isThenable as ao,
+  actionDepth as ap,
+  flush as aq,
+  setQuestion as ar,
+  emitDiagnostic as as,
+  enterCallback as at,
+  exitCallback as au,
+  getOwner as av,
+  inEffectCallback as aw,
+  setExternalHooks as ax,
+  signal as ay,
+  setSignal as az,
+  CONFIG_AUTHORITATIVE as b,
+  isSuppressed as b$,
+  $REFRESH as b0,
+  markRefresh as b1,
+  createRoot as b2,
+  getObserver as b3,
+  dispose as b4,
+  TimeoutError as b5,
+  untrack as b6,
+  dirtyQueue as b7,
+  CONFIG_REDERIVE as b8,
+  passTx as b9,
+  settlePendingSource as bA,
+  notifyEpoch as bB,
+  SUPPORTS_PROXY as bC,
+  releaseMarksHook as bD,
+  installMarkHooks as bE,
+  CONFIG_LAGS as bF,
+  REACTIVE_REASK as bG,
+  heldUnder as bH,
+  unhold as bI,
+  laneStageHook as bJ,
+  REACTIVE_ZOMBIE as bK,
+  installBoundaryHooks as bL,
+  CAUGHT_REARMED as bM,
+  OBSERVE as bN,
+  clearSnapshots as bO,
+  enforceLoadingBoundary as bP,
+  getNextChildId as bQ,
+  markSnapshotScope as bR,
+  peekNextChildId as bS,
+  releaseSnapshotScope as bT,
+  resetErrorHalt as bU,
+  setConsoleFooter as bV,
+  setSnapshotCapture as bW,
+  setWriteHook as bX,
+  setAttributionHooks as bY,
+  liveRootOwners as bZ,
+  ownerPath as b_,
+  CONFIG_FRESH_READ as ba,
+  createOwner as bb,
+  writeHook as bc,
+  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as bd,
+  ownedScopeWriteMessage as be,
+  isEqual as bf,
+  CONFIG_MANUAL_WRITE as bg,
+  snapshotCaptureActive as bh,
+  captureWriteSnapshot as bi,
+  notePromotedWrite as bj,
+  slotSignal as bk,
+  stagedScreen as bl,
+  CONFIG_PROMOTED as bm,
+  setSlotUnobserved as bn,
+  installStoreHooks as bo,
+  joinPassTx as bp,
+  asyncTailFlights as bq,
+  untrackDepth as br,
+  checkPostAwaitRead as bs,
+  disposalDepth as bt,
+  insertIntoHeap as bu,
+  isDisposed as bv,
+  handleAsync as bw,
+  addPendingSource as bx,
+  propagateStatus as by,
+  forEachDependent as bz,
+  CONFIG_OVERRIDE as c,
+  blockersOf as c0,
+  CONFIG_PLUMBING as c1,
+  anyExcluded as c2,
+  isExcluded as c3,
+  CONFIG_WIDE as c4,
+  GRAPH_SIZE_WARN_AT as c5,
+  noteFanOut as c6,
+  CONFIG_SUPERSEDES as c7,
+  newTransaction as d,
   enqueueSub as e,
-  CONFIG_AUTHORITATIVE as f,
-  tracking as g,
-  CONFIG_CHILDREN_FORBIDDEN as h,
-  sameLane as i,
-  CONFIG_HELD as j,
-  flushTransaction as k,
-  STATUS_UNINITIALIZED as l,
-  NotReadyError as m,
+  CONFIG_VERDICT as f,
+  REACTIVE_PROBE_UNANSWERED as g,
+  blocked as h,
+  installLaneHooks as i,
+  REACTIVE_LANE_DIRTY as j,
+  CONFIG_HELD as k,
+  clock as l,
+  insertSubs as m,
   nextQuestion as n,
-  REACTIVE_SCREEN_READ as o,
-  passLane as p,
+  ownFlights as o,
+  laneDirty as p,
   question as q,
   resolveTx as r,
   schedule as s,
   txOf as t,
-  REACTIVE_FRAME_READ as u,
-  REACTIVE_LANE_READ as v,
-  ext as w,
-  REACTIVE_RECOMPUTING_DEPS as x,
-  queuePendingNode as y,
-  REACTIVE_LANE_DIRTY as z
+  REACTIVE_LANE_READ as u,
+  ext as v,
+  REACTIVE_RECOMPUTING_DEPS as w,
+  queuePendingNode as x,
+  list as y,
+  STATUS_ERROR as z
 };