@solidjs/signals 2.0.0-rc.15 → 2.0.0-rc.17

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;
   }
 }
@@ -61,11 +61,26 @@ class NoOwnerError extends Error {
 }
 class ContextNotFoundError extends Error {
   constructor() {
-    super(
-      "Context must either be created with a default value or a value must be provided before accessing it."
-    );
+    super(contextNotFoundMessage(arguments[0], arguments[1]));
   }
 }
+/**
+ * Dev message for a context read with no value. `undefined` means "not
+ * provided" for context, from either side — no default, or a provider
+ * passing `undefined` — so the message says which happened and points at
+ * `null` as the explicit empty value.
+ */
+function contextNotFoundMessage(context, providedUndefined) {
+  if (!context)
+    return "Context must either be created with a default value or a value must be provided before accessing it.";
+  const description = context.id.description;
+  const name = description ? `Context "${description}"` : "Context";
+  if (providedUndefined)
+    return `${name} was provided with \`undefined\`, which counts as not provided: \`undefined\` means "no value" for context. To provide an empty value, create the context with a \`null\` default (\`createContext<T | null>(null)\`) and pass \`null\`.`;
+  if (context._undefinedDefault)
+    return `${name} has no provider above this read, and \`createContext(undefined)\` does not give it a default: \`undefined\` means "no value" for context. Mount a provider above this read, or use \`null\` as an explicit empty default: \`createContext<T | null>(null)\`.`;
+  return `${name} has no provider above this read and no default value. Mount a provider above this read, or create the context with a default; for an optional context, use \`null\` as the empty default (\`createContext<T | null>(null)\`), not \`undefined\`.`;
+}
 
 const REACTIVE_NONE = 0;
 const REACTIVE_CHECK = 1 << 0;
