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

package/dist/dev-shared.js

@@ -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;
@@ -291,6 +306,8 @@ const defaultContext = {};
  */
 const $REFRESH = Symbol("refresh");
 
+const NewSet = Set;
+
 let attrHooks = null;
 /**
  * The installed engine, registered on `globalThis` as well (the records
@@ -688,6 +705,19 @@ function locationLine(loc) {
     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
@@ -704,9 +734,7 @@ function locationLine(loc) {
  */
 function reportDiagnostic(entry) {
   if (suppressedEvents.has(entry)) return;
-  let text = entry.message;
-  if (entry.ownerPath) text += `\n  in ${entry.ownerPath.join(" › ")}`;
-  if (entry.loc) text += `\n  at ${locationLine(entry.loc)}`;
+  let text = entry.message + locationLines(entry);
   const footer = takeFooter(entry);
   if (footer) text += `\n${footer}`;
   const element = eventSubjects.get(entry)?._devElement;
@@ -989,9 +1017,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);
@@ -1112,1647 +1141,1740 @@ function devCheckQuiescent(isQueuedForCommit) {
   return;
 }
 
-// Optional-module hooks: module bindings, not `GlobalQueue` statics, so a
-// bundle that never imports the installing module never assigns them — its
-// minifier folds every guarded call site (and the branch behind it) away.
-// Each module installs its own set at evaluation (pay-for-use).
-//
-// Lanes (lanes.ts; installed when `createOptimistic` — or verdict.ts — is
-// imported; every call site is behind a bit or a `passLane` nothing else sets).
-let laneReadHook = null;
-let laneStageHook = null;
-let laneOutcomeHook = null;
-let laneWriteHook = null;
-let applyGuessesHook = null;
-let laneSeamsHook = null;
-let laneCorrectionsHook = null;
-let endLanesHook = null;
-let lanesBlockedHook = null;
-function installLaneHooks(
-  read,
-  stage,
-  outcome,
-  write,
-  applyGuesses,
-  seams,
-  corrections,
-  end,
-  blocked
-) {
-  laneReadHook = read;
-  laneStageHook = stage;
-  laneOutcomeHook = outcome;
-  laneWriteHook = write;
-  applyGuessesHook = applyGuesses;
-  laneSeamsHook = seams;
-  laneCorrectionsHook = corrections;
-  endLanesHook = end;
-  lanesBlockedHook = blocked;
+// 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;
+  }
 }
-// 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;
+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);
 }
-/** 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;
+// 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();
+  }
 }
-/** `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;
+/** Rethrows the error `runCleanup` collected, once; `drop` discards it. @internal */
+function rethrowCleanupError(drop) {
+  const error = cleanupError;
+  cleanupError = undefined;
+  if (error && !drop) throw error[0];
 }
-/** Verdicts (verdict.ts). */
-let observeFlightHook = null;
-function installVerdictHooks(observeFlight) {
-  observeFlightHook = observeFlight;
+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;
+  }
+  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();
+  }
 }