@@ -191,6 +206,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. */
@@ -199,15 +217,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
@@ -259,9 +283,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;
@@ -410,13 +438,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() {
@@ -518,10 +554,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,
@@ -531,7 +568,7 @@ const DEV = {
   getObservers,
   report: reportDiagnostic,
   guideUrl(code) {
-    return `${GUIDE_URL}#${code.toLowerCase()}`;
+    return GUIDE_URL + code.toLowerCase().replace(/_/g, "-");
   }
 };
 /**
@@ -570,15 +607,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 = {
@@ -595,6 +646,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);
@@ -631,12 +686,44 @@ 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 locating lines of a console report: `\n  in <App> › <TodoRow> › effect`
+ * (the owner path) and `\n  at src/App.tsx:18:3` (see `locationLine`), each
+ * when the entry carries it; `""` when it carries neither. Shared by
+ * `reportDiagnostic` and the sites that print their own console entry (the
+ * halt, which logs its cause beside the message).
+ */
+function locationLines(entry) {
+  let text = "";
+  if (entry.ownerPath) text += `\n  in ${entry.ownerPath.join(" › ")}`;
+  if (entry.loc) text += `\n  at ${locationLine(entry.loc)}`;
+  return text;
+}
 /**
  * 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
@@ -645,8 +732,7 @@ const eventSubjects = new WeakMap();
  */
 function reportDiagnostic(entry) {
   if (suppressedEvents.has(entry)) return;
-  let text = entry.message;
-  if (entry.ownerPath) text += `\n  in ${entry.ownerPath.join(" › ")}`;
+  let text = entry.message + locationLines(entry);
   const footer = takeFooter(entry);
   if (footer) text += `\n${footer}`;
   const element = eventSubjects.get(entry)?._devElement;
@@ -929,9 +1015,10 @@ function checkPostAwaitRead(dep, holder, key, nodeName, throwsPending) {
   if (callbackDepth !== 0) return;
   if (disposalDepth !== 0) {
     // Teardown is synchronous, so a depth still raised on the next microtask
-    // was left behind by a cleanup that threw (owner.ts brackets it without
-    // try/finally, which would survive into prod). Clear it then, or every
-    // later check would stay silent.
+    // was left behind by a throw that escaped it (owner.ts brackets it
+    // without try/finally, which would survive into prod; a cleanup's own
+    // throw is caught there). Clear it then, or every later check would stay
+    // silent.
     if (!disposalHealQueued) {
       disposalHealQueued = true;
       queueMicrotask(healDisposalDepth);
@@ -1052,1514 +1139,1704 @@ function devCheckQuiescent(isQueuedForCommit) {
   return;
 }
 
-/** Live transactions — opened, unmerged, not landed. Scanned at every seam
- * while non-empty; nothing on the plain path. */
-const transactions = [];
-/** Observe tier: this flush parked its transaction (`holdStart` fired). */
-let holding = false;
-/** A transaction (listed here) or a lane (lanes.ts lists its own). */
-function newTransaction(lane, parent = null) {
-  const t = {
-    _nodes: [],
-    _queues: [[], []],
-    _reruns: [],
-    _into: null,
-    _parent: parent,
-    _lane: lane,
-    _verdict: null,
-    _open: 0,
-    _acted: false,
-    _links: null,
-    _shown: false,
-    _held: false,
-    _marks: null
-  };
-  if (!lane) transactions.push(t);
-  return t;
-}
-// Lanes (plan sec. 28, 2026-10-02; lanes.ts). A lane is "a new base of a transition":
-// the sub-frame an optimistic write opens in the transition of the frame it
-// is made in. It sees the screen plus its own guesses (plan sec. 19), breaks out of
-// the parent's hold — its effects run now — and holds itself if its own
-// derivations hit async. It ends when the parent lands: a guess reverts to
-// the truth it covered, or lands as the truth that superseded it. A frame
-// that does not park has nothing to be optimistic over: the write is void.
-//
-// The seat of a pass is its node's: a node carrying a lane's value runs as
-// the lane's whoever dirtied it; a derivation's tracked read of a lane's
-// value moves its pass into the lane; a leaf's never does (it reads the
-// screen). Lane work's values go to the lane slot, its runs to the lane's
-// queues; the rest of the frame is the flush's.
-/** The lane the running pass is work of; set at `recompute`'s head from the
- * node, moved by a derivation's lane read, saved and restored around the
- * pass. */
-let passLane = null;
-function setPassLane(l) {
-  passLane = l;
-}
-/** The transaction this flush parks into: set by the first join, merged
- * with every further one. Consumed at the seam. A join outside a flush (a
- * mount's pending observer, a write to a held node, an action opening)
- * schedules the seam that consumes it: membership is the tick's — the same
- * synchronous frame — and the next tick's writes are not this one's. */
-let flushTransaction = null;
-/** The transaction the passes running OUTSIDE a flush this tick derive from
- * (a mainline mount, a mainline re-pass): the passes' own (A29, creation-
- * time form — "the entry is the pass's alone"): their results are staged
- * into it, and nothing else in the tick is — a write made after the mount
- * is a mainline write, a render effect mounted beside it a stale reader.
- * Inside a flush, or in a tick that already has its transaction (an
- * action's body), the frame joins instead (`flushTransaction`) — except a
- * first pass a loading boundary that has not shown content catches (`own`,
- * A29's boundary exemption, #3540): it is the boundary's, not the tick's,
- * and a flush that has joined nothing keeps it pass-scoped as outside one.
- * Cleared by the flush the join schedules, and at the end of a flush that
- * set it. */
-let passTx = null;
-function joinPassTx(t, own) {
-  if ((globalQueue._running && !own) || flushTransaction !== null) return joinFuture(t);
-  if (passTx === null) passTx = resolveTx(t);
-  else merge(resolveTx(t), passTx);
-  schedule();
-}
-/** The transaction holding a node (CONFIG_HELD set), resolved through
- * merges; the path is compressed. */
-function txOf(n) {
-  return (n._x._transaction = resolveTx(n._x._transaction));
-}
-/** `t` resolved through merges while it is still parked or open; null once
- * it has landed. */
-function liveTx(t) {
-  t = resolveTx(t);
-  return transactions.indexOf(t) !== -1 ? t : null;
-}
-function resolveTx(t) {
-  while (t._into !== null) t = t._into;
-  return t;
-}
-/** The flush joins transaction `t` — or needs one of its own (`null`: a pass
- * went pending with nothing held). Joining a second one merges it into the
- * flush's: the work that touched both entangles them (A15). */
-function joinFuture(t) {
-  const f = flushTransaction;
-  if (f === null) {
-    flushTransaction = t === null ? newTransaction(false) : resolveTx(t);
-  } else if (t !== null) merge(resolveTx(t), f);
-  if (!globalQueue._running) schedule();
-}
-/** `t` merges into `f`: the work that touched both entangles them (A15).
- * A lane never merges: it is a sub-frame, not a peer — its work is routed
- * per pass (`passLane`). */
-function merge(t, f) {
-  // Both ends resolved: a stale pointer to a transaction already merged
-  // into the other would close a cycle `resolveTx` never leaves.
-  t = resolveTx(t);
-  f = resolveTx(f);
-  if (t === f || t._lane || f._lane) return;
-  if (attrHooks !== null) attrHooks.transitionMerged(f, t);
-  t._into = f;
-  f._open += t._open;
-  f._acted ||= t._acted;
-  append(f._nodes, t._nodes);
-  append(f._queues[0], t._queues[0]);
-  append(f._queues[1], t._queues[1]);
-  append(f._reruns, t._reruns);
-  if (t._marks !== null) append((f._marks ??= []), t._marks);
-  transactions.splice(transactions.indexOf(t), 1);
+// L2 (step 2): the parked frame. A pass parks the previous frame's children
+// and `_disposal` list on `_x._pendingFirstChild` / `_x._pendingDisposal`
+// (`parkChildren`, core.ts); they keep reacting until the node's commit
+// disposes them (`zombie` walk below) or the owner dies. `markDisposal` flags
+// the parked subtree REACTIVE_ZOMBIE: the splice guard and the reawaken path
+// key off it, and the heap defers a zombie's recompute past the seam (no
+// second heap — the deferral list in scheduler.ts).
+function markDisposal(el) {
+  let child = el._firstChild;
+  while (child) {
+    child._flags |= REACTIVE_ZOMBIE;
+    markDisposal(child);
+    child = child._nextSibling;
+  }
 }
-/** A15: a hold is a property of the async node — observed pending by a
- * render reader. A transaction is blocked while a node it holds, in flight,
- * has one: a pending render effect (the frame itself), or a pending held
- * node a render effect reads. A stale reader served the committed value
- * never went pending, but derives from the flight all the same (#3494) and
- * is still linked to it; a memo between them is pending, and held, too — so
- * one hop of `_subs` is the chain. Reads of the reader's LAST pass only (the
- * link's generation is the pass's): a tail kept for A30 — the committed
- * frame's dependency, awaiting the run that retires it — is not a read of
- * the flight, and a reader that stopped reading releases it (O3, #3494).
- * An errored pass (NotReady included) did not stop: it never got there, and
- * its full list stands (A30) — the reads it did not reach still observe. A
- * flight nobody renders holds nothing (A29). Only the nodes `t` still owns
- * count: one a lane took over since is the lane's to wait on. A guess whose
- * own truth is in flight blocks the lane's parent, not the lane — it stands
- * in for the flight (A17: "visible until its own fetch settles"). */
-function blocked(t) {
-  // The transaction being judged (a lane consulted on its behalf judges for
-  // it): a zombie whose removal it stages is moot for it alone (`onScreen`).
-  const prev = judge;
-  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));
-  judge = prev;
-  return r;
+function dispose(node) {
+  // Direct disposal is death, not dormancy: strip the observation lifecycle
+  // so a later read freezes at the last committed value instead of
+  // reawakening the node (#3024). The teardown itself (heap removal — a node
+  // left queued would be recomputed and resurrected by the next flush (#2983)
+  // — dep unlinking, child disposal) is exactly unobserved()'s body; only
+  // this flag distinguishes death from dormancy.
+  node._config &= ~CONFIG_AUTO_DISPOSE;
+  unobserved(node);
 }
-let judge = null;
-/** Observe tier: the flights `t` waits on — its pending held sources a
- * frame reader observes (`blockedBy`'s predicate, collected; the readers
- * themselves are not sources). */
-function blockersOf(t) {
-  const out = [];
-  for (let i = 0; i < t._nodes.length; i++) {
-    const n = t._nodes[i];
-    if (
-      !n._type &&
-      n._statusFlags & STATUS_PENDING &&
-      !(n._flags & REACTIVE_DISPOSED) &&
-      (n._x._transaction === null || txOf(n) === t) &&
-      blockedBy([n], t)
-    )
-      out.push(n);
+// The first error a cleanup threw, boxed so a thrown `undefined` still
+// counts. A throwing cleanup stops neither its siblings nor the rest of the
+// tree: every cleanup runs. The error is rethrown once the teardown is over:
+// by a root's dispose call outside a flush (`disposeRootSelf`), otherwise when
+// the flush ends (`flush`; `runCleanup` schedules one), so a flush is never
+// left half-applied. A halt drops it: the error that halted is the one
+// reported, and a stale one must not surface from a later, unrelated dispose.
+let cleanupError;
+/** Runs a cleanup or `unobserved` hook; a throw is collected, not raised. @internal */
+function runCleanup(fn) {
+  try {
+    fn();
+  } catch (e) {
+    cleanupError ||= [e];
+    schedule();
   }
-  return out;
 }
-/** `t`'s own flights only — not its lanes': a flight the frame asked for
- * (a refetch, a plain load) is authoritative; a lane's derivation flight is
- * not (lanes.ts, the body-end corollary). A pending reader counts only if
- * one of the sources it waits on is `t`'s (a render effect marked pending
- * by a lane flight, never re-run, is the lane's wait, not the frame's). */
-function ownFlights(t) {
-  return blockedBy(t._nodes, t, true);
+/** Rethrows the error `runCleanup` collected, once; `drop` discards it. @internal */
+function rethrowCleanupError(drop) {
+  const error = cleanupError;
+  cleanupError = undefined;
+  if (error && !drop) throw error[0];
 }
-/** A source the pending node waits on that is `t`'s (held by it, or by no
- * one) — not another transaction's or lane's work. Itself, when it is the
- * source. */
-function ownSource(n, t) {
-  const sources = n._x?._pendingSources;
-  if (sources === undefined) return true;
-  for (const s of sources) {
-    const u = s._x?._transaction;
-    if (u == null || resolveTx(u) === t) return true;
+function disposeChildren(node, self = false, zombie) {
+  const flags = node._flags;
+  if (flags & REACTIVE_DISPOSED) return;
+  // A parked frame dies with its owner (#3024): the commit that would retire
+  // it never comes once the node is DISPOSED, so it drains here or its
+  // cleanups never run and it stays subscribed, rerunning in a torn-down
+  // tree (#3561). Death only (`self`): a re-pass leaves the frame reacting
+  // until the commit.
+  if (
+    self &&
+    !zombie &&
+    node._x !== null &&
+    (node._x._pendingFirstChild !== null || node._x._pendingDisposal !== null)
+  )
+    disposeChildren(node, false, true);
+  if (self) {
+    node._flags = flags | REACTIVE_DISPOSED;
+    if (node._parent === null && node._root) unregisterRoot(node);
   }
-  return false;
-}
-function blockedBy(nodes, owner, own = false) {
-  for (let i = 0; i < nodes.length; i++) {
-    const n = nodes[i];
+  if (self && true) clearSignals(node);
+  if (self && node._fn) {
+    if (node._x !== null) node._x._inFlight = null;
+    // A death that can unblock the future (L2, `futureBlocked`): a held
+    // flight's — a transaction's or a lane's (its `_x._transaction`) — or a
+    // stale reader's (REACTIVE_FRAME_READ — a frame that derived from one).
+    // Nothing else re-examines a dead node, so make sure a seam comes.
     if (
-      !(n._statusFlags & STATUS_PENDING) ||
-      n._flags & REACTIVE_DISPOSED ||
-      n._config & CONFIG_GUESS ||
-      (n._x._transaction !== null && txOf(n) !== owner) ||
-      (own && !ownSource(n, owner))
+      (node._statusFlags & STATUS_PENDING && node._x?._transaction != null) ||
+      flags & REACTIVE_FRAME_READ
     )
-      continue;
-    // The frame's own pending observer (off screen: this one holds nothing;
-    // the next listed node may).
-    if (n._type === EFFECT_RENDER) {
-      if (onScreen(n, judge ?? owner)) return true;
-      continue;
-    }
-    for (let s = n._subs; s !== null; s = s._nextSub) {
-      const r = s._sub;
-      // A frame reader: a render effect, or a stale reader of the flight
-      // (REACTIVE_FRAME_READ — a verdict reader, `observeFlight`; lane work,
-      // `frameRead`): served committed instead of going pending, it derives
-      // from the flight all the same and is re-derived at the landing — the
-      // frame's observation survives its reader becoming a lane's (a guess
-      // over a held window, V5/A17). A probe alone does not hold. A
-      // boundary showing content forwards the pending (its output pending,
-      // CONFIG_REDERIVE): transparent, its readers hold through it (A33; the
-      // lane-membership ruling, 2026-10-05). An output that never committed
-      // shows nothing — a mount the frame has not revealed — and holds
-      // nothing.
-      if (
-        ((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) &&
-        !(r._flags & REACTIVE_DISPOSED) &&
-        onScreen(r, judge ?? owner)
-      )
-        return true;
-    }
+      schedule();
+  }
+  let child = zombie ? node._x._pendingFirstChild : node._firstChild;
+  if (zombie) node._x._pendingFirstChild = null;
+  else node._firstChild = null;
+  while (child) {
+    const n = child;
+    // Owner teardown is death regardless of the child's own lifecycle
+    // (#3024): strip AUTO_DISPOSE so a post-disposal read freezes at the
+    // last committed value instead of reawakening in a torn-down tree.
+    // Runs before the recursion so already-dormant children (whose
+    // disposeChildren call early-returns on REACTIVE_DISPOSED) die too.
+    // Only unobserved()'s own node keeps its dormancy — it is never in
+    // this loop; its children are rebuilt fresh on reawaken.
+    n._config &= ~CONFIG_AUTO_DISPOSE;
+    // Heap removal must not be gated on `_deps`: a dependency-free
+    // computation queued by refresh() has a null dep list but still sits in
+    // the dirty heap, and left there the post-disposal flush recomputes it —
+    // recompute() rewriting `_flags` clears REACTIVE_DISPOSED and the node
+    // comes back to life (post-unmount runs, leaked cleanups, #2983).
+    // deleteFromHeap self-guards on the in-heap flags (and tolerates plain
+    // Owners, whose _flags is undefined), so no gate here.
+    deleteFromHeap(n, dirtyQueue);
+    clearDeps(n);
+    // The chain is detached above so a node a cleanup links mid-drain lands
+    // on the fresh head and survives. Pointing each drained child's prev at
+    // itself routes its later splice onto the detached chain, never the head,
+    // and keeps the dev owner-chain-head invariant honest for those children.
+    child._prevSibling = child;
+    disposeChildren(child, true);
+    // Read after, not before: a sibling this disposal made dormant spliced
+    // itself out of the detached chain, and a cleanup may then have linked
+    // it at the fresh head, which rewrote the `_nextSibling` a pre-read
+    // would still be holding.
+    child = child._nextSibling;
+  }
+  if (!zombie) node._childCount = 0;
+  // O(1) splice out of parent's chain on individual dispose. Skipped during
+  // batch dispose (parent already disposed) and for a zombie (it sits on the
+  // parent's parked frame, drained whole by the commit). We leave
+  // node._nextSibling intact so outer walks that already advanced past us
+  // still reach later siblings.
+  if (
+    self &&
+    !zombie &&
+    !(flags & REACTIVE_ZOMBIE) &&
+    node._parent !== null &&
+    !(node._parent._flags & REACTIVE_DISPOSED)
+  ) {
+    const prev = node._prevSibling;
+    const next = node._nextSibling;
+    // A node with no predecessor must be the chain's head; otherwise the
+    // write below would clobber the head with a stale `_nextSibling`,
+    // orphaning every live child ahead of it (#3543).
+    assertInvariant(
+      prev !== null || node._parent._firstChild === node,
+      "owner-chain-head",
+      "head node is not parent._firstChild — a node was spliced while flagged live but not in the chain (see #3543)"
+    );
+    if (prev !== null) prev._nextSibling = next;
+    else node._parent._firstChild = next;
+    if (next !== null) next._prevSibling = prev;
+    node._prevSibling = null;
+  }
+  runDisposal(node, zombie);
+  // Final effect-returned cleanup fires at true disposal, after `_disposal`
+  // to mirror rerun ordering (compute-phase teardown first, cleanup last).
+  if (self && node._cleanup) {
+    const effectCleanup = node._cleanup;
+    node._cleanup = undefined;
+    enterDisposal();
+    runCleanup(effectCleanup);
+    exitDisposal();
   }
-  return false;
-}
-/** A frame reader whose say counts for `t`'s hold — `t` the transaction
- * being judged: not a zombie whose removal `t` stages (A15 #3463: a re-ask
- * in the unmount frame lands its pending on the zombie it unmounts — the
- * compiled <Show> of #3372; a zombie blocks every other judgment while it
- * is visible, a lane's reveal included: only the commit that disposes it
- * makes its say moot), and not behind a fallback (A33: a boundary showing its fallback is the display of
- * 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))
-  );
-}
-/** 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,
- * except the transaction staging its removal: for that one its say is moot
- * (done, and the commit disposes it; not done, and it stays parked). The
- * staging transaction is the one holding the pass that parked the frame:
- * 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)
-  );
-}
-/** Unchanged passes this flush whose stale dependency tail awaits the
- * flush's verdict (A30, #3469): trimmed when the flush commits, kept when
- * it parks — the committed frame still derives from the previous pass's
- * dependencies, and a write to one of them must reach the node until a
- * committing pass replaces it. */
-const heldTrims = [];
-function heldTrim(el) {
-  heldTrims.push(el);
-}
-/** Zombies popped from the dirty heap this flush (`deferZombie`). The seam
- * decides their fate: a park cancels them (the writes that dirtied them are
- * held with it); a commit runs the survivors — the ones whose owner is still
- * awaiting its commit — in height order, after the commits that would have
- * disposed them (#3546). No second heap: the list is the deferral. */
-const deferredZombies = [];
-function deferZombie(el) {
-  deleteFromHeap(el, dirtyQueue);
-  el._flags &= -4;
-  deferredZombies.push(el);
-}
-/** Put a staged node in a transaction: flagged, stamped, on its landing
- * list. */
-function holdNode(n, t) {
-  n._config |= CONFIG_HELD;
-  list(n, t);
 }
-/** Put a node on a transaction's list, once: a node's `_transaction` is the
- * transaction whose `_nodes` it is on (every site that sets one does the
- * other), so a re-pass, a re-landing or a re-staging adds nothing. */
-function list(n, t) {
-  const x = ext(n);
-  if (x._transaction === t) return;
-  x._transaction = t;
-  t._nodes.push(n);
+function linkChild(parent, node) {
+  const head = parent._firstChild;
+  node._prevSibling = null;
+  node._nextSibling = head;
+  if (head !== null) head._prevSibling = node;
+  parent._firstChild = node;
 }
-/** Hold the (uncommitted) frame under a held pass: every computed in the
- * live child chain, recursively. Plain owners are walked through, not held
- * — nothing reads or re-passes them. Once per park, over the parked frames
- * only; recomputes pay nothing for it. A lane's node in the frame (listed on
- * a lane: a verdict reader broken out of this very hold — display-ahead — or
- * a derivation of a guess, CONFIG_OVERRIDE; a lane pass's effect) is the
- * lane's, as the seam's own loop has it: "lane work never makes its node
- * transaction work" (A15, #3698). Re-listed here it would carry the lane's
- * value on the transaction's list, where the landing nulls its transaction
- * and `dissolveLane` no longer finds it — a lane node with no lane, which the
- * next read of it trips over (`laneRead` → `txOf`). Its frame is the lane's
- * too (ruling A: a lane pass's children are the lane's), revealed and
- * retired at the lane's seam. */
-function holdFrame(owner, t) {
-  for (let c = owner._firstChild; c !== null; c = c._nextSibling) {
-    if (c._x?._transaction?._lane) continue;
-    if (c._fn !== undefined) {
-      if (!(c._config & CONFIG_HELD)) holdNode(c, t);
-      c._config |= CONFIG_HELD_FRAME;
+function runDisposal(node, zombie) {
+  // Detach the list BEFORE running it (#3601), as `_cleanup` is (#2813). A
+  // cleanup that disposes an ancestor re-enters this node through the death
+  // walk while the loop is still running; with the list still attached, that
+  // walk ran every entry a second time. Detached, the re-entrant drain finds
+  // nothing. The same shape latched a throwing cleanup: the list survived the
+  // throw and every later drain re-ran and re-threw it.
+  const disposal = zombie ? node._x._pendingDisposal : node._disposal;
+  if (!disposal) return;
+  if (zombie) node._x._pendingDisposal = null;
+  else node._disposal = null;
+  // Each cleanup is guarded (`runCleanup`), so the depth is always lowered.
+  enterDisposal();
+  if (Array.isArray(disposal)) {
+    // Unwind order (#3572, restores 1.x #1562): later registrations run
+    // before earlier ones. Children have already been disposed by the caller,
+    // so with LIFO a body that registers cleanup before creating its children
+    // tears down after them — the same order a per-component owner gives.
+    for (let i = disposal.length - 1; i >= 0; i--) {
+      runCleanup(disposal[i]);
     }
-    holdFrame(c, t);
+  } else {
+    runCleanup(disposal);
   }
+  exitDisposal();
 }
-const dirtyQueue = {
-  _heap: new Array(2000).fill(undefined),
-  _marked: false,
-  _min: 0,
-  _max: 0
-};
-let clock = 0;
-let scheduled = false;
-let halted = false;
-let haltNotified = false;
-let syncDepth = 0;
-let inTrackedQueueCallback = false;
-let _enforceLoadingBoundary = false;
-let _hitUnhandledAsync = false;
-// Once per enforcement window: the ASYNC_OUTSIDE_LOADING_BOUNDARY finding is a
-// fact about the MOUNT ("the root mount will be deferred"), not about each
-// pending render effect — N async siblings at mount used to produce N copies.
-let _reportedUnhandledAsync = false;
-/**
- * Consume the unhandled-async hit. Returns whether this is the first report
- * of the current enforcement window — the caller warns only then.
- */
-function resetUnhandledAsync() {
-  _hitUnhandledAsync = false;
-  if (_reportedUnhandledAsync) return false;
-  _reportedUnhandledAsync = true;
-  return true;
+function childId(owner, consume) {
+  let counter = owner;
+  while (counter._config & CONFIG_TRANSPARENT && counter._parent) counter = counter._parent;
+  if (counter.id != null)
+    return formatId(counter.id, consume ? counter._childCount++ : counter._childCount);
+  throw new Error("Cannot get child id from owner without an id");
 }
 /**
- * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
- * window. Only `render()` calls this — wrapping the initial mount so that a
- * top-level uncaught async read surfaces the diagnostic. Not part of the
- * user-facing API.
+ * Allocates and returns the next stable child id for `owner`. Used by
+ * hydration plumbing and `createUniqueId`. Not part of the user-facing API.
  *
  * @internal
  */
-function enforceLoadingBoundary(enabled) {
-  _enforceLoadingBoundary = enabled;
-  if (enabled) _reportedUnhandledAsync = false;
-}
-function setTrackedQueueCallback(value) {
-  inTrackedQueueCallback = value;
+function getNextChildId(owner) {
+  return childId(owner, true);
 }
-// Dev-only marker for the effect half of createEffect/createRenderEffect, so
-// flush() can report the no-op instead of failing silently (React parity).
-/** Action bodies on the stack (action.ts): `flush()` is refused inside one —
- * the body's writes are its transaction's and commit when it settles; a
- * drain mid-step cannot reveal them, and dev says so. */
-let actionDepth = 0;
-function enterAction() {
-  actionDepth++;
+/**
+ * The id a freshly-created node inherits: an explicit `options.id` wins;
+ * transparent nodes share their parent's id; otherwise the parent's next
+ * child id is consumed (or `undefined` outside an id-carrying tree).
+ */
+function inheritId(options, transparent, parent) {
+  return (
+    options?.id ??
+    (transparent ? parent?.id : parent?.id != null ? getNextChildId(parent) : undefined)
+  );
 }
-function exitAction() {
-  actionDepth--;
+/**
+ * Returns the *next* child id for `owner` without consuming it. Used by
+ * hydration plumbing to peek at the id a future child will receive.
+ *
+ * @internal
+ */
+function peekNextChildId(owner) {
+  return childId(owner, false);
 }
-/** Provenance (A18, #3331): the question being asked — an action's
- * sequence while a slice of its body and the flush that carries it run, 0
- * otherwise. A guess is stamped with it (lanes.ts; a mainline guess takes a
- * fresh sequence: the newest intent), a flight with the question that
- * started it (async.ts; mainline is always the current question). An
- * answer from an older question than the guess it lands on is stale: held
- * silently, it does not move the graph. */
-let question = 0;
-let questions = 0;
-function setQuestion(q) {
-  question = q;
+function formatId(prefix, id) {
+  const num = id.toString(36),
+    len = num.length - 1;
+  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
 }
-function nextQuestion() {
-  return ++questions;
+/**
+ * Returns the currently-tracking observer (the computation that subscribes to
+ * reactive reads at this point), or `null` if reads here would be untracked.
+ * Used by reactive primitives that need to know whether they're inside a
+ * tracking scope. App code rarely needs this — see `getOwner()` for the
+ * lifecycle owner instead.
+ *
+ * @example
+ * ```ts
+ * // Library predicate: only register a hot-path subscription when the
+ * // caller is inside a tracking scope (memo / effect compute / JSX).
+ * function trackIfTracked(source: () => unknown) {
+ *   if (getObserver()) source();
+ * }
+ * ```
+ */
+function getObserver() {
+  return tracking ? context : null;
 }
-const MAINLINE_QUESTION = 0x7fffffff;
-let inEffectCallback = false;
-function setEffectCallback(value) {
-  inEffectCallback = value;
+/**
+ * Returns the current reactive **owner** — the lifecycle node that the next
+ * `cleanup()` / `onCleanup()` / `createSignal()` etc. will be attached to.
+ *
+ * Returns `null` if called outside any owner. Capture the owner with
+ * `getOwner()` and re-enter it later with `runWithOwner(owner, fn)` to attach
+ * disposables created from a callback (event handler, async resolution, etc.)
+ * back to a component's lifecycle.
+ *
+ * @example
+ * ```ts
+ * function defer<T>(fn: () => T) {
+ *   const owner = getOwner();
+ *   queueMicrotask(() => runWithOwner(owner, fn));
+ * }
+ * ```
+ */
+function getOwner() {
+  return context;
 }
-function schedule() {
-  if (halted) {
-    notifyHalted();
-    return;
-  }
-  if (scheduled) return;
-  scheduled = true;
-  if (!syncDepth && !globalQueue._running) {
-    queueMicrotask(flush);
-  }
+/**
+ * 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; `owner`
+ * (internal) targets a specific owner's disposal list instead of the ambient
+ * one.
+ */
+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;
 }
 /**
- * Permanently halts the reactive system. Called when a user error escapes
- * every boundary — app state is undefined at that point, so scheduling stops
- * entirely rather than limping along with a half-applied update.
+ * Returns `true` if the owner has been disposed. Pair with a captured owner
+ * to bail out of late callbacks whose surrounding component already
+ * unmounted.
+ *
+ * @example
+ * ```ts
+ * function onSettleSafe(fn: () => void) {
+ *   const owner = getOwner();
+ *   queueMicrotask(() => {
+ *     if (owner && isDisposed(owner)) return; // component unmounted; skip
+ *     runWithOwner(owner, fn);
+ *   });
+ * }
+ * ```
  */
+function isDisposed(node) {
+  return !!(node._flags & REACTIVE_DISPOSED);
+}
+function disposeRootSelf(self = true) {
+  disposeChildren(this, self);
+  // Outside a flush the dispose call rethrows; inside one, the flush does.
+  // Kept out of `disposeChildren`, whose hot path it slows.
+  if (cleanupError && !globalQueue._running) rethrowCleanupError();
+}
 /**
- * The key a root owner carries its client error hook under (`render`'s
- * `onError`) — registered, so a runtime writes it with no import of the hook
- * module (core/error-hooks.ts) and no property mangling in the way. Defined
- * HERE, not there: a runtime that only writes the key must not retain the
- * hook machinery (pay-for-use).
+ * Creates a fresh owner attached as a child of the current owner (or as a
+ * detached root if there is none). Used by framework internals to group
+ * cleanups; app code should use `createRoot()` (host a reactive scope outside
+ * a component) or `runWithOwner()` (re-enter a captured owner).
+ *
+ * @internal
  */
-const ROOT_ERROR_HOOK = Symbol.for("solid-js/root-error-hook");
-function haltReactivity(cause) {
-  if (halted) return;
-  halted = true;
-  let message = "[REACTIVITY_HALTED]";
-  {
-    message +=
-      " An uncaught error halted the reactive system. No further updates will be processed. Handle errors with <Errored> or treat this as a crash.";
+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` 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,
+    _nextSibling: null,
+    _prevSibling: null,
+    _disposal: null,
+    _context: parent?._context || defaultContext,
+    _childCount: 0,
+    _x: null,
+    _parent: parent,
+    dispose: disposeRootSelf,
+    _name: undefined,
+    _loc: undefined
+  };
+  if (parent && parent._config & CONFIG_CHILDREN_FORBIDDEN) {
     emitDiagnostic({
-      code: "REACTIVITY_HALTED",
-      kind: "error",
+      code: "PRIMITIVE_IN_FORBIDDEN_SCOPE",
+      kind: "lifecycle",
       severity: "error",
-      message
+      message: PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE,
+      ownerId: parent.id,
+      ownerName: parent._name
     });
+    throw new Error(PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE);
   }
-  // Surface the cause here too: callers rethrow it, but a creation-time throw
-  // unwinds through ancestor recomputes that convert it to status instead of
-  // surfacing it (#2884), so the rethrow alone cannot guarantee visibility.
-  // Where the platform has one, hand the cause to its uncaught-error channel
-  // (`reportError` → `error` event → window.onerror / error monitoring): a
-  // halt that only reaches console.error leaves a page that LOOKS alive with
-  // nothing an app or its telemetry can act on (#3338 — an uncaught throw
-  // during the hydration render). The rethrow may reach the top as well in
-  // the non-swallowed cases; a duplicate report beats a silent one.
-  const report = cause !== undefined && globalThis.reportError;
-  report || cause === undefined ? console.error(message) : console.error(message, cause);
-  report && report(cause);
+  assertNotInEffectCallback();
+  if (parent) linkChild(parent, owner);
+  else registerRoot(owner);
+  DEV.hooks.onOwner?.(owner);
+  return owner;
 }
-// Logs on the first write after a halt so a frozen interaction is traceable.
-function notifyHalted() {
-  if (haltNotified) return;
-  haltNotified = true;
-  console.error(
-    "[REACTIVITY_HALTED] Update ignored: the reactive system was halted by an earlier uncaught error."
-  );
+/**
+ * Creates a reactive root — an owner scope with its own `dispose()`. A root
+ * created inside an existing owner is owned by it and is disposed when the
+ * parent is disposed; call `dispose()` to tear it down earlier. To create a
+ * root that outlives its creator, detach explicitly:
+ * `runWithOwner(null, () => createRoot(...))`. Pass `id` to seed hydration
+ * ids for the tree it owns.
+ *
+ * `dispose()` tears down every signal, memo, effect, and `onCleanup`
+ * registered inside the root.
+ *
+ * Use this to host long-lived reactive scopes outside of a component (custom
+ * controllers, app bootstrapping, tests). Inside a component, prefer
+ * letting Solid's component lifecycle own things.
+ *
+ * @example
+ * ```ts
+ * // At module level there is no owner, so this root lives until disposed.
+ * const dispose = createRoot(dispose => {
+ *   const [n, setN] = createSignal(0);
+ *   createEffect(() => n(), value => console.log(value));
+ *   setInterval(() => setN(x => x + 1), 1000);
+ *   return dispose;
+ * });
+ *
+ * // Later, to tear everything down:
+ * dispose();
+ *
+ * // Inside an owner (component, effect, another root), detach explicitly
+ * // if the root must outlive its creator:
+ * const detached = runWithOwner(null, () => createRoot(d => d));
+ * ```
+ *
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/owner-introspection/create-root
+ */
+function createRoot(init, options) {
+  const owner = createOwner(options);
+  // 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)));
 }
-/** @internal Test/dev-reload hook. Revives scheduling after a halt. */
-function resetErrorHalt() {
-  halted = false;
-  haltNotified = false;
+
+// 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;
 }
-class GlobalQueue {
-  _queues = [[], []];
-  _running = false;
-  flush() {
-    if (this._running) return;
-    this._running = true;
-    // A28: companions of nodes written since the last flush mirror the
-    // flushed world — re-synced inside the running window (the write is
-    // "flushed" from here on).
-    resyncUnflushedCompanions();
-    passLane = null;
-    passTx = null;
-    try {
-      // Sweep before the heap: unobserved() pulls swept nodes out of it, so
-      // a dormant memo dirtied in the same tick is reclaimed instead of
-      // recomputed; late subscribers (an effect reading a swept memo this
-      // flush) revive it, which is the pay-for-use contract.
-      sweepDormant();
-      runHeap(dirtyQueue, GlobalQueue._update);
-      this.settle();
-      clock++;
-      // A write the commit sweep staged with no subscriber to dirty is work
-      // too — the next round commits it.
-      scheduled = dirtyQueue._max >= dirtyQueue._min || pendingNodes.length !== 0;
-      this.run(EFFECT_RENDER);
-      this.run(EFFECT_USER);
-      if (true && holding) {
-        holding = false;
-        attrHooks.holdEnd();
-      }
-      if (true && !scheduled) {
-        // Fully drained: no staged value may survive this point unqueued or
-        // unheld.
-        devCheckQuiescent(
-          n => pendingNodes.includes(n) || (n._config & (CONFIG_HELD | CONFIG_OVERRIDE)) !== 0
-        );
-      }
-      if (true) DEV.hooks.onUpdate?.();
-    } finally {
-      this._running = false;
-      passTx = null;
-    }
+/** Live transactions — opened, unmerged, not landed. Scanned at every seam
+ * while non-empty; nothing on the plain path. */
+const transactions = [];
+/** Observe tier: this flush parked its transaction (`holdStart` fired). */
+let holding = false;
+/** A transaction (listed here) or a lane (lanes.ts lists its own). */
+function newTransaction(lane, parent = null) {
+  const t = {
+    _nodes: [],
+    _queues: [[], []],
+    _reruns: [],
+    _into: null,
+    _parent: parent,
+    _lane: lane,
+    _verdict: null,
+    _open: 0,
+    _acted: false,
+    _links: null,
+    _shown: false,
+    _held: false,
+    _marks: null
+  };
+  if (!lane) transactions.push(t);
+  return t;
+}
+// Lanes (plan sec. 28, 2026-10-02; lanes.ts). A lane is "a new base of a transition":
+// the sub-frame an optimistic write opens in the transition of the frame it
+// is made in. It sees the screen plus its own guesses (plan sec. 19), breaks out of
+// the parent's hold — its effects run now — and holds itself if its own
+// derivations hit async. It ends when the parent lands: a guess reverts to
+// the truth it covered, or lands as the truth that superseded it. A frame
+// that does not park has nothing to be optimistic over: the write is void.
+//
+// The seat of a pass is its node's: a node carrying a lane's value runs as
+// the lane's whoever dirtied it; a derivation's tracked read of a lane's
+// value moves its pass into the lane; a leaf's never does (it reads the
+// screen). Lane work's values go to the lane slot, its runs to the lane's
+// queues; the rest of the frame is the flush's.
+/** The lane the running pass is work of; set at `recompute`'s head from the
+ * node, moved by a derivation's lane read, saved and restored around the
+ * pass. */
+let passLane = null;
+function setPassLane(l) {
+  passLane = l;
+}
+/** The transaction this flush parks into: set by the first join, merged
+ * with every further one. Consumed at the seam. A join outside a flush (a
+ * mount's pending observer, a write to a held node, an action opening)
+ * schedules the seam that consumes it: membership is the tick's — the same
+ * synchronous frame — and the next tick's writes are not this one's. */
+let flushTransaction = null;
+/** The transaction the passes running OUTSIDE a flush this tick derive from
+ * (a mainline mount, a mainline re-pass): the passes' own (A29, creation-
+ * time form — "the entry is the pass's alone"): their results are staged
+ * into it, and nothing else in the tick is — a write made after the mount
+ * is a mainline write, a render effect mounted beside it a stale reader.
+ * Inside a flush, or in a tick that already has its transaction (an
+ * action's body), the frame joins instead (`flushTransaction`) — except a
+ * first pass a loading boundary that has not shown content catches (`own`,
+ * A29's boundary exemption, #3540): it is the boundary's, not the tick's,
+ * and a flush that has joined nothing keeps it pass-scoped as outside one.
+ * Cleared by the flush the join schedules, and at the end of a flush that
+ * set it. */
+let passTx = null;
+function joinPassTx(t, own) {
+  if ((globalQueue._running && !own) || flushTransaction !== null) return joinFuture(t);
+  if (passTx === null) passTx = resolveTx(t);
+  else merge(resolveTx(t), passTx);
+  schedule();
+}
+/** The transaction holding a node (CONFIG_HELD set), resolved through
+ * merges; the path is compressed. */
+function txOf(n) {
+  return (n._x._transaction = resolveTx(n._x._transaction));
+}
+/** `t` resolved through merges while it is still parked or open; null once
+ * it has landed. */
+function liveTx(t) {
+  t = resolveTx(t);
+  return transactions.indexOf(t) !== -1 ? t : null;
+}
+function resolveTx(t) {
+  while (t._into !== null) t = t._into;
+  return t;
+}
+/** The flush joins transaction `t` — or needs one of its own (`null`: a pass
+ * went pending with nothing held). Joining a second one merges it into the
+ * flush's: the work that touched both entangles them (A15). */
+function joinFuture(t) {
+  const f = flushTransaction;
+  if (f === null) {
+    flushTransaction = t === null ? newTransaction(false) : resolveTx(t);
+  } else if (t !== null) merge(resolveTx(t), f);
+  if (!globalQueue._running) schedule();
+}
+/** `t` merges into `f`: the work that touched both entangles them (A15).
+ * A lane never merges: it is a sub-frame, not a peer — its work is routed
+ * per pass (`passLane`). */
+function merge(t, f) {
+  // Both ends resolved: a stale pointer to a transaction already merged
+  // into the other would close a cycle `resolveTx` never leaves.
+  t = resolveTx(t);
+  f = resolveTx(f);
+  if (t === f || t._lane || f._lane) return;
+  if (attrHooks !== null) attrHooks.transitionMerged(f, t);
+  t._into = f;
+  f._open += t._open;
+  f._acted ||= t._acted;
+  append(f._nodes, t._nodes);
+  append(f._queues[0], t._queues[0]);
+  append(f._queues[1], t._queues[1]);
+  append(f._reruns, t._reruns);
+  if (t._marks !== null) append((f._marks ??= []), t._marks);
+  transactions.splice(transactions.indexOf(t), 1);
+}
+/** A15: a hold is a property of the async node — observed pending by a
+ * render reader. A transaction is blocked while a node it holds, in flight,
+ * has one: a pending render effect (the frame itself), or a pending held
+ * node a render effect reads. A stale reader served the committed value
+ * never went pending, but derives from the flight all the same (#3494) and
+ * is still linked to it; a memo between them is pending, and held, too — so
+ * one hop of `_subs` is the chain. Reads of the reader's LAST pass only (the
+ * link's generation is the pass's): a tail kept for A30 — the committed
+ * frame's dependency, awaiting the run that retires it — is not a read of
+ * the flight, and a reader that stopped reading releases it (O3, #3494).
+ * An errored pass (NotReady included) did not stop: it never got there, and
+ * its full list stands (A30) — the reads it did not reach still observe. A
+ * flight nobody renders holds nothing (A29). Only the nodes `t` still owns
+ * count: one a lane took over since is the lane's to wait on. A guess whose
+ * own truth is in flight blocks the lane's parent, not the lane — it stands
+ * in for the flight (A17: "visible until its own fetch settles"). */
+function blocked(t) {
+  // The transaction being judged (a lane consulted on its behalf judges for
+  // it): a zombie whose removal it stages is moot for it alone (`onScreen`).
+  const prev = judge;
+  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) || !!lanesBlockedHook?.(t);
+  judge = prev;
+  return r;
+}
+let judge = null;
+/** Observe tier: the flights `t` waits on — its pending held sources a
+ * frame reader observes (`blockedBy`'s predicate, collected; the readers
+ * themselves are not sources). */
+function blockersOf(t) {
+  const out = [];
+  for (let i = 0; i < t._nodes.length; i++) {
+    const n = t._nodes[i];
+    if (
+      !n._type &&
+      n._statusFlags & STATUS_PENDING &&
+      !(n._flags & REACTIVE_DISPOSED) &&
+      (n._x._transaction === null || txOf(n) === t) &&
+      blockedBy([n], t)
+    )
+      out.push(n);
   }
-  /** L2 — the seam: end of the pure phase. Commit this flush's staged nodes,
-   * or park them with the transaction the flush joined; then land every
-   * transaction no frame is waiting on. The landing flush is an ordinary
-   * flush: the settle walk (async.ts) re-ran the parked readers in its pure
-   * phase, and here no flight the transaction holds has a frame deriving
-   * from it (`blocked`). */
-  settle() {
-    // 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);
-    const joined = flushTransaction;
-    flushTransaction = null;
-    // The frame's verdict is in: the guesses written since the last seam
-    // open their lane under the frame's transaction (a lane's own flush
-    // parents a nested lane to it), or are dropped — the frame commits, and
-    // 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);
-    // 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.)
-    const t = joined !== null && !joined._lane ? resolveTx(joined) : null;
-    if (t !== null) {
-      // `t._nodes` grows under the walk (holdFrame pushes); the bound is
-      // this flush's list, which does not.
-      const count = pendingNodes.length;
-      for (let i = 0; i < count; i++) {
-        const n = pendingNodes[i];
-        // Already held: the pass that re-staged it joined its transaction,
-        // which is `t` (or merged into it). Lane work is the lane's (a
-        // pending mark propagated onto it queued it here too).
-        if (
-          !(n._config & (CONFIG_HELD | CONFIG_OVERRIDE)) &&
-          (n._x === null || n._x._transaction === null || !n._x._transaction._lane)
-        ) {
-          // A loading source — pending with nothing staged and no committed
-          // value (A16, A19 exc. 1: uninitialized is loading, not pending)
-          // that is not an observer — is nobody's frame: not held. Its
-          // first landing is commit #0, not a resumption of this frame, and
-          // a write that reaches it later overlaps nothing (#2937: the
-          // stale stamp was the bridge that entangled unrelated updates
-          // with a never-resolving flight). Its observers are held and
-          // wait on its flight (`blocked`).
-          if (
-            n._pendingValue === NOT_PENDING &&
-            n._statusFlags & STATUS_UNINITIALIZED &&
-            n._type !== EFFECT_RENDER
-          )
-            continue;
-          // A34 (2): a tick whose writes net to the committed value made no
-          // proposal (`setShow(false); setShow(true)` on a committed true) —
-          // not staged, not held, pends nothing; a later write to it is
-          // plain mainline. (A node already held stays held when written
-          // back: A34 (1).)
-          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._pendingValue = NOT_PENDING;
-            n._config &= ~CONFIG_STAGED;
-            continue;
-          }
-          holdNode(n, t);
-        }
-        // A held pass's frame is held with it (ruling A, O2): the children it
-        // created are the transaction's — they compute, and a pass over them
-        // or a write that reaches them joins; they effect at the landing.
-        if (n._config & CONFIG_STAGED) holdFrame(n, t);
-      }
-      pendingNodes.length = 0;
-      GlobalQueue._storePark?.(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.)
-      // The batch joins: the writes that dirtied these are held with it — a
-      // zombie never displays that world. A verdict reader among them does
-      // (#3444: `latest()` inside a branch a held Show is removing peers
-      // 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]);
-      // The unchanged passes' tails stay linked (A30, #3469): their inputs
-      // are held, and the committed frame still derives from them — no trim.
-    } else {
-      commitPendingNodes();
-      // The flush committed: an unchanged pass's stale tail goes now. Not
-      // after a later pass this flush that threw (NotReady included — it
-      // keeps its full list, `_depsTail` marking where it stopped) or that
-      // left an effect owing a run (`runEffect` trims when the run applies):
-      // `recompute`'s own gates.
-      for (let i = 0; i < heldTrims.length; i++) {
-        const t = heldTrims[i];
-        if (t._x?._error == null && !t._modified) trimStaleDeps(t);
-      }
-    }
-    // The list is the flush's either way. Reset only when there is something
-    // to reset (`stagedReaders` below likewise): `length = 0` is a runtime
-    // call even on an empty array, and the plain flush — no unchanged pass,
-    // no lane work — has nothing in either.
-    if (heldTrims.length) heldTrims.length = 0;
-    // Lanes: a blocked one parks its frame (its own flight is up); an
-    // unblocked one reveals this round's work. Then land every transaction
-    // no frame is waiting on — its lanes end with it. Backwards: a landing
-    // removes its entry.
-    // This flush's own runs, the lanes' reveals, and the landings' held runs
-    // are collected apart and ordered below.
-    const own = this._queues;
-    const lanes = (this._queues = [[], []]);
-    // 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;
-    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);
-      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") —
-      // judge them again.
-      k = transactions.length;
-    }
-    // The store folds the pending backings whose container nodes committed
-    // — this flush's, or a landing's (store/store.ts installs it).
-    GlobalQueue._storeCommit?.();
-    // 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).
-    const live = t && liveTx(t);
-    GlobalQueue._releaseAmbientMarks?.(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
-    // re-derived at the landing before a boundary swap held since the
-    // 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 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(live);
-      holding = true;
-    }
-    for (let i = 0; i < 2; 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
-      // builds the ordered queue above.
-      this._queues[i] =
-        parked || lanes[i].length || this._queues[i].length
-          ? lanes[i].concat(parked ? [] : own[i], this._queues[i])
-          : own[i];
-    }
-    if (deferredZombies.length !== 0) {
-      // Survivors are the displayed frame of a held pass: they rerun for the
-      // live write, parents before children.
-      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)) recompute(zombies[i]);
-      }
-    }
-    // Boundaries: readers that settled, landed or died this flush are
-    // dropped; a fallback with none left reveals next round.
-    GlobalQueue._boundarySeam?.();
+  return out;
+}
+/** `t`'s own flights only — not its lanes': a flight the frame asked for
+ * (a refetch, a plain load) is authoritative; a lane's derivation flight is
+ * not (lanes.ts, the body-end corollary). A pending reader counts only if
+ * one of the sources it waits on is `t`'s (a render effect marked pending
+ * by a lane flight, never re-run, is the lane's wait, not the frame's). */
+function ownFlights(t) {
+  return blockedBy(t._nodes, t, true);
+}
+/** A source the pending node waits on that is `t`'s (held by it, or by no
+ * one) — not another transaction's or lane's work. Itself, when it is the
+ * source. */
+function ownSource(n, t) {
+  const sources = n._x?._pendingSources;
+  if (sources === undefined) return true;
+  for (const s of sources) {
+    const u = s._x?._transaction;
+    if (u == null || resolveTx(u) === t) return true;
   }
-  run(type) {
-    const effects = this._queues[type - 1];
-    if (effects.length) {
-      this._queues[type - 1] = [];
-      runQueue(effects, type);
+  return false;
+}
+function blockedBy(nodes, owner, own = false) {
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    if (
+      !(n._statusFlags & STATUS_PENDING) ||
+      n._flags & REACTIVE_DISPOSED ||
+      n._config & CONFIG_GUESS ||
+      (n._x._transaction !== null && txOf(n) !== owner) ||
+      (own && !ownSource(n, owner))
+    )
+      continue;
+    // The frame's own pending observer (off screen: this one holds nothing;
+    // the next listed node may).
+    if (n._type === EFFECT_RENDER) {
+      if (onScreen(n, judge ?? owner)) return true;
+      continue;
     }
-  }
-  enqueue(type, fn, lane = passLane) {
-    // Lane work's runs are the lane's: they run at its reveal, not with
-    // the frame (which may park). A lane pass that read the frame's own
-    // staging is the frame's (`recompute` passes null): its run waits with
-    // the frame.
-    if (type) (lane !== null ? lane : this)._queues[type - 1].push(fn);
-    schedule();
-  }
-  /** Status reaching the root: pending is absorbed (the root mount defers —
-   * dev records it for the ASYNC_OUTSIDE_LOADING_BOUNDARY FYI); an error is
-   * unhandled (`false` → the caller halts).
-   *
-   * L2: this is where a transaction is registered. Pending that reaches an
-   * observer (a render effect: the frame) is a frame that cannot show — the
-   * flush parks, and the transaction waits on the flight while a frame
-   * derives from it (`blocked`). Pending nobody observes holds nothing: a
-   * memo in flight that no frame reads is not a frame waiting. (Base: the
-   * queue's `_asyncReporters`, INV-3's one registration site.)
-   *
-   * A boundary between the observer and the root (boundaries.ts) is asked
-   * 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 (mask & STATUS_PENDING) {
-      if (flags & STATUS_PENDING) {
-        if (_enforceLoadingBoundary) _hitUnhandledAsync = true;
-        // A pass that went pending holds its frame: the async's own
-        // synchronous frame is not ready (A15 reveal corollary: a reveal
-        // that discovers a flight whose inputs are visible holds and joins
-        // it; one whose inputs are held is a stale reader and never gets
-        // here — `read` serves it the committed value). The frame's, not the
-        // observer's: a render effect belongs to whoever dirtied its pass
-        // (A15 shared-hole, #3407) — one held by T1 and re-run by T2's write
-        // pends for T2's flight, and the two stay parallel; a frame that is
-        // T1's already joined T1 through the write or the memo that made it
-        // so. Outside a flush — root setup, a mount — the frame is the
-        // mount's: its pending observers are one transaction, and a flight
-        // started in it resumes it when it lands (maintainer, #3461: "part
-        // of the same one"); what the mount published synchronously stays
-        // published. Lane work going pending holds the lane, not the frame:
-        // `blocked(lane)` finds it in the lane's staging ("if further async
-        // downstream is hit it holds like its own transition").
-        if (passLane === null) joinFuture(null);
-      }
-      return true;
+    for (let s = n._subs; s !== null; s = s._nextSub) {
+      const r = s._sub;
+      // A frame reader: a render effect, or a stale reader of the flight
+      // (REACTIVE_FRAME_READ — a verdict reader, `observeFlight`; lane work,
+      // `frameRead`): served committed instead of going pending, it derives
+      // from the flight all the same and is re-derived at the landing — the
+      // frame's observation survives its reader becoming a lane's (a guess
+      // over a held window, V5/A17). A probe alone does not hold. A
+      // boundary showing content forwards the pending (its output pending,
+      // CONFIG_REDERIVE): transparent, its readers hold through it (A33; the
+      // lane-membership ruling, 2026-10-05). An output that never committed
+      // shows nothing — a mount the frame has not revealed — and holds
+      // nothing.
+      if (
+        ((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) &&
+        !(r._flags & REACTIVE_DISPOSED) &&
+        onScreen(r, judge ?? owner)
+      )
+        return true;
     }
-    return false;
   }
+  return false;
+}
+/** A frame reader whose say counts for `t`'s hold — `t` the transaction
+ * being judged: not a zombie whose removal `t` stages (A15 #3463: a re-ask
+ * in the unmount frame lands its pending on the zombie it unmounts — the
+ * compiled <Show> of #3372; a zombie blocks every other judgment while it
+ * is visible, a lane's reveal included: only the commit that disposes it
+ * makes its say moot), and not behind a fallback (A33: a boundary showing its fallback is the display of
+ * 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)) && !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,
+ * except the transaction staging its removal: for that one its say is moot
+ * (done, and the commit disposes it; not done, and it stays parked). The
+ * staging transaction is the one holding the pass that parked the frame:
+ * the nearest non-zombie ancestor. */
+function removalStagedBy(r, t) {
+  let o = r;
+  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
+ * it parks — the committed frame still derives from the previous pass's
+ * dependencies, and a write to one of them must reach the node until a
+ * committing pass replaces it. */
+const heldTrims = [];
+function heldTrim(el) {
+  heldTrims.push(el);
+}
+/** Zombies popped from the dirty heap this flush (`deferZombie`). The seam
+ * decides their fate: a park cancels them (the writes that dirtied them are
+ * held with it); a commit runs the survivors — the ones whose owner is still
+ * awaiting its commit — in height order, after the commits that would have
+ * disposed them (#3546). No second heap: the list is the deferral. */
+const deferredZombies = [];
+function deferZombie(el) {
+  deleteFromHeap(el, dirtyQueue);
+  el._flags &= -4;
+  deferredZombies.push(el);
+}
+/** Put a staged node in a transaction: flagged, stamped, on its landing
+ * list. */
+function holdNode(n, t) {
+  n._config |= CONFIG_HELD;
+  list(n, t);
 }
-/** A15's stale readers: a frame whose LAST pass read a held node as
- * committed re-derives on the landed world — next round, after the commits.
- * One re-derived since (any later pass cleared the bit: in the transaction,
- * or without the held read) owes nothing. A run this transaction stashed
- * for it is void (#3322: an effect has one value slot, and the stale pass
- * overwrote the value that run was for) — the re-derivation's run replaces
- * it. */
-function reruns(u) {
-  for (let i = 0; i < u._reruns.length; i++) {
-    const r = u._reruns[i];
-    // An errored reader's display is its error (D-39): the landing gives it
-    // nothing to re-derive, and a re-run would be a read that retries the
-    // errored source (#3945).
-    if (r._flags & REACTIVE_DISPOSED || r._statusFlags & STATUS_ERROR) continue;
-    if (r._flags & REACTIVE_FRAME_READ || r._config & CONFIG_VERDICT) {
-      r._flags &= ~REACTIVE_FRAME_READ;
-      r._modified = false;
-      // Its frame is replaced by the re-derivation: a run one of its
-      // children queued this flush (re-run by the same landing) is for the
-      // frame being replaced — void too (#3404).
-      for (let c = r._firstChild; c !== null; c = c._nextSibling) if (c._type) c._modified = false;
-      enqueueSub(r);
+/** Put a node on a transaction's list, once: a node's `_transaction` is the
+ * transaction whose `_nodes` it is on (every site that sets one does the
+ * other), so a re-pass, a re-landing or a re-staging adds nothing. */
+function list(n, t) {
+  const x = ext(n);
+  if (x._transaction === t) return;
+  x._transaction = t;
+  t._nodes.push(n);
+}
+/** Hold the (uncommitted) frame under a held pass: every computed in the
+ * live child chain, recursively. Plain owners are walked through, not held
+ * — nothing reads or re-passes them. Once per park, over the parked frames
+ * only; recomputes pay nothing for it. A lane's node in the frame (listed on
+ * a lane: a verdict reader broken out of this very hold — display-ahead — or
+ * a derivation of a guess, CONFIG_OVERRIDE; a lane pass's effect) is the
+ * lane's, as the seam's own loop has it: "lane work never makes its node
+ * transaction work" (A15, #3698). Re-listed here it would carry the lane's
+ * value on the transaction's list, where the landing nulls its transaction
+ * and `dissolveLane` no longer finds it — a lane node with no lane, which the
+ * next read of it trips over (`laneRead` → `txOf`). Its frame is the lane's
+ * too (ruling A: a lane pass's children are the lane's), revealed and
+ * retired at the lane's seam. */
+function holdFrame(owner, t) {
+  for (let c = owner._firstChild; c !== null; c = c._nextSibling) {
+    if (c._x?._transaction?._lane) continue;
+    if (c._fn !== undefined) {
+      if (!(c._config & CONFIG_HELD)) holdNode(c, t);
+      c._config |= CONFIG_HELD_FRAME;
     }
+    holdFrame(c, t);
   }
-  u._reruns.length = 0;
 }
-/** The landing: the held frame becomes the frame. */
-function land(u) {
-  // Attribution hook: judged complete — its held writes commit next
-  // (`_nodes` still lists them).
-  if (attrHooks !== null) attrHooks.transitionSettled(u);
-  reruns(u);
-  if (u._marks !== null) GlobalQueue._releaseMarks(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.
-  for (let i = 0; i < u._nodes.length; i++) {
-    const n = u._nodes[i];
-    if (n._x._transaction === null || txOf(n) !== u) continue;
-    n._x._transaction = null;
-    commitPendingNode(n);
+/** 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);
   }
-  releaseQueues(u);
 }
-/** The held runs join this flush's effect phase after its own runs (the
- * landing's re-passes, in height order): the frame's effects run as one
- * pass would have queued them — a shell re-derived at the landing before a
- * boundary swap held since the write (#3540's log order). */
-function releaseQueues(u) {
-  for (let i = 0; i < 2; i++) {
-    append(globalQueue._queues[i], u._queues[i]);
-    u._queues[i] = [];
-  }
+/** `n` leaves the hold it was staged in: its next pass publishes mainline. */
+function unhold(n) {
+  n._x._transaction = null;
+  n._config &= ~CONFIG_HELD;
 }
-/** `a.push(...b)` without the argument-count limit. */
-function append(a, b) {
-  for (let i = 0; i < b.length; i++) a.push(b[i]);
+const dirtyQueue = {
+  _heap: new Array(2000).fill(undefined),
+  _marked: false,
+  _min: 0,
+  _max: 0
+};
+let clock = 0;
+let scheduled = false;
+let halted = false;
+let haltNotified = false;
+// Dev: where the halt happened (the owner path and source lines of its
+// diagnostic), repeated on the "Update ignored" notice so a frozen interaction
+// points back at the computation that threw (#4178).
+let haltedAt = "";
+// Dev: the computation the halt in progress is located at (haltReactivityAt).
+let haltSubject;
+let syncDepth = 0;
+let inTrackedQueueCallback = false;
+let _enforceLoadingBoundary = false;
+let _hitUnhandledAsync = false;
+// Once per enforcement window: the ASYNC_OUTSIDE_LOADING_BOUNDARY finding is a
+// fact about the MOUNT ("the root mount will be deferred"), not about each
+// pending render effect — N async siblings at mount used to produce N copies.
+let _reportedUnhandledAsync = false;
+/**
+ * Consume the unhandled-async hit. Returns whether this is the first report
+ * of the current enforcement window — the caller warns only then.
+ */
+function resetUnhandledAsync() {
+  _hitUnhandledAsync = false;
+  if (_reportedUnhandledAsync) return false;
+  _reportedUnhandledAsync = true;
+  return true;
 }
-/** Nodes staged this flush (`_pendingValue` set), committed at its end. */
-const pendingNodes = [];
-/** Passes that read a staging of this flush as the screen — lane work
- * (core.ts `stagedRead`), a verdict reader before the frame's verdict
- * (verdict.ts): if the frame parks they read a held write — re-derived next
- * round (lanes.ts; a lane's runs wait that round). */
-const stagedReaders = [];
-/** A15's stale reader: `c` was served the committed value of a node `t`
- * holds (a render effect, a verdict reader, lane work) and is re-derived
- * after `t`'s landing (`_reruns`). Once per pass. */
-function staleReader(c, t) {
-  if (!(c._flags & REACTIVE_FRAME_READ)) {
-    c._flags |= REACTIVE_FRAME_READ;
-    t._reruns.push(c);
-  }
+/**
+ * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
+ * window. Only `render()` calls this — wrapping the initial mount so that a
+ * top-level uncaught async read surfaces the diagnostic. Not part of the
+ * user-facing API.
+ *
+ * @internal
+ */
+function enforceLoadingBoundary(enabled) {
+  _enforceLoadingBoundary = enabled;
+  if (enabled) _reportedUnhandledAsync = false;
 }
-function queuePendingNode(node) {
-  lastStagedNodeName = node._name ?? null;
-  pendingNodes.push(node);
-  if (!globalQueue._running) markUnflushedStaged(); // A28
+function setTrackedQueueCallback(value) {
+  inTrackedQueueCallback = value;
 }
-// Dev-only attribution for the flush loop guard (#3140): when the guard
-// trips, naming what the loop kept chewing on lets the app author attribute
-// the runaway without patching dist.
-let lastStagedNodeName = null;
-/** §12d: bumped by every recompute and every new subscriber edge. A node's
- * staged-rewrite skip is sound only while NOTHING recomputed or linked since
- * its last notify — a mid-batch pull can clean a marked subscriber, and a
- * skipped re-write would leave it stale. */
-let notifyEpoch = 0;
-function bumpNotifyEpoch() {
-  notifyEpoch++;
+// Dev-only marker for the effect half of createEffect/createRenderEffect, so
+// flush() can report the no-op instead of failing silently (React parity).
+/** Action bodies on the stack (action.ts): `flush()` is refused inside one —
+ * the body's writes are its transaction's and commit when it settles; a
+ * drain mid-step cannot reveal them, and dev says so. */
+let actionDepth = 0;
+function enterAction() {
+  actionDepth++;
 }
-function insertSubs(node) {
-  // §12d: stamp before walking — setSignal's staged-rewrite fast path skips
-  // the next walk for this node while the epoch holds (marking is idempotent).
-  node._notifiedAt = notifyEpoch;
-  // Presence bits gate the optional-slot probes (see constants.ts): one
-  // masked read of the always-present _config instead of missing-property
-  // lookups in the hottest notify loop.
-  const cfg = node._config;
-  const hasSnapshot = (cfg & CONFIG_HAS_SNAPSHOT) !== 0 && node._x?._snapshotValue !== undefined;
-  // Observe-tier fan-out: this walk visits every subscriber edge anyway, so
-  // the graph-size count is one local increment here and no field anywhere.
-  let fanOut = 0;
-  for (let s = node._subs; s !== null; s = s._nextSub) {
-    const sub = s._sub;
-    fanOut++;
-    // Missed-wake latch (#3037): this write is landing while the subscriber
-    // is mid-recompute (a nested pull committing beneath its reads), and the
-    // heap refuses RECOMPUTING nodes. A gen-current link means the pass
-    // already validated this dep — the value it read is now stale — so latch
-    // for recompute's tail to reschedule. Untouched links need no latch (the
-    // pass either re-reads them fresh or trims them), and neither does the
-    // tail link: it is the read IN FLIGHT — read() links before it pulls, so
-    // this very commit is what that read returns.
-    if (sub._flags & REACTIVE_RECOMPUTING_DEPS && s._gen === sub._depGen && s !== sub._depsTail)
-      sub._flags |= REACTIVE_MISSED_WAKE;
-    if (hasSnapshot && sub._config & CONFIG_IN_SNAPSHOT_SCOPE) {
-      sub._flags |= REACTIVE_SNAPSHOT_STALE;
-      continue;
-    }
-    enqueueSub(sub);
+function exitAction() {
+  actionDepth--;
+}
+/** Provenance (A18, #3331): the question being asked — an action's
+ * sequence while a slice of its body and the flush that carries it run, 0
+ * otherwise. A guess is stamped with it (lanes.ts; a mainline guess takes a
+ * fresh sequence: the newest intent), a flight with the question that
+ * started it (async.ts; mainline is always the current question). An
+ * answer from an older question than the guess it lands on is stale: held
+ * silently, it does not move the graph. */
+let question = 0;
+let questions = 0;
+function setQuestion(q) {
+  question = q;
+}
+function nextQuestion() {
+  return ++questions;
+}
+const MAINLINE_QUESTION = 0x7fffffff;
+let inEffectCallback = false;
+function setEffectCallback(value) {
+  inEffectCallback = value;
+}
+function schedule() {
+  if (halted) {
+    notifyHalted();
+    return;
+  }
+  if (scheduled) return;
+  scheduled = true;
+  if (!syncDepth && !globalQueue._running) {
+    queueMicrotask(flush);
   }
-  if (fanOut >= GRAPH_SIZE_WARN_AT) noteFanOut(node, fanOut);
 }
-/** Lane work re-staged (lanes.ts; `recompute`): the lane's members among
- * its subscribers re-derive as the lane's work (REACTIVE_LANE_DIRTY), their
- * runs held with it — not as stale readers republishing the committed view
- * (#3460). After `insertSubs`. A render effect on no lane is marked too:
- * inert for its pass (`recompute` seats a lane only from its own `_x`), it
- * is a live write if the effect becomes a zombie later this flush — an
- * on-screen reader whose removal an adopted write stages follows the lane
- * (the lane-membership ruling, 2026-10-05; `_update`). */
-function laneDirty(node, l) {
-  for (let s = node._subs; s !== null; s = s._nextSub) {
-    const t = s._sub._x?._transaction;
-    if (t?._lane ? sameLane(t, l) : s._sub._type) s._sub._flags |= REACTIVE_LANE_DIRTY;
+/**
+ * Permanently halts the reactive system. Called when a user error escapes
+ * every boundary — app state is undefined at that point, so scheduling stops
+ * entirely rather than limping along with a half-applied update.
+ */
+/**
+ * The key a root owner carries its client error hook under (`render`'s
+ * `onError`) — registered, so a runtime writes it with no import of the hook
+ * module (core/error-hooks.ts) and no property mangling in the way. Defined
+ * HERE, not there: a runtime that only writes the key must not retain the
+ * hook machinery (pay-for-use).
+ */
+const ROOT_ERROR_HOOK = Symbol.for("solid-js/root-error-hook");
+function haltReactivity(cause) {
+  if (halted) return;
+  halted = true;
+  // A cleanup error collected before the halt is dropped (owner.ts).
+  rethrowCleanupError(true);
+  let message = "[REACTIVITY_HALTED]";
+  {
+    message +=
+      " An uncaught error halted the reactive system. No further updates will be processed. Handle errors with <Errored> or treat this as a crash.";
+    // Located at the computation the error escaped from when the call site
+    // named it (haltReactivityAt), so the console says where it happened
+    // (`in <App> › <Composer>`), not only that it did (#4178). Otherwise the
+    // ambient owner, as every other diagnostic.
+    const entry = emitDiagnostic(
+      {
+        code: "REACTIVITY_HALTED",
+        kind: "error",
+        severity: "error",
+        message
+      },
+      haltSubject
+    );
+    haltedAt = locationLines(entry);
+    message += haltedAt;
   }
+  // Surface the cause here too: callers rethrow it, but a creation-time throw
+  // unwinds through ancestor recomputes that convert it to status instead of
+  // surfacing it (#2884), so the rethrow alone cannot guarantee visibility.
+  // Where the platform has one, hand the cause to its uncaught-error channel
+  // (`reportError` → `error` event → window.onerror / error monitoring): a
+  // halt that only reaches console.error leaves a page that LOOKS alive with
+  // nothing an app or its telemetry can act on (#3338 — an uncaught throw
+  // during the hydration render). The rethrow may reach the top as well in
+  // the non-swallowed cases; a duplicate report beats a silent one.
+  const report = cause !== undefined && globalThis.reportError;
+  report || cause === undefined ? console.error(message) : console.error(message, cause);
+  report && report(cause);
 }
-/** One lane, or two of one link group (#3335): one reveal unit. */
-function sameLane(a, b) {
-  return a === b || (a._links !== null && a._links === b._links);
+/**
+ * Dev: `haltReactivity`, located at `subject` — the computation the uncaught
+ * error escaped from — for the REACTIVITY_HALTED message's owner path. Call
+ * sites pick it in dev builds only (`haltReactivity(e)` in production), so
+ * production keeps the one-argument halt and its bytes unchanged.
+ */
+function haltReactivityAt(cause, subject) {
+  haltSubject = subject;
+  haltReactivity(cause);
+  haltSubject = undefined;
 }
-function commitPendingNode(n) {
-  const c = n;
-  // L2: the commit is where a pass, held or not, stops being uncommitted —
-  // unless it has no answer yet. A pass still in flight (pending, nothing
-  // staged) stays uncommitted: a re-pass disposes its children on the spot,
-  // and the frame it parked stays the frame until a pass of this node
-  // commits a value.
-  if (!c._fn) {
-    n._config &= -385;
-    if (n._pendingValue !== NOT_PENDING) {
-      n._value = n._pendingValue;
-      n._pendingValue = NOT_PENDING;
+// Logs on the first write after a halt so a frozen interaction is traceable.
+function notifyHalted() {
+  if (haltNotified) return;
+  haltNotified = true;
+  console.error(
+    "[REACTIVITY_HALTED] Update ignored: the reactive system was halted by an earlier uncaught error." +
+      haltedAt
+  );
+}
+/** @internal Test/dev-reload hook. Revives scheduling after a halt. */
+function resetErrorHalt() {
+  halted = false;
+  haltNotified = false;
+  haltedAt = "";
+}
+class GlobalQueue {
+  _queues = [[], []];
+  _running = false;
+  flush() {
+    if (this._running) return;
+    this._running = true;
+    // A28: companions of nodes written since the last flush mirror the
+    // flushed world — re-synced inside the running window (the write is
+    // "flushed" from here on).
+    resyncUnflushedCompanions();
+    passLane = null;
+    passTx = null;
+    try {
+      // Sweep before the heap: unobserved() pulls swept nodes out of it, so
+      // a dormant memo dirtied in the same tick is reclaimed instead of
+      // recomputed; late subscribers (an effect reading a swept memo this
+      // flush) revive it, which is the pay-for-use contract.
+      sweepDormant();
+      runHeap(dirtyQueue, GlobalQueue._update);
+      this.settle();
+      clock++;
+      // A write the commit sweep staged with no subscriber to dirty is work
+      // too — the next round commits it.
+      scheduled = dirtyQueue._max >= dirtyQueue._min || pendingNodes.length !== 0;
+      this.run(EFFECT_RENDER);
+      this.run(EFFECT_USER);
+      if (true && holding) {
+        holding = false;
+        attrHooks.holdEnd();
+      }
+      if (true && !scheduled) {
+        // Fully drained: no staged value may survive this point unqueued or
+        // unheld.
+        devCheckQuiescent(
+          n => pendingNodes.includes(n) || (n._config & (CONFIG_HELD | CONFIG_OVERRIDE)) !== 0
+        );
+      }
+      if (true) DEV.hooks.onUpdate?.();
+    } finally {
+      this._running = false;
+      passTx = null;
     }
-    return;
   }
-  // Computeds only from here (`_statusFlags` is not a signal field). A
-  // 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 & -1048833) | CONFIG_INPUTS_PUBLISHED : n._config & -1049985;
-  if (n._pendingValue !== NOT_PENDING) {
-    n._value = n._pendingValue;
-    n._pendingValue = NOT_PENDING;
-    // A node born staged (recompute) initializes at this commit.
-    c._statusFlags &= ~STATUS_UNINITIALIZED;
-    // A quiet re-ask's classification survives its landing and dies with
-    // the landed value's commit (A19 exc. 2, #3178): verdict-quiet through
-    // the reveal. (The sweep of a node still in flight is not a landing.)
-    // The A28 stash goes with it.
-    if (c._x != null) ((c._x._reask = false), (c._x._flushed = NOT_PENDING));
-    // An effect with a staged value was born held (L2): its first run is
-    // this commit's, not its creation's (A29) — queue it now.
-    if (n._type && n._type !== EFFECT_TRACKED) {
-      n._modified = true;
-      globalQueue.enqueue(n._type, (n._boundRunEffect ??= GlobalQueue._runEffect.bind(null, c)));
+  /** L2 — the seam: end of the pure phase. Commit this flush's staged nodes,
+   * or park them with the transaction the flush joined; then land every
+   * transaction no frame is waiting on. The landing flush is an ordinary
+   * flush: the settle walk (async.ts) re-ran the parked readers in its pure
+   * phase, and here no flight the transaction holds has a frame deriving
+   * from it (`blocked`). */
+  settle() {
+    // 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 (laneCorrectionsHook?.()) runHeap(dirtyQueue, GlobalQueue._update);
+    const joined = flushTransaction;
+    flushTransaction = null;
+    // The frame's verdict is in: the guesses written since the last seam
+    // open their lane under the frame's transaction (a lane's own flush
+    // parents a nested lane to it), or are dropped — the frame commits, and
+    // 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.
+    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.)
+    const t = joined !== null && !joined._lane ? resolveTx(joined) : null;
+    if (t !== null) {
+      // `t._nodes` grows under the walk (holdFrame pushes); the bound is
+      // this flush's list, which does not.
+      const count = pendingNodes.length;
+      for (let i = 0; i < count; i++) {
+        const n = pendingNodes[i];
+        // Already held: the pass that re-staged it joined its transaction,
+        // which is `t` (or merged into it). Lane work is the lane's (a
+        // pending mark propagated onto it queued it here too).
+        if (
+          !(n._config & (CONFIG_HELD | CONFIG_OVERRIDE)) &&
+          (n._x === null || n._x._transaction === null || !n._x._transaction._lane)
+        ) {
+          // A loading source — pending with nothing staged and no committed
+          // value (A16, A19 exc. 1: uninitialized is loading, not pending)
+          // that is not an observer — is nobody's frame: not held. Its
+          // first landing is commit #0, not a resumption of this frame, and
+          // a write that reaches it later overlaps nothing (#2937: the
+          // stale stamp was the bridge that entangled unrelated updates
+          // with a never-resolving flight). Its observers are held and
+          // wait on its flight (`blocked`).
+          if (
+            n._pendingValue === NOT_PENDING &&
+            n._statusFlags & STATUS_UNINITIALIZED &&
+            n._type !== EFFECT_RENDER
+          )
+            continue;
+          // A34 (2): a tick whose writes net to the committed value made no
+          // proposal (`setShow(false); setShow(true)` on a committed true) —
+          // not staged, not held, pends nothing; a later write to it is
+          // plain mainline. (A node already held stays held when written
+          // back: A34 (1).)
+          if (
+            n._pendingValue !== NOT_PENDING &&
+            !(n._statusFlags & (STATUS_PENDING | STATUS_UNINITIALIZED)) &&
+            n._x?._pendingFirstChild == 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;
+            continue;
+          }
+          holdNode(n, t);
+        }
+        // A held pass's frame is held with it (ruling A, O2): the children it
+        // created are the transaction's — they compute, and a pass over them
+        // or a write that reaches them joins; they effect at the landing.
+        if (n._config & CONFIG_STAGED) holdFrame(n, t);
+      }
+      pendingNodes.length = 0;
+      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.)
+      // The batch joins: the writes that dirtied these are held with it — a
+      // zombie never displays that world. A verdict reader among them does
+      // (#3444: `latest()` inside a branch a held Show is removing peers
+      // 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).
+      // (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 {
+      commitPendingNodes();
+      // The flush committed: an unchanged pass's stale tail goes now. Not
+      // after a later pass this flush that threw (NotReady included — it
+      // keeps its full list, `_depsTail` marking where it stopped) or that
+      // left an effect owing a run (`runEffect` trims when the run applies):
+      // `recompute`'s own gates.
+      for (let i = 0; i < heldTrims.length; i++) {
+        const t = heldTrims[i];
+        if (t._x?._error == null && !t._modified) trimStaleDeps(t);
+      }
     }
-  }
-  // The committed value is the first observable answer for a loading-window
-  // node — the window closes here, not at compute time (#2990). Unconditional
-  // store to an always-present computed slot.
-  c._loading = false;
-  c._flags &= ~REACTIVE_MANUAL_WRITE;
-  // The dependencies of the pass that produced the value are the frame's now:
-  // the previous frame's tail goes (A30, #3410; `recompute` left it for a
-  // staged pass). Only after a clean pass: `_error` is cleared by a clean
-  // pass or by the node's own landing (whose pass was clean), so a set
-  // `_error` means the last pass threw, kept its full list, and `_depsTail`
-  // marks where it stopped.
-  if (c._x?._error == null) trimStaleDeps(c);
-  if (!(c._statusFlags & STATUS_PENDING)) c._statusFlags &= ~STATUS_UNINITIALIZED;
-  // L2: the children this commit publishes are the frame's now — the frame
-  // they replace, parked by the pass (`recompute`), goes.
-  if (
-    !inFlight &&
-    c._x != null &&
-    (c._x._pendingFirstChild !== null || c._x._pendingDisposal !== null)
-  )
-    GlobalQueue._dispose(c, false, true);
-}
-function commitPendingNodes() {
-  for (let i = 0; i < pendingNodes.length; i++) {
-    const n = pendingNodes[i];
-    // A node a lane pass re-staged this round is the lane's to reveal; one
-    // a transaction holds (born held by a mainline pass, `passTx`) is that
-    // transaction's to commit, at its landing.
-    if (!(n._config & (CONFIG_OVERRIDE | CONFIG_HELD))) commitPendingNode(n);
-  }
-  pendingNodes.length = 0;
-}
-const globalQueue = new GlobalQueue();
-function flush(fn) {
-  if (actionDepth > 0) {
-    {
-      throw new Error(
-        "[FLUSH_IN_ACTION] flush() inside an action body is not allowed. An action's writes are held in its " +
-          "transaction and commit when the action settles: flush() cannot reveal them, and draining here would " +
-          "detach the writes that follow from the transaction. Remove the flush(); to observe the result, read " +
-          "after the action resolves."
-      );
+    // The list is the flush's either way. Reset only when there is something
+    // to reset (`stagedReaders` below likewise): `length = 0` is a runtime
+    // call even on an empty array, and the plain flush — no unchanged pass,
+    // no lane work — has nothing in either.
+    if (heldTrims.length) heldTrims.length = 0;
+    // Lanes: a blocked one parks its frame (its own flight is up); an
+    // unblocked one reveals this round's work. Then land every transaction
+    // no frame is waiting on — its lanes end with it. Backwards: a landing
+    // removes its entry.
+    // This flush's own runs, the lanes' reveals, and the landings' held runs
+    // are collected apart and ordered below.
+    const own = this._queues;
+    const lanes = (this._queues = [[], []]);
+    // 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).
+    if (laneSeamsHook) {
+      laneSeamsHook(t !== null ? stagedReaders : null);
+      if (stagedReaders.length) stagedReaders.length = 0;
     }
-  }
-  if (fn) {
-    syncDepth++;
-    try {
-      return fn();
-    } finally {
-      // Decrement even if the drain throws (a throwing effect): a leaked
-      // syncDepth would stop `schedule()` from ever queuing a microtask again.
-      try {
-        flush();
-      } finally {
-        syncDepth--;
-      }
+    this._queues = [[], []];
+    for (let k = transactions.length - 1; k >= 0; k--) {
+      const u = transactions[k];
+      if (blocked(u)) continue;
+      transactions.splice(k, 1);
+      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") —
+      // judge them again.
+      k = transactions.length;
     }
-  }
-  if (globalQueue._running) {
-    if (inTrackedQueueCallback) {
-      throw new Error(
-        "Cannot call flush() from inside onSettled or createTrackedEffect. flush() is not reentrant there. " +
-          "Writes made here are processed in the same flush's continuation; to force a drain afterwards, defer it: queueMicrotask(() => flush())."
-      );
+    // The store folds the pending backings whose container nodes committed
+    // — this flush's, or a landing's (store/store.ts installs it).
+    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).
+    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
+    // re-derived at the landing before a boundary swap held since the
+    // 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 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(live);
+      holding = true;
     }
-    if (inEffectCallback) {
-      const message =
-        "[FLUSH_IN_EFFECT_CALLBACK] flush() called from inside an effect callback is a no-op: the flush that runs effects is already in progress. " +
-        "Writes made here are processed in the same flush's continuation; to force a drain afterwards, defer it: queueMicrotask(() => flush()).";
-      reportDiagnostic(
-        emitDiagnostic({
-          code: "FLUSH_IN_EFFECT_CALLBACK",
-          kind: "lifecycle",
-          severity: "warn",
-          message
-        })
-      );
+    for (let i = 0; i < 2; 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
+      // builds the ordered queue above.
+      this._queues[i] =
+        parked || lanes[i].length || this._queues[i].length
+          ? lanes[i].concat(parked ? [] : own[i], this._queues[i])
+          : own[i];
     }
-    return;
-  }
-  if (halted) return;
-  let count = 0;
-  // Attribution: whether this call drained anything, so `flushEnd` fires once
-  // per real drain and never for a no-op call. The declaration is dead in
-  // prod (its only write is behind true) and rollup drops it.
-  let drained = false;
-  // The drain's opening instant, under the loop's own condition so it fires
-  // exactly when `flushEnd` below will. Outside every try (see the rule in
-  // attribution-hooks.ts).
-  if (attrHooks !== null && scheduled) attrHooks.flushStart();
-  while (scheduled) {
-    if (++count === 1e5) {
-      // Attribution beats a bare guard (#3140): say what kept the loop alive.
-      throw new Error(
-        `Potential Infinite Loop Detected. Kept alive by scheduled work${lastStagedNodeName ? `; last staged node: ${lastStagedNodeName}` : ""}`
-      );
+    if (deferredZombies.length !== 0) {
+      // Survivors are the displayed frame of a held pass: they rerun for the
+      // live write, parents before children.
+      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)) recompute(zombies[i]);
+      }
     }
-    globalQueue.flush();
-    drained = true;
+    // Boundaries: readers that settled, landed or died this flush are
+    // dropped; a fallback with none left reveals next round.
+    boundarySeamHook?.();
   }
-  // Outside every try in this function (see the rule in attribution-hooks.ts):
-  // the drain loop above is the one place all scheduled work funnels through,
-  // so this is the "committed and effects ran" instant for everything the
-  // loop processed.
-  if (drained && attrHooks !== null) attrHooks.flushEnd();
-}
-function runQueue(queue, type) {
-  for (let i = 0; i < queue.length; i++) queue[i](type);
-}
-
-/**
- * Schedule one subscriber to re-run on the next flush: inserted into the
- * dirty heap with the `_min` cursor pulled down. Tracked effects ride the
- * heap too — the heap visit is their (empty) compute phase, which hands the
- * callback to the user queue once the pass has committed (see
- * GlobalQueue._update, #3291).
- */
-function enqueueSub(node) {
-  if (dirtyQueue._min > node._height) dirtyQueue._min = node._height;
-  insertIntoHeap(node, dirtyQueue);
-}
-function actualInsertIntoHeap(n, heap) {
-  const parentHeight =
-    (n._parent?._root ? n._parent._parentComputed?._height : n._parent?._height) ?? -1;
-  if (parentHeight >= n._height) n._height = parentHeight + 1;
-  const height = n._height;
-  const heapAtHeight = heap._heap[height];
-  if (heapAtHeight === undefined) heap._heap[height] = n;
-  else {
-    const tail = heapAtHeight._prevHeap;
-    tail._nextHeap = n;
-    n._prevHeap = tail;
-    heapAtHeight._prevHeap = n;
+  run(type) {
+    const effects = this._queues[type - 1];
+    if (effects.length) {
+      this._queues[type - 1] = [];
+      runQueue(effects, type);
+    }
   }
-  if (height > heap._max) heap._max = height;
-}
-function insertIntoHeap(n, heap) {
-  let flags = n._flags;
-  // RECOMPUTING refusals are not always losses: a genuinely missed wake (a
-  // write to a link this pass already validated) is latched link-side in
-  // insertSubs as REACTIVE_MISSED_WAKE for recompute's tail (#3037).
-  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
-  if (flags & REACTIVE_CHECK) {
-    n._flags = (flags & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
-  } else {
-    n._flags = flags | REACTIVE_IN_HEAP;
-    // An unmarked node entering an already-marked heap is marked on the
-    // spot, keeping the markHeap memo valid. `_marked` is only reset by
-    // runHeap, so a write between two mid-tick pulls (read-time markHeap +
-    // updateIfNecessary) would otherwise leave this node unmarked and every
-    // downstream pull stale until the next flush (#2922: the second
-    // `latest()` returned the first write's value). Invalidating the memo
-    // instead re-walked the WHOLE heap on the next pull — with N effects
-    // parked in the heap for a synchronous mount (each row writing a ref
-    // signal its effect subscribes to), mounting N rows was O(N²) (#3350).
-    // markNode's own guard skips an already-DIRTY node.
-    if (heap._marked) markNode(n);
+  enqueue(type, fn, lane = passLane) {
+    // Lane work's runs are the lane's: they run at its reveal, not with
+    // the frame (which may park). A lane pass that read the frame's own
+    // staging is the frame's (`recompute` passes null): its run waits with
+    // the frame.
+    if (type) (lane !== null ? lane : this)._queues[type - 1].push(fn);
+    schedule();
   }
-  if (!(flags & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(n, heap);
-}
-function insertIntoHeapHeight(n, heap) {
-  let flags = n._flags;
-  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
-  n._flags = flags | REACTIVE_IN_HEAP_HEIGHT;
-  actualInsertIntoHeap(n, heap);
-}
-function deleteFromHeap(n, heap) {
-  const flags = n._flags;
-  if (!(flags & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-  n._flags = flags & -25;
-  const height = n._height;
-  if (n._prevHeap === n) heap._heap[height] = undefined;
-  else {
-    const next = n._nextHeap;
-    const dhh = heap._heap[height];
-    const end = next ?? dhh;
-    if (n === dhh) heap._heap[height] = next;
-    else n._prevHeap._nextHeap = next;
-    end._prevHeap = n._prevHeap;
+  /** Status reaching the root: pending is absorbed (the root mount defers —
+   * dev records it for the ASYNC_OUTSIDE_LOADING_BOUNDARY FYI); an error is
+   * unhandled (`false` → the caller halts).
+   *
+   * L2: this is where a transaction is registered. Pending that reaches an
+   * observer (a render effect: the frame) is a frame that cannot show — the
+   * flush parks, and the transaction waits on the flight while a frame
+   * derives from it (`blocked`). Pending nobody observes holds nothing: a
+   * memo in flight that no frame reads is not a frame waiting. (Base: the
+   * queue's `_asyncReporters`, INV-3's one registration site.)
+   *
+   * A boundary between the observer and the root (boundaries.ts) is asked
+   * first: a fallback catches what is not ready under it, and the root
+   * never hears of it. */
+  notify(node, mask, flags, error) {
+    if (catchHook?.(node, flags & mask, error)) return true;
+    if (mask & STATUS_PENDING) {
+      if (flags & STATUS_PENDING) {
+        if (_enforceLoadingBoundary) _hitUnhandledAsync = true;
+        // A pass that went pending holds its frame: the async's own
+        // synchronous frame is not ready (A15 reveal corollary: a reveal
+        // that discovers a flight whose inputs are visible holds and joins
+        // it; one whose inputs are held is a stale reader and never gets
+        // here — `read` serves it the committed value). The frame's, not the
+        // observer's: a render effect belongs to whoever dirtied its pass
+        // (A15 shared-hole, #3407) — one held by T1 and re-run by T2's write
+        // pends for T2's flight, and the two stay parallel; a frame that is
+        // T1's already joined T1 through the write or the memo that made it
+        // so. Outside a flush — root setup, a mount — the frame is the
+        // mount's: its pending observers are one transaction, and a flight
+        // started in it resumes it when it lands (maintainer, #3461: "part
+        // of the same one"); what the mount published synchronously stays
+        // published. Lane work going pending holds the lane, not the frame:
+        // `blocked(lane)` finds it in the lane's staging ("if further async
+        // downstream is hit it holds like its own transition").
+        if (passLane === null) joinFuture(null);
+      }
+      return true;
+    }
+    return false;
   }
-  n._prevHeap = n;
-  n._nextHeap = undefined;
 }
-function markHeap(heap) {
-  if (heap._marked) return;
-  heap._marked = true;
-  for (let i = 0; i <= heap._max; i++) {
-    for (let el = heap._heap[i]; el !== undefined; el = el._nextHeap) {
-      if (el._flags & REACTIVE_IN_HEAP) markNode(el);
+/** A15's stale readers: a frame whose LAST pass read a held node as
+ * committed re-derives on the landed world — next round, after the commits.
+ * One re-derived since (any later pass cleared the bit: in the transaction,
+ * or without the held read) owes nothing. A run this transaction stashed
+ * for it is void (#3322: an effect has one value slot, and the stale pass
+ * overwrote the value that run was for) — the re-derivation's run replaces
+ * it. */
+function reruns(u) {
+  for (let i = 0; i < u._reruns.length; i++) {
+    const r = u._reruns[i];
+    // An errored reader's display is its error (D-39): the landing gives it
+    // nothing to re-derive, and a re-run would be a read that retries the
+    // errored source (#3945).
+    if (r._flags & REACTIVE_DISPOSED || r._statusFlags & STATUS_ERROR) continue;
+    if (r._flags & REACTIVE_FRAME_READ || r._config & CONFIG_VERDICT) {
+      r._flags &= ~REACTIVE_FRAME_READ;
+      r._modified = false;
+      // Its frame is replaced by the re-derivation: a run one of its
+      // children queued this flush (re-run by the same landing) is for the
+      // frame being replaced — void too (#3404).
+      for (let c = r._firstChild; c !== null; c = c._nextSibling) if (c._type) c._modified = false;
+      enqueueSub(r);
     }
   }
+  u._reruns.length = 0;
 }
-function markNode(el, newState = REACTIVE_DIRTY) {
-  const flags = el._flags;
-  if ((flags & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= newState) return;
-  el._flags = (flags & -4) | newState;
-  for (let link = el._subs; link !== null; link = link._nextSub) {
-    markNode(link._sub, REACTIVE_CHECK);
+/** The landing: the held frame becomes the frame. */
+function land(u) {
+  // Attribution hook: judged complete — its held writes commit next
+  // (`_nodes` still lists them).
+  if (attrHooks !== null) attrHooks.transitionSettled(u);
+  reruns(u);
+  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.
+  for (let i = 0; i < u._nodes.length; i++) {
+    const n = u._nodes[i];
+    if (n._x._transaction === null || txOf(n) !== u) continue;
+    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);
 }
-function runHeap(heap, recompute) {
-  heap._marked = false;
-  for (heap._min = 0; heap._min <= heap._max; heap._min++) {
-    let el = heap._heap[heap._min];
-    while (el !== undefined) {
-      if (el._flags & REACTIVE_IN_HEAP) recompute(el);
-      else adjustHeight(el, heap);
-      el = heap._heap[heap._min];
-    }
+/** The held runs join this flush's effect phase after its own runs (the
+ * landing's re-passes, in height order): the frame's effects run as one
+ * pass would have queued them — a shell re-derived at the landing before a
+ * boundary swap held since the write (#3540's log order). */
+function releaseQueues(u) {
+  for (let i = 0; i < 2; i++) {
+    append(globalQueue._queues[i], u._queues[i]);
+    u._queues[i] = [];
   }
-  heap._max = 0;
 }
-function adjustHeight(el, heap) {
-  deleteFromHeap(el, heap);
-  let newHeight = el._height;
-  for (let d = el._deps; d; d = d._nextDep) {
-    const dep = d._dep;
-    if (dep._fn && dep._height >= newHeight) newHeight = dep._height + 1;
-  }
-  if (el._height !== newHeight) {
-    el._height = newHeight;
-    for (let s = el._subs; s !== null; s = s._nextSub) insertIntoHeapHeight(s._sub, heap);
-  }
+/** `a.push(...b)` without the argument-count limit. */
+function append(a, b) {
+  for (let i = 0; i < b.length; i++) a.push(b[i]);
 }
-
-// L2 (step 2): the parked frame. A pass parks the previous frame's children
-// and `_disposal` list on `_x._pendingFirstChild` / `_x._pendingDisposal`
-// (`parkChildren`, core.ts); they keep reacting until the node's commit
-// disposes them (`zombie` walk below) or the owner dies. `markDisposal` flags
-// the parked subtree REACTIVE_ZOMBIE: the splice guard and the reawaken path
-// key off it, and the heap defers a zombie's recompute past the seam (no
-// second heap — the deferral list in scheduler.ts).
-function markDisposal(el) {
-  let child = el._firstChild;
-  while (child) {
-    child._flags |= REACTIVE_ZOMBIE;
-    markDisposal(child);
-    child = child._nextSibling;
+/** Nodes staged this flush (`_pendingValue` set), committed at its end. */
+const pendingNodes = [];
+/** Passes that read a staging of this flush as the screen — lane work
+ * (core.ts `stagedRead`), a verdict reader before the frame's verdict
+ * (verdict.ts): if the frame parks they read a held write — re-derived next
+ * round (lanes.ts; a lane's runs wait that round). */
+const stagedReaders = [];
+/** A15's stale reader: `c` was served the committed value of a node `t`
+ * holds (a render effect, a verdict reader, lane work) and is re-derived
+ * after `t`'s landing (`_reruns`). Once per pass. */
+function staleReader(c, t) {
+  if (!(c._flags & REACTIVE_FRAME_READ)) {
+    c._flags |= REACTIVE_FRAME_READ;
+    t._reruns.push(c);
   }
 }
-function dispose(node) {
-  // Direct disposal is death, not dormancy: strip the observation lifecycle
-  // so a later read freezes at the last committed value instead of
-  // reawakening the node (#3024). The teardown itself (heap removal — a node
-  // left queued would be recomputed and resurrected by the next flush (#2983)
-  // — dep unlinking, child disposal) is exactly unobserved()'s body; only
-  // this flag distinguishes death from dormancy.
-  node._config &= ~CONFIG_AUTO_DISPOSE;
-  unobserved(node);
+function queuePendingNode(node) {
+  lastStagedNodeName = node._name ?? null;
+  pendingNodes.push(node);
+  if (!globalQueue._running) markUnflushedStaged(); // A28
 }
-function disposeChildren(node, self = false, zombie) {
-  const flags = node._flags;
-  if (flags & REACTIVE_DISPOSED) return;
-  // A parked frame dies with its owner (#3024): the commit that would retire
-  // it never comes once the node is DISPOSED, so it drains here or its
-  // cleanups never run and it stays subscribed, rerunning in a torn-down
-  // tree (#3561). Death only (`self`): a re-pass leaves the frame reacting
-  // until the commit.
-  if (
-    self &&
-    !zombie &&
-    node._x !== null &&
-    (node._x._pendingFirstChild !== null || node._x._pendingDisposal !== null)
-  )
-    disposeChildren(node, false, true);
-  if (self) {
-    node._flags = flags | REACTIVE_DISPOSED;
-    if (node._parent === null && node._root) unregisterRoot(node);
-  }
-  if (self && true) clearSignals(node);
-  if (self && node._fn) {
-    if (node._x !== null) node._x._inFlight = null;
-    // A death that can unblock the future (L2, `futureBlocked`): a held
-    // flight's — a transaction's or a lane's (its `_x._transaction`) — or a
-    // stale reader's (REACTIVE_FRAME_READ — a frame that derived from one).
-    // Nothing else re-examines a dead node, so make sure a seam comes.
-    if (
-      (node._statusFlags & STATUS_PENDING && node._x?._transaction != null) ||
-      flags & REACTIVE_FRAME_READ
-    )
-      schedule();
-  }
-  let child = zombie ? node._x._pendingFirstChild : node._firstChild;
-  if (zombie) node._x._pendingFirstChild = null;
-  else node._firstChild = null;
-  while (child) {
-    const n = child;
-    // Owner teardown is death regardless of the child's own lifecycle
-    // (#3024): strip AUTO_DISPOSE so a post-disposal read freezes at the
-    // last committed value instead of reawakening in a torn-down tree.
-    // Runs before the recursion so already-dormant children (whose
-    // disposeChildren call early-returns on REACTIVE_DISPOSED) die too.
-    // Only unobserved()'s own node keeps its dormancy — it is never in
-    // this loop; its children are rebuilt fresh on reawaken.
-    n._config &= ~CONFIG_AUTO_DISPOSE;
-    // Heap removal must not be gated on `_deps`: a dependency-free
-    // computation queued by refresh() has a null dep list but still sits in
-    // the dirty heap, and left there the post-disposal flush recomputes it —
-    // recompute() rewriting `_flags` clears REACTIVE_DISPOSED and the node
-    // comes back to life (post-unmount runs, leaked cleanups, #2983).
-    // deleteFromHeap self-guards on the in-heap flags (and tolerates plain
-    // Owners, whose _flags is undefined), so no gate here.
-    deleteFromHeap(n, dirtyQueue);
-    clearDeps(n);
-    // The chain is detached above so a node a cleanup links mid-drain lands
-    // on the fresh head and survives. Pointing each drained child's prev at
-    // itself routes its later splice onto the detached chain, never the head,
-    // and keeps the dev owner-chain-head invariant honest for those children.
-    child._prevSibling = child;
-    disposeChildren(child, true);
-    // Read after, not before: a sibling this disposal made dormant spliced
-    // itself out of the detached chain, and a cleanup may then have linked
-    // it at the fresh head, which rewrote the `_nextSibling` a pre-read
-    // would still be holding.
-    child = child._nextSibling;
-  }
-  if (!zombie) node._childCount = 0;
-  // O(1) splice out of parent's chain on individual dispose. Skipped during
-  // batch dispose (parent already disposed) and for a zombie (it sits on the
-  // parent's parked frame, drained whole by the commit). We leave
-  // node._nextSibling intact so outer walks that already advanced past us
-  // still reach later siblings.
-  if (
-    self &&
-    !zombie &&
-    !(flags & REACTIVE_ZOMBIE) &&
-    node._parent !== null &&
-    !(node._parent._flags & REACTIVE_DISPOSED)
-  ) {
-    const prev = node._prevSibling;
-    const next = node._nextSibling;
-    // A node with no predecessor must be the chain's head; otherwise the
-    // write below would clobber the head with a stale `_nextSibling`,
-    // orphaning every live child ahead of it (#3543).
-    assertInvariant(
-      prev !== null || node._parent._firstChild === node,
-      "owner-chain-head",
-      "head node is not parent._firstChild — a node was spliced while flagged live but not in the chain (see #3543)"
-    );
-    if (prev !== null) prev._nextSibling = next;
-    else node._parent._firstChild = next;
-    if (next !== null) next._prevSibling = prev;
-    node._prevSibling = null;
+// Dev-only attribution for the flush loop guard (#3140): when the guard
+// trips, naming what the loop kept chewing on lets the app author attribute
+// the runaway without patching dist.
+let lastStagedNodeName = null;
+/** §12d: bumped by every recompute and every new subscriber edge. A node's
+ * staged-rewrite skip is sound only while NOTHING recomputed or linked since
+ * its last notify — a mid-batch pull can clean a marked subscriber, and a
+ * skipped re-write would leave it stale. */
+let notifyEpoch = 0;
+function bumpNotifyEpoch() {
+  notifyEpoch++;
+}
+function insertSubs(node) {
+  // §12d: stamp before walking — setSignal's staged-rewrite fast path skips
+  // the next walk for this node while the epoch holds (marking is idempotent).
+  node._notifiedAt = notifyEpoch;
+  // Presence bits gate the optional-slot probes (see constants.ts): one
+  // masked read of the always-present _config instead of missing-property
+  // lookups in the hottest notify loop.
+  const cfg = node._config;
+  const hasSnapshot = (cfg & CONFIG_HAS_SNAPSHOT) !== 0 && node._x?._snapshotValue !== undefined;
+  // Observe-tier fan-out: this walk visits every subscriber edge anyway, so
+  // the graph-size count is one local increment here and no field anywhere.
+  let fanOut = 0;
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    const sub = s._sub;
+    fanOut++;
+    // Missed-wake latch (#3037): this write is landing while the subscriber
+    // is mid-recompute (a nested pull committing beneath its reads), and the
+    // heap refuses RECOMPUTING nodes. A gen-current link means the pass
+    // already validated this dep — the value it read is now stale — so latch
+    // for recompute's tail to reschedule. Untouched links need no latch (the
+    // pass either re-reads them fresh or trims them), and neither does the
+    // tail link: it is the read IN FLIGHT — read() links before it pulls, so
+    // this very commit is what that read returns.
+    if (sub._flags & REACTIVE_RECOMPUTING_DEPS && s._gen === sub._depGen && s !== sub._depsTail)
+      sub._flags |= REACTIVE_MISSED_WAKE;
+    if (hasSnapshot && sub._config & CONFIG_IN_SNAPSHOT_SCOPE) {
+      sub._flags |= REACTIVE_SNAPSHOT_STALE;
+      continue;
+    }
+    enqueueSub(sub);
   }
-  runDisposal(node, zombie);
-  // Final effect-returned cleanup fires at true disposal, after `_disposal`
-  // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-  if (self && node._cleanup) {
-    const effectCleanup = node._cleanup;
-    node._cleanup = undefined;
-    enterDisposal();
-    effectCleanup();
-    exitDisposal();
+  if (fanOut >= GRAPH_SIZE_WARN_AT) noteFanOut(node, fanOut);
+}
+/** Lane work re-staged (lanes.ts; `recompute`): the lane's members among
+ * its subscribers re-derive as the lane's work (REACTIVE_LANE_DIRTY), their
+ * runs held with it — not as stale readers republishing the committed view
+ * (#3460). After `insertSubs`. A render effect on no lane is marked too:
+ * inert for its pass (`recompute` seats a lane only from its own `_x`), it
+ * is a live write if the effect becomes a zombie later this flush — an
+ * on-screen reader whose removal an adopted write stages follows the lane
+ * (the lane-membership ruling, 2026-10-05; `_update`). */
+function laneDirty(node, l) {
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    const t = s._sub._x?._transaction;
+    if (t?._lane ? sameLane(t, l) : s._sub._type) s._sub._flags |= REACTIVE_LANE_DIRTY;
   }
 }
-function linkChild(parent, node) {
-  const head = parent._firstChild;
-  node._prevSibling = null;
-  node._nextSibling = head;
-  if (head !== null) head._prevSibling = node;
-  parent._firstChild = node;
+/** One lane, or two of one link group (#3335): one reveal unit. */
+function sameLane(a, b) {
+  return a === b || (a._links !== null && a._links === b._links);
 }
-function runDisposal(node, zombie) {
-  // Detach the list BEFORE running it (#3601), as `_cleanup` is (#2813). A
-  // cleanup that disposes an ancestor re-enters this node through the death
-  // walk while the loop is still running; with the list still attached, that
-  // walk ran every entry a second time. Detached, the re-entrant drain finds
-  // nothing. The same shape latched a throwing cleanup: the list survived the
-  // throw and every later drain re-ran and re-threw it.
-  const disposal = zombie ? node._x._pendingDisposal : node._disposal;
-  if (!disposal) return;
-  if (zombie) node._x._pendingDisposal = null;
-  else node._disposal = null;
-  // No try/finally: it would survive into prod (rollup keeps the frame). A
-  // throw leaves the depth raised; dev.ts clears the stale count on the next
-  // microtask, since teardown never spans one (core.ts).
-  enterDisposal();
-  if (Array.isArray(disposal)) {
-    // Unwind order (#3572, restores 1.x #1562): later registrations run
-    // before earlier ones. Children have already been disposed by the caller,
-    // so with LIFO a body that registers cleanup before creating its children
-    // tears down after them — the same order a per-component owner gives.
-    for (let i = disposal.length - 1; i >= 0; i--) {
-      const callable = disposal[i];
-      callable.call(callable);
+function commitPendingNode(n) {
+  const c = n;
+  // L2: the commit is where a pass, held or not, stops being uncommitted —
+  // unless it has no answer yet. A pass still in flight (pending, nothing
+  // staged) stays uncommitted: a re-pass disposes its children on the spot,
+  // and the frame it parked stays the frame until a pass of this node
+  // commits a value.
+  if (!c._fn) {
+    n._config &= -385;
+    if (n._pendingValue !== NOT_PENDING) {
+      n._value = n._pendingValue;
+      n._pendingValue = NOT_PENDING;
     }
-  } else {
-    disposal.call(disposal);
+    return;
   }
-  exitDisposal();
+  // Computeds only from here (`_statusFlags` is not a signal field). A
+  // 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;
+  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.
+    c._statusFlags &= ~STATUS_UNINITIALIZED;
+    // A quiet re-ask's classification survives its landing and dies with
+    // the landed value's commit (A19 exc. 2, #3178): verdict-quiet through
+    // the reveal. (The sweep of a node still in flight is not a landing.)
+    // The A28 stash goes with it.
+    if (c._x != null) ((c._x._reask = false), (c._x._flushed = NOT_PENDING));
+    // An effect with a staged value was born held (L2): its first run is
+    // this commit's, not its creation's (A29) — queue it now.
+    if (n._type && n._type !== EFFECT_TRACKED) {
+      n._modified = true;
+      globalQueue.enqueue(n._type, (n._boundRunEffect ??= GlobalQueue._runEffect.bind(null, c)));
+    }
+  }
+  // The committed value is the first observable answer for a loading-window
+  // node — the window closes here, not at compute time (#2990). Unconditional
+  // store to an always-present computed slot.
+  c._loading = false;
+  c._flags &= ~REACTIVE_MANUAL_WRITE;
+  // The dependencies of the pass that produced the value are the frame's now:
+  // the previous frame's tail goes (A30, #3410; `recompute` left it for a
+  // staged pass). Only after a clean pass: `_error` is cleared by a clean
+  // pass or by the node's own landing (whose pass was clean), so a set
+  // `_error` means the last pass threw, kept its full list, and `_depsTail`
+  // marks where it stopped.
+  if (c._x?._error == null) trimStaleDeps(c);
+  if (!(c._statusFlags & STATUS_PENDING)) c._statusFlags &= ~STATUS_UNINITIALIZED;
+  // L2: the children this commit publishes are the frame's now — the frame
+  // they replace, parked by the pass (`recompute`), goes.
+  if (
+    !inFlight &&
+    c._x != null &&
+    (c._x._pendingFirstChild !== null || c._x._pendingDisposal !== null)
+  )
+    GlobalQueue._dispose(c, false, true);
 }
-function childId(owner, consume) {
-  let counter = owner;
-  while (counter._config & CONFIG_TRANSPARENT && counter._parent) counter = counter._parent;
-  if (counter.id != null)
-    return formatId(counter.id, consume ? counter._childCount++ : counter._childCount);
-  throw new Error("Cannot get child id from owner without an id");
+function commitPendingNodes() {
+  for (let i = 0; i < pendingNodes.length; i++) {
+    const n = pendingNodes[i];
+    // A node a lane pass re-staged this round is the lane's to reveal; one
+    // a transaction holds (born held by a mainline pass, `passTx`) is that
+    // transaction's to commit, at its landing.
+    if (!(n._config & (CONFIG_OVERRIDE | CONFIG_HELD))) commitPendingNode(n);
+  }
+  pendingNodes.length = 0;
 }
-/**
- * Allocates and returns the next stable child id for `owner`. Used by
- * hydration plumbing and `createUniqueId`. Not part of the user-facing API.
- *
- * @internal
- */
-function getNextChildId(owner) {
-  return childId(owner, true);
+const globalQueue = new GlobalQueue();
+function flush(fn) {
+  if (actionDepth > 0) {
+    {
+      throw new Error(
+        "[FLUSH_IN_ACTION] flush() inside an action body is not allowed. An action's writes are held in its " +
+          "transaction and commit when the action settles: flush() cannot reveal them, and draining here would " +
+          "detach the writes that follow from the transaction. Remove the flush(); to observe the result, read " +
+          "after the action resolves."
+      );
+    }
+  }
+  if (fn) {
+    syncDepth++;
+    try {
+      return fn();
+    } finally {
+      // Decrement even if the drain throws (a throwing effect): a leaked
+      // syncDepth would stop `schedule()` from ever queuing a microtask again.
+      try {
+        flush();
+      } finally {
+        syncDepth--;
+      }
+    }
+  }
+  if (globalQueue._running) {
+    if (inTrackedQueueCallback) {
+      throw new Error(
+        "Cannot call flush() from inside onSettled or createTrackedEffect. flush() is not reentrant there. " +
+          "Writes made here are processed in the same flush's continuation; to force a drain afterwards, defer it: queueMicrotask(() => flush())."
+      );
+    }
+    if (inEffectCallback) {
+      const message =
+        "[FLUSH_IN_EFFECT_CALLBACK] flush() called from inside an effect callback is a no-op: the flush that runs effects is already in progress. " +
+        "Writes made here are processed in the same flush's continuation; to force a drain afterwards, defer it: queueMicrotask(() => flush()).";
+      reportDiagnostic(
+        emitDiagnostic({
+          code: "FLUSH_IN_EFFECT_CALLBACK",
+          kind: "lifecycle",
+          severity: "warn",
+          message
+        })
+      );
+    }
+    return;
+  }
+  if (halted) return;
+  let count = 0;
+  // Attribution: whether this call drained anything, so `flushEnd` fires once
+  // per real drain and never for a no-op call. The declaration is dead in
+  // prod (its only write is behind true) and rollup drops it.
+  let drained = false;
+  // The drain's opening instant, under the loop's own condition so it fires
+  // exactly when `flushEnd` below will. Outside every try (see the rule in
+  // attribution-hooks.ts).
+  if (attrHooks !== null && scheduled) attrHooks.flushStart();
+  while (scheduled) {
+    if (++count === 1e5) {
+      rethrowCleanupError(true);
+      // Attribution beats a bare guard (#3140): say what kept the loop alive.
+      throw new Error(
+        `Potential Infinite Loop Detected. Kept alive by scheduled work${lastStagedNodeName ? `; last staged node: ${lastStagedNodeName}` : ""}`
+      );
+    }
+    globalQueue.flush();
+    drained = true;
+  }
+  // Outside every try in this function (see the rule in attribution-hooks.ts):
+  // the drain loop above is the one place all scheduled work funnels through,
+  // so this is the "committed and effects ran" instant for everything the
+  // loop processed.
+  if (drained && attrHooks !== null) attrHooks.flushEnd();
+  // A cleanup that threw during the drain, now that the drain is complete
+  // (owner.ts).
+  rethrowCleanupError();
 }
-/**
- * The id a freshly-created node inherits: an explicit `options.id` wins;
- * transparent nodes share their parent's id; otherwise the parent's next
- * child id is consumed (or `undefined` outside an id-carrying tree).
- */
-function inheritId(options, transparent, parent) {
-  return (
-    options?.id ??
-    (transparent ? parent?.id : parent?.id != null ? getNextChildId(parent) : undefined)
-  );
+function runQueue(queue, type) {
+  for (let i = 0; i < queue.length; i++) queue[i](type);
 }
+
 /**
- * Returns the *next* child id for `owner` without consuming it. Used by
- * hydration plumbing to peek at the id a future child will receive.
- *
- * @internal
+ * Schedule one subscriber to re-run on the next flush: inserted into the
+ * dirty heap with the `_min` cursor pulled down. Tracked effects ride the
+ * heap too — the heap visit is their (empty) compute phase, which hands the
+ * callback to the user queue once the pass has committed (see
+ * GlobalQueue._update, #3291).
  */
-function peekNextChildId(owner) {
-  return childId(owner, false);
+function enqueueSub(node) {
+  if (dirtyQueue._min > node._height) dirtyQueue._min = node._height;
+  insertIntoHeap(node, dirtyQueue);
 }
-function formatId(prefix, id) {
-  const num = id.toString(36),
-    len = num.length - 1;
-  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
+function actualInsertIntoHeap(n, heap) {
+  const parentHeight =
+    (n._parent?._root ? n._parent._parentComputed?._height : n._parent?._height) ?? -1;
+  if (parentHeight >= n._height) n._height = parentHeight + 1;
+  const height = n._height;
+  const heapAtHeight = heap._heap[height];
+  if (heapAtHeight === undefined) heap._heap[height] = n;
+  else {
+    const tail = heapAtHeight._prevHeap;
+    tail._nextHeap = n;
+    n._prevHeap = tail;
+    heapAtHeight._prevHeap = n;
+  }
+  if (height > heap._max) heap._max = height;
 }
-/**
- * Returns the currently-tracking observer (the computation that subscribes to
- * reactive reads at this point), or `null` if reads here would be untracked.
- * Used by reactive primitives that need to know whether they're inside a
- * tracking scope. App code rarely needs this — see `getOwner()` for the
- * lifecycle owner instead.
- *
- * @example
- * ```ts
- * // Library predicate: only register a hot-path subscription when the
- * // caller is inside a tracking scope (memo / effect compute / JSX).
- * function trackIfTracked(source: () => unknown) {
- *   if (getObserver()) source();
- * }
- * ```
- */
-function getObserver() {
-  return tracking ? context : null;
+function insertIntoHeap(n, heap) {
+  let flags = n._flags;
+  // RECOMPUTING refusals are not always losses: a genuinely missed wake (a
+  // write to a link this pass already validated) is latched link-side in
+  // insertSubs as REACTIVE_MISSED_WAKE for recompute's tail (#3037).
+  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
+  if (flags & REACTIVE_CHECK) {
+    n._flags = (flags & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+  } else {
+    n._flags = flags | REACTIVE_IN_HEAP;
+    // An unmarked node entering an already-marked heap is marked on the
+    // spot, keeping the markHeap memo valid. `_marked` is only reset by
+    // runHeap, so a write between two mid-tick pulls (read-time markHeap +
+    // updateIfNecessary) would otherwise leave this node unmarked and every
+    // downstream pull stale until the next flush (#2922: the second
+    // `latest()` returned the first write's value). Invalidating the memo
+    // instead re-walked the WHOLE heap on the next pull — with N effects
+    // parked in the heap for a synchronous mount (each row writing a ref
+    // signal its effect subscribes to), mounting N rows was O(N²) (#3350).
+    // markNode's own guard skips an already-DIRTY node.
+    if (heap._marked) markNode(n);
+  }
+  if (!(flags & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(n, heap);
 }
-/**
- * Returns the current reactive **owner** — the lifecycle node that the next
- * `cleanup()` / `onCleanup()` / `createSignal()` etc. will be attached to.
- *
- * Returns `null` if called outside any owner. Capture the owner with
- * `getOwner()` and re-enter it later with `runWithOwner(owner, fn)` to attach
- * disposables created from a callback (event handler, async resolution, etc.)
- * back to a component's lifecycle.
- *
- * @example
- * ```ts
- * function defer<T>(fn: () => T) {
- *   const owner = getOwner();
- *   queueMicrotask(() => runWithOwner(owner, fn));
- * }
- * ```
- */
-function getOwner() {
-  return context;
+function insertIntoHeapHeight(n, heap) {
+  let flags = n._flags;
+  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
+  n._flags = flags | REACTIVE_IN_HEAP_HEIGHT;
+  actualInsertIntoHeap(n, heap);
 }
-/**
- * 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.
- */
-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];
-  return fn;
+function deleteFromHeap(n, heap) {
+  const flags = n._flags;
+  if (!(flags & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
+  n._flags = flags & -25;
+  const height = n._height;
+  if (n._prevHeap === n) heap._heap[height] = undefined;
+  else {
+    const next = n._nextHeap;
+    const dhh = heap._heap[height];
+    const end = next ?? dhh;
+    if (n === dhh) heap._heap[height] = next;
+    else n._prevHeap._nextHeap = next;
+    end._prevHeap = n._prevHeap;
+  }
+  n._prevHeap = n;
+  n._nextHeap = undefined;
 }
-/**
- * Returns `true` if the owner has been disposed. Pair with a captured owner
- * to bail out of late callbacks whose surrounding component already
- * unmounted.
- *
- * @example
- * ```ts
- * function onSettleSafe(fn: () => void) {
- *   const owner = getOwner();
- *   queueMicrotask(() => {
- *     if (owner && isDisposed(owner)) return; // component unmounted; skip
- *     runWithOwner(owner, fn);
- *   });
- * }
- * ```
- */
-function isDisposed(node) {
-  return !!(node._flags & REACTIVE_DISPOSED);
+function markHeap(heap) {
+  if (heap._marked) return;
+  heap._marked = true;
+  for (let i = 0; i <= heap._max; i++) {
+    for (let el = heap._heap[i]; el !== undefined; el = el._nextHeap) {
+      if (el._flags & REACTIVE_IN_HEAP) markNode(el);
+    }
+  }
 }
-function disposeRootSelf(self = true) {
-  disposeChildren(this, self);
+function markNode(el, newState = REACTIVE_DIRTY) {
+  const flags = el._flags;
+  if ((flags & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= newState) return;
+  el._flags = (flags & -4) | newState;
+  for (let link = el._subs; link !== null; link = link._nextSub) {
+    markNode(link._sub, REACTIVE_CHECK);
+  }
 }
-/**
- * Creates a fresh owner attached as a child of the current owner (or as a
- * detached root if there is none). Used by framework internals to group
- * cleanups; app code should use `createRoot()` (host a reactive scope outside
- * a component) or `runWithOwner()` (re-enter a captured owner).
- *
- * @internal
- */
-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.
-  const owner = {
-    id: inheritId(options, transparent, parent),
-    _config: transparent ? CONFIG_TRANSPARENT : 0,
-    _root: true,
-    _parentComputed: parent?._root ? parent._parentComputed : parent,
-    _firstChild: null,
-    _nextSibling: null,
-    _prevSibling: null,
-    _disposal: null,
-    _context: parent?._context || defaultContext,
-    _childCount: 0,
-    _x: null,
-    _parent: parent,
-    dispose: disposeRootSelf,
-    _name: undefined
-  };
-  if (parent && parent._config & CONFIG_CHILDREN_FORBIDDEN) {
-    emitDiagnostic({
-      code: "PRIMITIVE_IN_FORBIDDEN_SCOPE",
-      kind: "lifecycle",
-      severity: "error",
-      message: PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE,
-      ownerId: parent.id,
-      ownerName: parent._name
-    });
-    throw new Error(PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE);
+function runHeap(heap, recompute) {
+  heap._marked = false;
+  for (heap._min = 0; heap._min <= heap._max; heap._min++) {
+    let el = heap._heap[heap._min];
+    while (el !== undefined) {
+      if (el._flags & REACTIVE_IN_HEAP) recompute(el);
+      else adjustHeight(el, heap);
+      el = heap._heap[heap._min];
+    }
   }
-  assertNotInEffectCallback();
-  if (parent) linkChild(parent, owner);
-  else registerRoot(owner);
-  DEV.hooks.onOwner?.(owner);
-  return owner;
+  heap._max = 0;
 }
-/**
- * Creates a reactive root — an owner scope with its own `dispose()`. A root
- * created inside an existing owner is owned by it and is disposed when the
- * parent is disposed; call `dispose()` to tear it down earlier. To create a
- * root that outlives its creator, detach explicitly:
- * `runWithOwner(null, () => createRoot(...))`. Pass `id` to seed hydration
- * ids for the tree it owns.
- *
- * `dispose()` tears down every signal, memo, effect, and `onCleanup`
- * registered inside the root.
- *
- * Use this to host long-lived reactive scopes outside of a component (custom
- * controllers, app bootstrapping, tests). Inside a component, prefer
- * letting Solid's component lifecycle own things.
- *
- * @example
- * ```ts
- * // At module level there is no owner, so this root lives until disposed.
- * const dispose = createRoot(dispose => {
- *   const [n, setN] = createSignal(0);
- *   createEffect(() => n(), value => console.log(value));
- *   setInterval(() => setN(x => x + 1), 1000);
- *   return dispose;
- * });
- *
- * // Later, to tear everything down:
- * dispose();
- *
- * // Inside an owner (component, effect, another root), detach explicitly
- * // if the root must outlive its creator:
- * const detached = runWithOwner(null, () => createRoot(d => d));
- * ```
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
- */
-function createRoot(init, options) {
-  const owner = createOwner(options);
-  return runWithOwner(owner, () => init(() => owner.dispose()));
+function adjustHeight(el, heap) {
+  deleteFromHeap(el, heap);
+  let newHeight = el._height;
+  for (let d = el._deps; d; d = d._nextDep) {
+    const dep = d._dep;
+    if (dep._fn && dep._height >= newHeight) newHeight = dep._height + 1;
+  }
+  if (el._height !== newHeight) {
+    el._height = newHeight;
+    for (let s = el._subs; s !== null; s = s._nextSub) insertIntoHeapHeight(s._sub, heap);
+  }
 }
 
 /** The store's shared slot-node release handler (store/store.ts installs it
@@ -2584,20 +2861,24 @@ function unlinkSubs(link) {
     if (nextSub === null) {
       // Store slot nodes dispatch to the ONE shared hook — no per-node
       // unobserved closure, no NodeExtension to hold it.
+      // A user hook that throws is collected like a cleanup (owner.ts): the
+      // unlink and the teardown around it carry on.
       if (dep._config & CONFIG_SLOT_NODE) slotUnobservedHook(dep);
-      else dep._x?._unobserved?.();
+      else if (dep._x?._unobserved) runCleanup(dep._x._unobserved);
       // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
       // A pending node is exempt: its in-flight async work is an observer —
       // tearing down would orphan the work and re-execute it on the next
       // 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;
@@ -2626,6 +2907,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);
@@ -2827,6 +3119,45 @@ 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).
+  // Not a projection's derive: its readers learn its error through the
+  // family, which the commit's publish never reaches (#4189).
+  if (
+    !(
+      el._config & CONFIG_HELD ||
+      (inPass && el._flags & REACTIVE_STAGED_READ && globalQueue._running && !el.fam)
+    ) ||
+    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();
@@ -3073,7 +3404,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.
@@ -3091,7 +3426,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
@@ -3104,6 +3439,9 @@ 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
@@ -3119,14 +3457,9 @@ function handleAsync(
       // 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 node
-      // already held stages its answer into that hold (`setSignal`).
-      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);
-      }
+      // 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.
@@ -3171,15 +3504,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;
@@ -3188,7 +3520,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.
@@ -3196,8 +3528,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,
@@ -3282,7 +3621,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(() => {
@@ -3290,8 +3629,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) {
@@ -3299,29 +3639,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();
         }
       },
@@ -3425,6 +3768,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
@@ -3504,7 +3849,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;
@@ -3519,7 +3865,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
@@ -3561,8 +3907,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";
@@ -3597,6 +3964,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) {
@@ -3656,6 +4027,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
@@ -3671,18 +4043,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
@@ -3724,8 +4105,11 @@ function recompute(el, create = false) {
       // 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);
+      // 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)
@@ -3745,8 +4129,22 @@ 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). A cleanup or
+      // `unobserved` hook that throws here neither stops the pass nor skips
+      // that drain: its error is rethrown when the flush ends (owner.ts).
+      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);
@@ -3763,6 +4161,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).
@@ -3777,7 +4177,7 @@ 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 a lane node's lane value
   // when it has one (lanes.ts), else the committed one.
@@ -3789,7 +4189,8 @@ function recompute(el, create = false) {
         : 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;
@@ -3834,11 +4235,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
@@ -3846,14 +4251,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
@@ -3861,10 +4268,19 @@ 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;
+    // A mount's staged read joins it — except a nested derivation left
+    // pending: no render effect reaches it yet, so it holds nothing and
+    // reaches no boundary (Reader, #4203). A reader that does is caught.
+    joined = !!(
+      el._flags &
+      (mount && (prevLane || isEffect || !(el._statusFlags & STATUS_PENDING))
+        ? 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
@@ -3883,6 +4299,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.
@@ -3911,15 +4328,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
@@ -3946,17 +4363,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) {
@@ -4000,7 +4409,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) {
@@ -4034,9 +4443,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
       ) {
@@ -4065,8 +4472,12 @@ function recompute(el, create = false) {
           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.)
-          GlobalQueue._fresh?.(el);
+          // 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
@@ -4101,16 +4512,14 @@ 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 held like it: its answer is the hold's, and the hold waits
-  // for it (A29, #3800) — unless a boundary that has not shown content
-  // catches it: then it is the boundary's, and the hold does not wait (#3540).
-  if (
-    create &&
-    lane === null &&
-    (joined || (prevLane && el._flags & REACTIVE_STAGED_READ)) &&
-    el._statusFlags & STATUS_PENDING
-  ) {
+  // 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 !== null && !t._lane && !GlobalQueue._fresh?.(el)) holdNode(el, t);
+    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
@@ -4222,12 +4631,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:
@@ -4269,6 +4678,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
@@ -4300,7 +4710,8 @@ function ext(el) {
     _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
@@ -4322,10 +4733,13 @@ function joinPass(c, el) {
   // 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),
-      (!c._type && c._statusFlags & STATUS_UNINITIALIZED) || GlobalQueue._fresh?.(c)
-    );
+    joinPassTx(txOf(el), (!c._type && c._statusFlags & STATUS_UNINITIALIZED) || freshHook?.(c));
+}
+/** `joinPass` into the hold `t` (a folded guess's: store/optimistic.ts
+ * `foldedRead`, D-34) — a reader is never a render effect there. */
+function joinPassAt(c, t) {
+  c._flags |= REACTIVE_JOINED;
+  joinPassTx(t, (!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
@@ -4362,10 +4776,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)
   )
@@ -4374,7 +4789,7 @@ 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) || bornInto(c, t)) return false;
+  if ((t === flushTransaction && !lane && !verdict) || bornInto(c, t)) return false;
   staleReader(c, t);
   return true;
 }
@@ -4461,6 +4876,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,
@@ -4512,7 +4928,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)) {
@@ -4524,7 +4940,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 = {
@@ -4540,6 +4956,7 @@ function signal(v, options) {
     _notifiedAt: -1,
     _x: null,
     _name: options?.name ?? "signal",
+    _loc: options?.loc,
     _owner: null
   };
   s._internal = false;
@@ -4563,7 +4980,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,
@@ -4581,6 +4999,7 @@ function slotSignal(v, equals, host, key, acc) {
     px: undefined,
     pxv: undefined,
     _name: "signal",
+    _loc: undefined,
     _owner: null
   };
   s._internal = false;
@@ -4617,10 +5036,15 @@ 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.
+ * survive into prod). A throwing cleanup is caught (owner.ts `runCleanup`);
+ * anything else escaping a teardown leaves it raised, and dev.ts resets it on
+ * the next microtask, which teardown — synchronous — never spans.
  */
 let disposalDepth = 0;
 function enterDisposal() {
@@ -4644,6 +5068,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.
@@ -4657,17 +5091,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;
@@ -4676,7 +5105,7 @@ function untrack(fn, strictReadLabel) {
     untrackDepth++;
   }
   try {
-    if (GlobalQueue._externalUntrack) return GlobalQueue._externalUntrack(fn);
+    if (externalUntrackHook) return externalUntrackHook(fn);
     return fn();
   } finally {
     tracking = prevTracking;
@@ -4748,7 +5177,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
@@ -4827,6 +5256,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,
@@ -4877,7 +5307,13 @@ 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;
+    // Lane work over a folded lane (D-34), once the frame has a
+    // transaction, reads the screen too.
+    if (
+      ((observeFlightHook && c._config & CONFIG_VERDICT) || (laneStageHook && passLane?.folded)) &&
+      stagedScreen(c)
+    )
+      return el._value;
     stagedRead(c);
     return el._pendingValue;
   }
@@ -4893,7 +5329,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
@@ -4910,8 +5354,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
@@ -4936,9 +5381,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
@@ -5007,6 +5454,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 &&
@@ -5053,14 +5503,24 @@ 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
  * yet hold (REACTIVE_STAGED_READ — the seam decides). Lane work too (plan sec. 28, a
- * lane sees the screen plus its own guesses): the staging is the screen if
+ * lane sees the screen plus its own guesses) — a folded lane's only before
+ * the frame has a transaction (after, it reads the screen like a verdict
+ * reader, `stagedScreen` — a list pass never pairs a held length with the
+ * guess's rows, D-34): the staging is the screen if
  * the frame commits — one pass, the common case — and a held write if it
  * parks, which the seam repairs (`stagedReaders`): the pass re-derives on
  * the committed world and its lane's runs wait that round, so the held
@@ -5073,7 +5533,7 @@ function serve(el, c) {
 function stagedRead(c, el) {
   if (!(el?._statusFlags & STATUS_UNINITIALIZED)) {
     c._flags |= REACTIVE_STAGED_READ;
-    if (passLane !== null) stagedReaders.push(c);
+    if (laneSeamsHook && passLane !== null) stagedReaders.push(c);
   }
 }
 /** A10 for a staged node: a verdict reader (the pass entered a window) that
@@ -5123,11 +5583,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",
@@ -5146,7 +5641,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
@@ -5154,8 +5649,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);
@@ -5213,8 +5712,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.
@@ -5222,7 +5734,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
@@ -5289,7 +5801,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",
@@ -5323,175 +5836,196 @@ function markRefresh(node) {
 }
 
 export {
-  REACTIVE_CHECK 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,
-  REACTIVE_STAGED_READ as Q,
+  REACTIVE_IN_HEAP as O,
+  REACTIVE_DIRTY as P,
+  REACTIVE_CHECK as Q,
   REACTIVE_DISPOSED as R,
-  STATUS_PENDING as S,
-  stagedRead as T,
-  CONFIG_SLOT_NODE as U,
-  attrHooks as V,
+  STATUS_UNINITIALIZED as S,
+  CONFIG_INPUTS_PUBLISHED as T,
+  releaseQueues as U,
+  CONFIG_SLOT_NODE as V,
   holdNode as W,
   joinFuture as X,
-  commitPendingNode as Y,
-  REACTIVE_IN_HEAP as Z,
-  REACTIVE_DIRTY as _,
-  CONFIG_OVERRIDE as a,
-  untrack as a$,
-  CONFIG_INPUTS_PUBLISHED as a0,
-  setVerdict as a1,
-  context as a2,
-  REACTIVE_PROBED as a3,
-  bornInto as a4,
-  globalQueue as a5,
-  staleReader as a6,
+  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,
-  createEffectNode as aA,
-  recompute as aB,
-  EFFECT_USER as aC,
-  reportDiagnostic as aD,
-  computed as aE,
-  staleValues as aF,
-  CONFIG_AUTO_DISPOSE as aG,
-  EFFECT_TRACKED as aH,
-  unwrapStatusError as aI,
-  haltReactivity as aJ,
-  setStrictRead as aK,
-  StatusError as aL,
-  trimStaleDeps as aM,
-  setTrackedQueueCallback as aN,
-  setEffectStatusNotify as aO,
-  _hitUnhandledAsync as aP,
-  resetUnhandledAsync as aQ,
-  ROOT_ERROR_HOOK as aR,
-  registerGraph as aS,
-  runWithOwner as aT,
-  setMemo as aU,
-  $REFRESH as aV,
-  markRefresh as aW,
-  createRoot as aX,
-  getObserver as aY,
-  dispose as aZ,
-  TimeoutError as a_,
+  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,
+  haltReactivityAt 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,
-  joinPass as ac,
-  markLateLinker as ad,
-  spectating as ae,
-  STATUS_ERROR as af,
-  unflushedValue as ag,
-  stagedReaders as ah,
-  enterAction as ai,
-  setEffectCallback as aj,
-  exitAction as ak,
-  isThenable as al,
-  actionDepth as am,
-  flush as an,
-  setQuestion as ao,
-  emitDiagnostic as ap,
-  enterCallback as aq,
-  exitCallback as ar,
-  getOwner as as,
-  inEffectCallback as at,
-  signal as au,
-  setSignal as av,
-  cleanup as aw,
-  read as ax,
-  NoOwnerError as ay,
-  ContextNotFoundError as az,
-  CONFIG_VERDICT as b,
-  dirtyQueue as b0,
-  CONFIG_REDERIVE as b1,
-  passTx as b2,
-  CONFIG_FRESH_READ as b3,
-  createOwner as b4,
-  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as b5,
-  ownedScopeWriteMessage as b6,
-  DEV as b7,
-  isEqual as b8,
-  CONFIG_MANUAL_WRITE as b9,
-  peekNextChildId as bA,
-  releaseSnapshotScope as bB,
-  resetErrorHalt as bC,
-  setConsoleFooter as bD,
-  setSnapshotCapture as bE,
-  setAttributionHooks as bF,
-  liveRootOwners as bG,
-  ownerPath as bH,
-  isSuppressed as bI,
-  blockersOf as bJ,
-  CONFIG_PLUMBING as bK,
-  anyExcluded as bL,
-  isExcluded as bM,
-  CONFIG_WIDE as bN,
-  GRAPH_SIZE_WARN_AT as bO,
-  noteFanOut as bP,
-  CONFIG_SUPERSEDES as bQ,
-  snapshotCaptureActive as ba,
-  captureWriteSnapshot as bb,
-  notePromotedWrite as bc,
-  slotSignal as bd,
-  stagedScreen as be,
-  CONFIG_PROMOTED as bf,
-  setSlotUnobserved as bg,
-  joinPassTx as bh,
-  asyncTailFlights as bi,
-  untrackDepth as bj,
-  checkPostAwaitRead as bk,
-  insertIntoHeap as bl,
-  isDisposed as bm,
-  handleAsync as bn,
-  addPendingSource as bo,
-  propagateStatus as bp,
-  forEachDependent as bq,
-  settlePendingSource as br,
-  notifyEpoch as bs,
-  SUPPORTS_PROXY as bt,
-  REACTIVE_ZOMBIE as bu,
-  OBSERVE as bv,
-  clearSnapshots as bw,
-  enforceLoadingBoundary as bx,
-  getNextChildId as by,
-  markSnapshotScope as bz,
-  REACTIVE_PROBE_UNANSWERED as c,
-  blocked as d,
-  REACTIVE_LANE_DIRTY as e,
-  enqueueSub as f,
-  CONFIG_AUTHORITATIVE as g,
-  tracking as h,
-  CONFIG_CHILDREN_FORBIDDEN as i,
-  sameLane as j,
+  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,
+  liveRootOwners 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,
+  joinPassAt as bB,
+  notifyEpoch as bC,
+  SUPPORTS_PROXY as bD,
+  releaseMarksHook as bE,
+  installMarkHooks as bF,
+  CONFIG_LAGS as bG,
+  REACTIVE_REASK as bH,
+  haltReactivity as bI,
+  heldUnder as bJ,
+  unhold as bK,
+  laneStageHook as bL,
+  REACTIVE_ZOMBIE as bM,
+  installBoundaryHooks as bN,
+  CAUGHT_REARMED as bO,
+  OBSERVE as bP,
+  clearSnapshots as bQ,
+  enforceLoadingBoundary as bR,
+  getNextChildId as bS,
+  markSnapshotScope as bT,
+  peekNextChildId as bU,
+  releaseSnapshotScope as bV,
+  resetErrorHalt as bW,
+  setConsoleFooter as bX,
+  setSnapshotCapture as bY,
+  setWriteHook as bZ,
+  setAttributionHooks 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,
+  ownerPath as c0,
+  isSuppressed as c1,
+  blockersOf as c2,
+  CONFIG_PLUMBING as c3,
+  anyExcluded as c4,
+  isExcluded as c5,
+  CONFIG_WIDE as c6,
+  GRAPH_SIZE_WARN_AT as c7,
+  noteFanOut as c8,
+  CONFIG_SUPERSEDES as c9,
+  newTransaction as d,
+  enqueueSub as e,
+  CONFIG_VERDICT as f,
+  REACTIVE_PROBE_UNANSWERED as g,
+  blocked as h,
+  installLaneHooks as i,
+  REACTIVE_LANE_DIRTY as j,
   CONFIG_HELD as k,
-  flushTransaction as l,
-  STATUS_UNINITIALIZED as m,
+  clock as l,
+  insertSubs as m,
   nextQuestion as n,
-  NotReadyError as o,
-  passLane as p,
+  ownFlights as o,
+  laneDirty as p,
   question as q,
   resolveTx as r,
   schedule as s,
   txOf as t,
-  REACTIVE_SCREEN_READ as u,
-  REACTIVE_FRAME_READ as v,
-  REACTIVE_LANE_READ as w,
-  ext as x,
-  REACTIVE_RECOMPUTING_DEPS as y,
-  queuePendingNode 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
 };