-/** 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;
+function linkChild(parent, node) {
+  const head = parent._firstChild;
+  node._prevSibling = null;
+  node._nextSibling = head;
+  if (head !== null) head._prevSibling = node;
+  parent._firstChild = node;
 }
-/** 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();
+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]);
+    }
+  } else {
+    runCleanup(disposal);
+  }
+  exitDisposal();
 }
-/** 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));
+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");
 }
-/** `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;
+/**
+ * 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);
 }
-function resolveTx(t) {
-  while (t._into !== null) t = t._into;
-  return t;
+/**
+ * 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)
+  );
 }
-/** 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();
+/**
+ * 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);
 }
-/** `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);
+function formatId(prefix, id) {
+  const num = id.toString(36),
+    len = num.length - 1;
+  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
 }
-/** 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;
+/**
+ * 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;
 }
-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);
-  }
-  return out;
+/**
+ * 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;
 }
-/** `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);
+/**
+ * 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;
 }
-/** 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;
-  }
-  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;
-    }
-    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;
-}
-/** 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);
-}
-/** 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);
-  }
-}
-/** The nodes under `owner` a transaction other than `t` holds (boundaries.ts:
- * what an earlier hold staged under a re-armed boundary). */
-function heldUnder(owner, t, fn) {
-  for (let c = owner._firstChild; c !== null; c = c._nextSibling) {
-    if ((c._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && txOf(c) !== t) fn(c);
-    heldUnder(c, t, fn);
-  }
-}
-/** `n` leaves the hold it was staged in: its next pass publishes mainline. */
-function unhold(n) {
-  n._x._transaction = null;
-  n._config &= ~CONFIG_HELD;
-}
-const dirtyQueue = {
-  _heap: new Array(2000).fill(undefined),
-  _marked: false,
-  _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.
+ * 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 resetUnhandledAsync() {
-  _hitUnhandledAsync = false;
-  if (_reportedUnhandledAsync) return false;
-  _reportedUnhandledAsync = true;
-  return true;
+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();
 }
 /**
- * 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.
+ * 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 enforceLoadingBoundary(enabled) {
-  _enforceLoadingBoundary = enabled;
-  if (enabled) _reportedUnhandledAsync = false;
-}
-function setTrackedQueueCallback(value) {
-  inTrackedQueueCallback = value;
-}
-// 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 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: "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);
+  }
+  assertNotInEffectCallback();
+  if (parent) linkChild(parent, owner);
+  else registerRoot(owner);
+  DEV.hooks.onOwner?.(owner);
+  return owner;
 }
-function exitAction() {
-  actionDepth--;
+/**
+ * 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)));
 }
-/** 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;
+
+// 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;
 }
-function nextQuestion() {
-  return ++questions;
+// 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;
 }
-const MAINLINE_QUESTION = 0x7fffffff;
-let inEffectCallback = false;
-function setEffectCallback(value) {
-  inEffectCallback = value;
+/** 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;
 }
-function schedule() {
-  if (halted) {
-    notifyHalted();
-    return;
-  }
-  if (scheduled) return;
-  scheduled = true;
-  if (!syncDepth && !globalQueue._running) {
-    queueMicrotask(flush);
-  }
+/** `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;
 }
-/**
- * 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;
-  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.";
-    emitDiagnostic({
-      code: "REACTIVITY_HALTED",
-      kind: "error",
-      severity: "error",
-      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);
+/** Verdicts (verdict.ts). */
+let observeFlightHook = null;
+function installVerdictHooks(observeFlight) {
+  observeFlightHook = observeFlight;
 }
-// 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."
-  );
+/** 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;
 }
-/** @internal Test/dev-reload hook. Revives scheduling after a halt. */
-function resetErrorHalt() {
-  halted = false;
-  haltNotified = false;
+/** 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;
 }
-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;
-    }
-  }
-  /** 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 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;
-    }
-    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;
-    }
-    // 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;
-    }
-    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.
-    boundarySeamHook?.();
-  }
-  run(type) {
-    const effects = this._queues[type - 1];
-    if (effects.length) {
-      this._queues[type - 1] = [];
-      runQueue(effects, type);
-    }
+// 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);
   }
-  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();
+  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;
   }
-  /** 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;
+}
+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;
+    }
+    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;
 }
-/** 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);
+/** 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);
+}
+/** 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) 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);
+/** 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);
   }
-  // A cleanup those commits ran that wrote a node `u` still held joined
-  // `u`, which has left `transactions`: the write is this landing's, and
-  // the next flush must not park in it (#4089).
-  if (flushTransaction === u) flushTransaction = null;
-  releaseQueues(u);
 }
-/** The held runs join this flush's effect phase after its own runs (the
- * 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);
-  }
-  if (fanOut >= GRAPH_SIZE_WARN_AT) noteFanOut(node, fanOut);
+function exitAction() {
+  actionDepth--;
 }
-/** 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;
-  }
+/** 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;
 }
-/** 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 nextQuestion() {
+  return ++questions;
 }
-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;
-    }
+const MAINLINE_QUESTION = 0x7fffffff;
+let inEffectCallback = false;
+/** Dev-only: matches no event, so a window or phase holding it applies
+ * whatever event is current (see `strictReadEvent`, core.ts). */
+const ANY_EVENT = {};
+/** Dev-only: the DOM event current when the effect phase was entered. A
+ * handler dispatched synchronously from that phase (`el.focus()`) runs under
+ * a different event and is not in it (#4235). */
+let effectCallbackEvent = ANY_EVENT;
+function setEffectCallback(value, event = ANY_EVENT) {
+  {
+    inEffectCallback = value;
+    effectCallbackEvent = event;
+  }
+}
+function schedule() {
+  if (halted) {
+    notifyHalted();
     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;
-  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)));
-    }
+  if (scheduled) return;
+  scheduled = true;
+  if (!syncDepth && !globalQueue._running) {
+    queueMicrotask(flush);
   }
-  // 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);
+/**
+ * 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;
   }
-  pendingNodes.length = 0;
+  // 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);
 }
-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++;
+/**
+ * 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;
+}
+// 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 {
-      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--;
+      // 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;
     }
   }
-  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())."
-      );
+  /** 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);
+      }
     }
-    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
-        })
-      );
+    // 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;
+    }
+    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;
     }
-    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}` : ""}`
-      );
+    // 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;
     }
-    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();
-}
-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;
-  }
-  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);
-  }
-  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;
-  }
-  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);
+    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];
     }
-  }
-}
-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);
-  }
-}
-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];
+    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.
+    boundarySeamHook?.();
   }
-  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;
+  run(type) {
+    const effects = this._queues[type - 1];
+    if (effects.length) {
+      this._queues[type - 1] = [];
+      runQueue(effects, type);
+    }
   }
-  if (el._height !== newHeight) {
-    el._height = newHeight;
-    for (let s = el._subs; s !== null; s = s._nextSub) insertIntoHeapHeight(s._sub, heap);
+  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();
   }
-}
-
-// 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;
+  /** 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;
   }
 }
-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 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;
+/** 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. Truthy when an effect re-derives (`land`). */
+function reruns(u) {
+  let frame;
+  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) {
+      frame ||= r._type;
+      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);
+    }
   }
-  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;
+  u._reruns.length = 0;
+  return frame;
+}
+/** 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);
+  const frame = 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);
   }
-  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();
+  // 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;
+  // An effect re-derives next round (`reruns`): the held runs wait for it
+  // (D-9, the A15 reveal corollary, #4071). Its re-derivation can discover a
+  // flight — a stale reader whose mainline pass stopped reading it, now
+  // reading the landed world — and a landing that showed its runs first
+  // would reveal the held write beside a frame that can only show its old
+  // value. Queued last in this effect phase, the release hands them to the
+  // next round's own runs, ahead of the re-derivation's: they show with it,
+  // or park with it in the hold its pending opens. The commits stand.
+  if (frame) globalQueue._queues[1].push(() => releaseQueues(u));
+  else 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] = [];
   }
 }
-function linkChild(parent, node) {
-  const head = parent._firstChild;
-  node._prevSibling = null;
-  node._nextSibling = head;
-  if (head !== null) head._prevSibling = node;
-  parent._firstChild = node;
+/** `a.push(...b)` without the argument-count limit. */
+function append(a, b) {
+  for (let i = 0; i < b.length; i++) a.push(b[i]);
 }
-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);
-    }
-  } else {
-    disposal.call(disposal);
+/** 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);
   }
-  exitDisposal();
 }
-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 queuePendingNode(node) {
+  lastStagedNodeName = node._name ?? null;
+  pendingNodes.push(node);
+  if (!globalQueue._running) markUnflushedStaged(); // A28
 }
-/**
- * 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);
+// 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++;
 }
-/**
- * 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 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);
+  }
+  if (fanOut >= GRAPH_SIZE_WARN_AT) noteFanOut(node, fanOut);
 }
-/**
- * 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);
+/** 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 formatId(prefix, id) {
-  const num = id.toString(36),
-    len = num.length - 1;
-  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
+/** 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);
 }
-/**
- * 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 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;
+    }
+    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;
+  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);
 }
-/**
- * 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 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;
 }
-/**
- * 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;
+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();
+}
+/** Dev-only: the DOM event current when the running effect queue started,
+ * or `ANY_EVENT` outside one. Read once per queue rather than once per
+ * effect (the getter is costly under jsdom); no event starts or ends between
+ * two effects of one synchronous queue (#4235). */
+let queueEvent = ANY_EVENT;
+function runQueue(queue, type) {
+  {
+    const prev = queueEvent;
+    queueEvent = dispatchingEvent();
+    try {
+      for (let i = 0; i < queue.length; i++) queue[i](type);
+    } finally {
+      queueEvent = prev;
+    }
+    return;
+  }
 }
+
 /**
- * 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);
- *   });
- * }
- * ```
+ * 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 isDisposed(node) {
-  return !!(node._flags & REACTIVE_DISPOSED);
+function enqueueSub(node) {
+  if (dirtyQueue._min > node._height) dirtyQueue._min = node._height;
+  insertIntoHeap(node, dirtyQueue);
 }
-function disposeRootSelf(self = true) {
-  disposeChildren(this, self);
+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;
 }
-/**
- * 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` 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: "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 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);
   }
-  assertNotInEffectCallback();
-  if (parent) linkChild(parent, owner);
-  else registerRoot(owner);
-  DEV.hooks.onOwner?.(owner);
-  return owner;
+  if (!(flags & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(n, heap);
 }
-/**
- * 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)));
+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;
+  }
+  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);
+    }
+  }
+}
+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);
+  }
+}
+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];
+    }
+  }
+  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);
+  }
 }
 
 /** The store's shared slot-node release handler (store/store.ts installs it
@@ -2777,8 +2899,10 @@ 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
@@ -2857,7 +2981,7 @@ function unobserved(el) {
  * reclamation still happens within one microtask — the enqueue site arms
  * schedule(), so a flush is guaranteed even when no other work is queued.
  */
-const dormantNodes = new Set();
+const dormantNodes = new NewSet();
 function sweepDormant() {
   if (dormantNodes.size === 0) return;
   for (const el of dormantNodes) {
@@ -2925,7 +3049,7 @@ function link(dep, sub) {
 // to clear it, stranding the Set members' pending forever (#2893).
 function addPendingSource(el, source) {
   if (el._x?._pendingSources?.has(source)) return false;
-  (ext(el)._pendingSources ??= new Set()).add(source);
+  (ext(el)._pendingSources ??= new NewSet()).add(source);
   return true;
 }
 function removePendingSource(el, source) {
@@ -3008,7 +3132,7 @@ function releaseIfSettledUnobserved(node) {
 // Collect-then-release so unobserved() never unlinks under the walk.
 function releaseSettledDependents(el) {
   let candidates;
-  const visited = new Set();
+  const visited = new NewSet();
   const visit = node => {
     if (visited.has(node)) return;
     visited.add(node);
@@ -3048,10 +3172,12 @@ function stageError(el, error, inPass) {
   // 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)
+      (inPass && el._flags & REACTIVE_STAGED_READ && globalQueue._running && !el.fam)
     ) ||
     passLane
   )
@@ -3072,7 +3198,7 @@ function stageError(el, error, inPass) {
 }
 function settleErroredDependents(el, error) {
   let scheduled = false;
-  const visited = new Set();
+  const visited = new NewSet();
   const visit = node => {
     if (visited.has(node)) return;
     visited.add(node);
@@ -3149,7 +3275,7 @@ function settlePendingSource(el, source = el) {
   removePendingSource(el, source);
   let scheduled = false;
   let released;
-  const visited = new Set();
+  const visited = new NewSet();
   const settle = node => {
     if (
       visited.has(node) ||
@@ -3216,6 +3342,37 @@ function releaseFlightTeardown(el) {
     teardown();
   }
 }
+/**
+ * Internal (not a package export): run `fn` when the current pass's flight
+ * is superseded, at the same instant as the iterator close above, instead of
+ * when the replacing pass commits (owner cleanups wait for that). Chains onto
+ * the node's teardown slot; fires once with it. A no-op unless the ambient
+ * owner is a computed in its own pass. `consumeIterator` fills the slot
+ * before its first pull, so a source opened in an async generator's body
+ * (`for await`) composes after the generator's close.
+ */
+function onSupersede(fn) {
+  const el = context;
+  if (el === null || el._fn === undefined || !(el._flags & REACTIVE_RECOMPUTING_DEPS)) return;
+  const fresh = el._x === null;
+  const x = ext(el);
+  // Allocating the extension mid-run turns `_x?._inFlight` from undefined into
+  // null, which recompute would read as a flight this body registered itself.
+  // Restore undefined here, so the fix costs nothing for code that never
+  // calls onSupersede.
+  if (fresh) x._inFlight = undefined;
+  const prev = x._flightTeardown;
+  x._flightTeardown =
+    prev === null
+      ? fn
+      : () => {
+          try {
+            prev();
+          } finally {
+            fn();
+          }
+        };
+}
 function handleAsync(
   el,
   result,
@@ -3319,8 +3476,14 @@ function handleAsync(
     // 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))
+    if (stillPending || setter || !stageError(el, error)) {
       notifyStatus(el, stillPending ? STATUS_PENDING : STATUS_ERROR, error);
+      // The error is this pass's answer, published now: it replaces the shown
+      // frame as a value's commit would (`commitPendingNode`), so the frame
+      // the pass parked goes instead of waiting for a later success. A no-op
+      // when nothing is parked.
+      if (!stillPending) disposeChildren(el, false, true);
+    }
     // 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.
@@ -3435,7 +3598,11 @@ function handleAsync(
     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.
+    // sites so supersede stops this stream immediately. Assigned, not
+    // chained (chaining here costs every app bytes): it replaces any
+    // `onSupersede` teardown this run registered earlier, which then falls
+    // back to the owner-cleanup channel. A returned `from()` is unaffected:
+    // `close` calls its `return()`, which runs its own teardown.
     ext(el)._flightTeardown = close;
     // Release check before each next pull: an unobserved lazy node must tear
     // down (its close above runs via disposal, closing the iterator) instead
@@ -3598,12 +3765,12 @@ function handleAsync(
       handleError(syncError);
       throw syncError;
     } else if (!resolved) {
-      // Loading window: serve commit #0 instead of suspending — first-flight
-      // work on a loadingValue node is loading-class (invisible to
-      // boundaries); the flight itself is already registered in _inFlight and
-      // lands through asyncWrite.
-      if (el._loading) return el._value;
-      throw new NotReadyError(context);
+      // Not landed: the shared tail below suspends, or — loading window —
+      // serves commit #0 (first-flight work on a loadingValue node is
+      // loading-class, invisible to boundaries; the flight itself is already
+      // registered in _inFlight and lands through asyncWrite). A promise is
+      // never an iterator, so nothing between here and there runs.
+      liveLanded = false;
     } else if (!flattenIfIterable(syncValue)) {
       // Synchronously-resolved promise: the first real answer landed.
       el._loading = false;
@@ -3615,7 +3782,7 @@ function handleAsync(
   if (iterator) flattenIfIterable(result);
   if (liveLanded !== null) {
     if (!liveLanded) {
-      // Loading window: serve commit #0 (see the promise branch above).
+      // Loading window: serve commit #0 instead of suspending.
       if (el._loading) return el._value;
       throw new NotReadyError(context);
     }
@@ -3627,7 +3794,7 @@ function handleAsync(
 }
 function clearStatus(el, clearUninitialized = false) {
   if (el._x?._pendingSources) clearPendingSources(el);
-  if (el._x?._blocked) if (el._x !== null) el._x._blocked = false;
+  if (el._x?._blocked) el._x._blocked = false;
   el._statusFlags = clearUninitialized ? 0 : el._statusFlags & STATUS_UNINITIALIZED;
   if (el._x?._error) setPendingError(el);
   const notify = statusNotifierOf(el);
@@ -3667,7 +3834,7 @@ function landStatus(el, clearUninitialized = false) {
     setPendingError(el, sources.values().next().value);
   } else clearStatus(el, clearUninitialized);
 }
-function notifyStatus(el, status, error, blockStatus) {
+function notifyStatus(el, status, error) {
   // Wrap regular errors to track source node
   if (
     status === STATUS_ERROR &&
@@ -3678,21 +3845,19 @@ function notifyStatus(el, status, error, blockStatus) {
   const pendingSource =
     status === STATUS_PENDING && error instanceof NotReadyError ? error.source : undefined;
   // (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
-      // the distinct pending source.
-      setPendingError(el, pendingSource, error);
-    } else {
-      clearPendingSources(el);
-      el._statusFlags =
-        status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
-      ext(el)._error = error;
-    }
+  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
+    // the distinct pending source.
+    setPendingError(el, pendingSource, error);
+  } else {
+    clearPendingSources(el);
+    el._statusFlags =
+      status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
+    ext(el)._error = error;
   }
   // Lanes: a written guess is an optimistic boundary (A17 — "the optimistic
   // future value until we know otherwise"). Its own source in flight is its
@@ -3706,9 +3871,7 @@ function notifyStatus(el, status, error, blockStatus) {
   }
   const elNotify = statusNotifierOf(el);
   if (elNotify) {
-    {
-      elNotify.call(el);
-    }
+    elNotify.call(el);
     return;
   }
   propagateStatus(el, status, error);
@@ -3718,7 +3881,7 @@ function notifyStatus(el, status, error, blockStatus) {
  * family's leaves, which are not the derive's dependents — the family
  * propagates the derive's status from each leaf to the leaf's readers
  * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */
-function propagateStatus(el, status, error, downstreamBlockStatus) {
+function propagateStatus(el, status, error) {
   const pendingSource =
     status === STATUS_PENDING && error instanceof NotReadyError ? error.source : undefined;
   forEachDependent(el, (sub, link) => {
@@ -3775,23 +3938,21 @@ function propagateStatus(el, status, error, downstreamBlockStatus) {
       // bookkeeping (loading window, uninitialized clear) runs with the flush
       // — with the lane, when the pass propagating is the lane's work and
       // the dependent's pending is the lane's own flight (`laneStage`).
-      {
-        // (No answer: a pending propagation leaves a written guess a guess.)
-        if (laneStageHook && passLane !== null) laneStageHook(sub, passLane, true, el);
-        else {
-          queuePendingNode(sub);
-          // A15 (#3443): pending propagates onto a held memo without
-          // recomputing it, and the propagation itself enters the memo's
-          // transaction — the flight flows into a memo that transaction
-          // holds, so the write that started it is held with it. A render
-          // effect's membership is its pass's (`notify`), never sticky.
-          if (
-            status === STATUS_PENDING &&
-            (sub._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD &&
-            !sub._type
-          )
-            joinFuture(txOf(sub));
-        }
+      // (No answer: a pending propagation leaves a written guess a guess.)
+      if (laneStageHook && passLane !== null) laneStageHook(sub, passLane, true, el);
+      else {
+        queuePendingNode(sub);
+        // A15 (#3443): pending propagates onto a held memo without
+        // recomputing it, and the propagation itself enters the memo's
+        // transaction — the flight flows into a memo that transaction
+        // holds, so the write that started it is held with it. A render
+        // effect's membership is its pass's (`notify`), never sticky.
+        if (
+          status === STATUS_PENDING &&
+          (sub._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD &&
+          !sub._type
+        )
+          joinFuture(txOf(sub));
       }
       notifyStatus(sub, status, error);
     }
@@ -3857,7 +4018,11 @@ const PRIMITIVE_IN_EFFECT_CALLBACK_MESSAGE =
  * created there is inert and harmless. Tracked effects and onSettled are
  * children-forbidden and refuse through PRIMITIVE_IN_FORBIDDEN_SCOPE. */
 function assertNotInEffectCallback() {
-  if (inEffectCallback && context === null) {
+  if (
+    inEffectCallback &&
+    context === null &&
+    (effectCallbackEvent === ANY_EVENT || dispatchingEvent() === effectCallbackEvent)
+  ) {
     emitDiagnostic({
       code: "PRIMITIVE_IN_EFFECT_CALLBACK",
       kind: "lifecycle",
@@ -3890,7 +4055,7 @@ function ownerInSnapshotScope(owner) {
 }
 function setSnapshotCapture(active) {
   snapshotCaptureActive = active;
-  if (active && !snapshotSources) snapshotSources = new Set();
+  if (active && !snapshotSources) snapshotSources = new NewSet();
 }
 function markSnapshotScope(owner) {
   owner._snapshotScope = true;
@@ -4043,7 +4208,9 @@ function recompute(el, create = false) {
     // and own nothing to park.
     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).
+      // 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);
@@ -4178,7 +4345,15 @@ 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 & (mount ? REACTIVE_JOINED | REACTIVE_STAGED_READ : REACTIVE_JOINED));
+    // 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.
@@ -4637,6 +4812,12 @@ function joinPass(c, el) {
   if (el._statusFlags & STATUS_UNINITIALIZED || c._type !== EFFECT_RENDER)
     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
  * the committed value — a pending one's too — publishes mainline, and is
@@ -4803,7 +4984,7 @@ function setEffectStatusNotify(fn) {
  * Presence doubles as the "display consumer" membership test in the status
  * walks, exactly as the per-node field did when every effect carried one. */
 function statusNotifierOf(el) {
-  return el._type ? (effectStatusNotify ?? undefined) : undefined;
+  return el._type ? effectStatusNotify : null;
 }
 const lazyOptions = { lazy: true };
 function setupComputedNode(self, options) {
@@ -4938,8 +5119,9 @@ function exitCallback() {
  * 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() {
@@ -4951,11 +5133,31 @@ function exitDisposal() {
 function resetDisposalDepth() {
   disposalDepth = 0;
 }
-function setStrictRead(v) {
+/**
+ * Dev-only: the DOM event being dispatched when the open strict-read window
+ * opened (`globalThis.event`; null between dispatches and off the main
+ * thread's Window), or `ANY_EVENT` when the window did not record one. A DOM
+ * call made in an effect callback that dispatches events synchronously
+ * (`el.focus()`, `el.click()`, `dialog.showModal()`) runs that event's
+ * handlers inside the window; a handler is a one-shot snapshot whoever
+ * dispatched the event, so a read made while a different event is current is
+ * outside the window (#4235). Only queued effect runs record the event, read
+ * once per queue (the getter is costly under jsdom); `strictReadActive` is
+ * the check.
+ */
+let strictReadEvent;
+// `?? null`: no current event must not read as a missing argument below.
+const dispatchingEvent = () => globalThis.event ?? null;
+function setStrictRead(v, event = ANY_EVENT) {
   const prev = strictRead;
   strictRead = v;
+  strictReadEvent = event;
   return prev;
 }
+/** Dev-only: is the strict-read window open for a read made now? */
+function strictReadActive() {
+  return !!strictRead && (strictReadEvent === ANY_EVENT || dispatchingEvent() === strictReadEvent);
+}
 /**
  * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
  * subscribe the current scope. Returns whatever `fn` returns.
@@ -4994,9 +5196,11 @@ function setStrictRead(v) {
 function untrack(fn, strictReadLabel) {
   const prevTracking = tracking;
   const prevStrictRead = strictRead;
+  const prevStrictReadEvent = strictReadEvent;
   tracking = false;
   {
     strictRead = strictReadLabel || false;
+    strictReadEvent = ANY_EVENT;
     untrackDepth++;
   }
   try {
@@ -5006,6 +5210,7 @@ function untrack(fn, strictReadLabel) {
     tracking = prevTracking;
     {
       strictRead = prevStrictRead;
+      strictReadEvent = prevStrictReadEvent;
       untrackDepth--;
     }
   }
@@ -5202,11 +5407,17 @@ 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 (observeFlightHook && 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;
   }
-  if (strictRead && owner._statusFlags & STATUS_PENDING)
+  if (strictRead && owner._statusFlags & STATUS_PENDING && strictReadActive())
     throwPendingUntrackedRead(strictRead, {
       ownerId: c?.id,
       ownerName: c?._name,
@@ -5327,7 +5538,7 @@ function read(el) {
   // Ahead of the snapshot serve below: a component body's direct read is
   // wrong in the same way whether the pass is hydrating or not, and the
   // hydration pass is the console nobody is watching (#3675).
-  if (strictRead)
+  if (strictRead && strictReadActive())
     warnStrictReadUntracked(strictRead, {
       ownerId: c?.id,
       ownerName: c?._name,
@@ -5406,7 +5617,10 @@ function serve(el, c) {
 }
 /** 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
@@ -5751,7 +5965,7 @@ export {
   CONFIG_STAGED as Z,
   merge as _,
   NotReadyError as a,
-  setMemo as a$,
+  resetUnhandledAsync as a$,
   REACTIVE_JOINED as a0,
   REACTIVE_STAGED_READ as a1,
   stagedRead as a2,
@@ -5762,133 +5976,140 @@ export {
   verdict as a7,
   link as a8,
   pullComputed as a9,
-  cleanup as aA,
-  read as aB,
-  DEV as aC,
-  CONFIG_TRANSPARENT as aD,
-  NoOwnerError as aE,
-  ContextNotFoundError as aF,
-  createEffectNode as aG,
-  recompute as aH,
-  EFFECT_USER as aI,
-  reportDiagnostic as aJ,
-  computed as aK,
-  staleValues as aL,
-  CONFIG_AUTO_DISPOSE as aM,
-  EFFECT_TRACKED as aN,
-  heldRunHook as aO,
-  unwrapStatusError as aP,
-  haltReactivity as aQ,
-  setStrictRead as aR,
-  StatusError as aS,
-  trimStaleDeps as aT,
-  setTrackedQueueCallback as aU,
-  setEffectStatusNotify as aV,
-  _hitUnhandledAsync as aW,
-  resetUnhandledAsync as aX,
-  ROOT_ERROR_HOOK as aY,
-  registerGraph as aZ,
-  runWithOwner as a_,
+  signal as aA,
+  setSignal as aB,
+  cleanup as aC,
+  read as aD,
+  DEV as aE,
+  CONFIG_TRANSPARENT as aF,
+  NoOwnerError as aG,
+  ContextNotFoundError as aH,
+  createEffectNode as aI,
+  recompute as aJ,
+  EFFECT_USER as aK,
+  reportDiagnostic as aL,
+  computed as aM,
+  staleValues as aN,
+  CONFIG_AUTO_DISPOSE as aO,
+  EFFECT_TRACKED as aP,
+  heldRunHook as aQ,
+  unwrapStatusError as aR,
+  setStrictRead as aS,
+  queueEvent as aT,
+  StatusError as aU,
+  trimStaleDeps as aV,
+  haltReactivityAt as aW,
+  strictReadEvent as aX,
+  setTrackedQueueCallback as aY,
+  setEffectStatusNotify as aZ,
+  _hitUnhandledAsync as a_,
   strictRead as aa,
-  warnStrictReadUntracked as ab,
-  staleReader as ac,
-  globalQueue as ad,
-  joinPass as ae,
-  markLateLinker as af,
-  spectating as ag,
-  unflushedValue as ah,
-  CONFIG_STAGED_ERROR as ai,
-  stagedReaders as aj,
-  bornInto as ak,
-  enterAction as al,
-  setEffectCallback as am,
-  exitAction as an,
-  isThenable as ao,
-  actionDepth as ap,
-  flush as aq,
-  setQuestion as ar,
-  emitDiagnostic as as,
-  enterCallback as at,
-  exitCallback as au,
-  getOwner as av,
-  inEffectCallback as aw,
-  setExternalHooks as ax,
-  signal as ay,
-  setSignal as az,
+  strictReadActive as ab,
+  warnStrictReadUntracked as ac,
+  staleReader as ad,
+  globalQueue as ae,
+  joinPass as af,
+  markLateLinker as ag,
+  spectating as ah,
+  unflushedValue as ai,
+  CONFIG_STAGED_ERROR as aj,
+  stagedReaders as ak,
+  bornInto as al,
+  enterAction as am,
+  setEffectCallback as an,
+  exitAction as ao,
+  isThenable as ap,
+  actionDepth as aq,
+  flush as ar,
+  setQuestion as as,
+  emitDiagnostic as at,
+  enterCallback as au,
+  exitCallback as av,
+  getOwner as aw,
+  inEffectCallback as ax,
+  effectCallbackEvent as ay,
+  setExternalHooks as az,
   CONFIG_AUTHORITATIVE as b,
-  isSuppressed as b$,
-  $REFRESH as b0,
-  markRefresh as b1,
-  createRoot as b2,
-  getObserver as b3,
-  dispose as b4,
-  TimeoutError as b5,
-  untrack as b6,
-  dirtyQueue as b7,
-  CONFIG_REDERIVE as b8,
-  passTx as b9,
-  settlePendingSource as bA,
-  notifyEpoch as bB,
-  SUPPORTS_PROXY as bC,
-  releaseMarksHook as bD,
-  installMarkHooks as bE,
-  CONFIG_LAGS as bF,
-  REACTIVE_REASK as bG,
-  heldUnder as bH,
-  unhold as bI,
-  laneStageHook as bJ,
-  REACTIVE_ZOMBIE as bK,
-  installBoundaryHooks as bL,
-  CAUGHT_REARMED as bM,
-  OBSERVE as bN,
-  clearSnapshots as bO,
-  enforceLoadingBoundary as bP,
-  getNextChildId as bQ,
-  markSnapshotScope as bR,
-  peekNextChildId as bS,
-  releaseSnapshotScope as bT,
-  resetErrorHalt as bU,
-  setConsoleFooter as bV,
-  setSnapshotCapture as bW,
-  setWriteHook as bX,
-  setAttributionHooks as bY,
-  liveRootOwners as bZ,
-  ownerPath as b_,
-  CONFIG_FRESH_READ as ba,
-  createOwner as bb,
-  writeHook as bc,
-  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as bd,
-  ownedScopeWriteMessage as be,
-  isEqual as bf,
-  CONFIG_MANUAL_WRITE as bg,
-  snapshotCaptureActive as bh,
-  captureWriteSnapshot as bi,
-  notePromotedWrite as bj,
-  slotSignal as bk,
-  stagedScreen as bl,
-  CONFIG_PROMOTED as bm,
-  setSlotUnobserved as bn,
-  installStoreHooks as bo,
-  joinPassTx as bp,
-  asyncTailFlights as bq,
-  untrackDepth as br,
-  checkPostAwaitRead as bs,
-  disposalDepth as bt,
-  insertIntoHeap as bu,
-  isDisposed as bv,
-  handleAsync as bw,
-  addPendingSource as bx,
-  propagateStatus as by,
-  forEachDependent as bz,
+  resetErrorHalt as b$,
+  ROOT_ERROR_HOOK as b0,
+  registerGraph as b1,
+  runWithOwner as b2,
+  setMemo as b3,
+  $REFRESH as b4,
+  markRefresh as b5,
+  createRoot as b6,
+  getObserver as b7,
+  dispose as b8,
+  TimeoutError as b9,
+  handleAsync as bA,
+  addPendingSource as bB,
+  propagateStatus as bC,
+  forEachDependent as bD,
+  settlePendingSource as bE,
+  joinPassAt as bF,
+  notifyEpoch as bG,
+  SUPPORTS_PROXY as bH,
+  releaseMarksHook as bI,
+  installMarkHooks as bJ,
+  CONFIG_LAGS as bK,
+  REACTIVE_REASK as bL,
+  onSupersede as bM,
+  haltReactivity as bN,
+  heldUnder as bO,
+  unhold as bP,
+  laneStageHook as bQ,
+  REACTIVE_ZOMBIE as bR,
+  installBoundaryHooks as bS,
+  CAUGHT_REARMED as bT,
+  OBSERVE as bU,
+  clearSnapshots as bV,
+  enforceLoadingBoundary as bW,
+  getNextChildId as bX,
+  markSnapshotScope as bY,
+  peekNextChildId as bZ,
+  releaseSnapshotScope as b_,
+  untrack as ba,
+  dirtyQueue as bb,
+  CONFIG_REDERIVE as bc,
+  passTx as bd,
+  CONFIG_FRESH_READ as be,
+  createOwner as bf,
+  writeHook as bg,
+  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as bh,
+  ownedScopeWriteMessage as bi,
+  isEqual as bj,
+  CONFIG_MANUAL_WRITE as bk,
+  snapshotCaptureActive as bl,
+  captureWriteSnapshot as bm,
+  notePromotedWrite as bn,
+  slotSignal as bo,
+  stagedScreen as bp,
+  CONFIG_PROMOTED as bq,
+  setSlotUnobserved as br,
+  installStoreHooks as bs,
+  joinPassTx as bt,
+  asyncTailFlights as bu,
+  untrackDepth as bv,
+  checkPostAwaitRead as bw,
+  disposalDepth as bx,
+  insertIntoHeap as by,
+  isDisposed as bz,
   CONFIG_OVERRIDE as c,
-  blockersOf as c0,
-  CONFIG_PLUMBING as c1,
-  anyExcluded as c2,
-  isExcluded as c3,
-  CONFIG_WIDE as c4,
-  GRAPH_SIZE_WARN_AT as c5,
-  noteFanOut as c6,
-  CONFIG_SUPERSEDES as c7,
+  setConsoleFooter as c0,
+  setSnapshotCapture as c1,
+  setWriteHook as c2,
+  setAttributionHooks as c3,
+  liveRootOwners as c4,
+  ownerPath as c5,
+  isSuppressed as c6,
+  blockersOf as c7,
+  CONFIG_PLUMBING as c8,
+  anyExcluded as c9,
+  isExcluded as ca,
+  CONFIG_WIDE as cb,
+  GRAPH_SIZE_WARN_AT as cc,
+  noteFanOut as cd,
+  CONFIG_SUPERSEDES as ce,
   newTransaction as d,
   enqueueSub as e,
   CONFIG_VERDICT as f,