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

package/dist/dev-shared.js

@@ -149,7 +149,7 @@ const CONFIG_SYNC = 1 << 6;
 // CONFIG_HELD_CHILDREN, CONFIG_INPUTS_PUBLISHED and CONFIG_ADOPTED_UNFLUSHED
 // (transaction holds, zombies, until()'s authoritative view) went with the
 // transactions.
-// L2 (step 2): three bits, all maintained by the node's commit.
+// L2 (step 2): four bits, all maintained by the node's commit.
 /** The node has a pass awaiting commit: its live children (and `_disposal`)
  * are that pass's and were never shown — a re-pass tears them down on the
  * spot, while the frame parked on `_x._pendingFirstChild` keeps waiting for
@@ -162,6 +162,11 @@ const CONFIG_STAGED = 1 << 7;
  * parking flush they see the committed value and hold nothing, and are
  * re-derived at the landing. Set at the park seam on every staged node. */
 const CONFIG_HELD = 1 << 8;
+/** A member of the uncommitted frame a held pass built (ruling A): set at
+ * the park seam on every computed under a staged node (`holdFrame`). Never
+ * shown, it has no screen: its reads are its transaction's, whichever flush
+ * runs it (`bornInto`, #4010). Cleared by its commit. */
+const CONFIG_HELD_FRAME = 1 << 20;
 /** A15's reveal corollary (#3305): a commit published this flight's inputs
  * beneath it — the node was pending, nothing staged, when it committed — so
  * its committed value is torn against the visible frame. A render effect
@@ -1262,7 +1267,7 @@ function blockedBy(nodes, owner, own = false) {
       // shows nothing — a mount the frame has not revealed — and holds
       // nothing.
       if (
-        (r._type === EFFECT_RENDER ||
+        ((r._type === EFFECT_RENDER && r._statusFlags & STATUS_PENDING) ||
           r._flags & REACTIVE_FRAME_READ ||
           (r._config & CONFIG_REDERIVE && r._statusFlags === STATUS_PENDING)) &&
         (s._gen === r._depGen || r._x?._error != null) &&
@@ -1355,7 +1360,10 @@ function list(n, t) {
 function holdFrame(owner, t) {
   for (let c = owner._firstChild; c !== null; c = c._nextSibling) {
     if (c._x?._transaction?._lane) continue;
-    if (c._fn !== undefined && !(c._config & CONFIG_HELD)) holdNode(c, t);
+    if (c._fn !== undefined) {
+      if (!(c._config & CONFIG_HELD)) holdNode(c, t);
+      c._config |= CONFIG_HELD_FRAME;
+    }
     holdFrame(c, t);
   }
 }
@@ -1684,7 +1692,8 @@ class GlobalQueue {
     // parked (something async below) — the window is the frame's, the marks
     // are its transaction's; else they release at the seam, verdict-only,
     // nothing to show (affects.ts).
-    GlobalQueue._releaseAmbientMarks?.(t !== null && transactions.indexOf(t) !== -1 ? t : null);
+    const live = t && liveTx(t);
+    GlobalQueue._releaseAmbientMarks?.(live);
     // The effect phase: lane work first (displayed ahead of the frame), then
     // this flush's runs, then the runs the landings held from earlier
     // flushes — as one pass would have queued them (#3540: a shell
@@ -1692,18 +1701,17 @@ class GlobalQueue {
     // write; #3528: a display-ahead swap before the count it is shown
     // beside). A parked frame's runs wait with its transaction instead: the
     // effect phase applies a committed frame.
-    const u = t && liveTx(t);
-    const parked = u !== null;
+    const parked = live !== null;
     // Attribution hook: this flush found its transaction incomplete — its
     // writes stay staged, its runs are stashed below. Before the effect
     // phase (the lanes' display-ahead runs are the visible acknowledgers);
     // `holdEnd` fires after it (`flush`).
     if (parked && attrHooks !== null) {
-      attrHooks.holdStart(u);
+      attrHooks.holdStart(live);
       holding = true;
     }
     for (let i = 0; i < 2; i++) {
-      if (parked) append(u._queues[i], own[i]);
+      if (parked) append(live._queues[i], own[i]);
       // The plain flush — no reveal, no landing, not parked — has nothing to
       // order around its own runs: they are the queue as they stand (the
       // same array, not a copy; `run` takes it whole). Every other seam
@@ -1792,8 +1800,11 @@ class GlobalQueue {
 function reruns(u) {
   for (let i = 0; i < u._reruns.length; i++) {
     const r = u._reruns[i];
-    if (r._flags & REACTIVE_DISPOSED) continue;
-    if (r._flags & REACTIVE_FRAME_READ) {
+    // An errored reader's display is its error (D-39): the landing gives it
+    // nothing to re-derive, and a re-run would be a read that retries the
+    // errored source (#3945).
+    if (r._flags & REACTIVE_DISPOSED || r._statusFlags & STATUS_ERROR) continue;
+    if (r._flags & REACTIVE_FRAME_READ || r._config & CONFIG_VERDICT) {
       r._flags &= ~REACTIVE_FRAME_READ;
       r._modified = false;
       // Its frame is replaced by the re-derivation: a run one of its
@@ -1940,7 +1951,7 @@ function commitPendingNode(n) {
   // commit beneath a flight publishes its inputs (A15 reveal corollary,
   // #3305): a reveal of it must observe, not show the pre-flight value.
   const inFlight = n._pendingValue === NOT_PENDING && (c._statusFlags & STATUS_PENDING) !== 0;
-  n._config = inFlight ? (n._config & ~CONFIG_HELD) | CONFIG_INPUTS_PUBLISHED : n._config & -1409;
+  n._config = inFlight ? (n._config & -1048833) | CONFIG_INPUTS_PUBLISHED : n._config & -1049985;
   if (n._pendingValue !== NOT_PENDING) {
     n._value = n._pendingValue;
     n._pendingValue = NOT_PENDING;
@@ -3094,14 +3105,21 @@ function handleAsync(
         return;
       }
       if (wasUninitialized) landStatus(el, true);
+      // Attribution hook: this path landed through the setter (derived
+      // stores, projections), which does not go through setSignal, so the
+      // plain branch's asyncEnd never ran and the flight stayed open — the
+      // next flight counted a committed answer as abandoned (#3947).
+      // direct=true: asyncEnd finalizes either way and stamps an async write
+      // only if the commit moved `_value`/`_time` or parked `_pendingValue`.
+      // A store setter does not move this node's `_value`, so no stamp is
+      // recorded and waterfall chaining through derived stores stays
+      // unmeasured. Outside the try (#2883 — see attribution-hooks.ts).
+      if (attrHooks !== null) attrHooks.asyncEnd(el, undefined, value, true);
     } else {
       // CARVE 2: the override-covered landing (hold + A18 supersession) and the
       // lane-routed landing (derived override, lane effect queue) went with
-      // the optimistic engine; every landing is the plain setSignal. A first
-      // answer born into a hold still live lands into it (A29, #3800).
-      let t = el._x._bornIn;
-      el._x._bornIn = null;
-      if (wasUninitialized && t && (t = liveTx(t))) holdNode(el, t);
+      // the optimistic engine; every landing is the plain setSignal. A node
+      // already held stages its answer into that hold (`setSignal`).
       try {
         setSignal(el, () => value);
       } catch (e) {
@@ -3691,9 +3709,16 @@ function recompute(el, create = false) {
     // joins all the same. Not a render effect (rule 3): it is the frame.
     // Re-run outside its transaction's flush it publishes mainline — the
     // value it staged there is superseded (`frameRead` remembers it for the
-    // landing). A frame born into the transaction (uninitialized: never run,
-    // A29) keeps staging: live writes keep it current, it effects at the
-    // swap (ruling A).
+    // landing). A frame born into the transaction (`bornInto`: never run,
+    // A29, or mounted by a pass of it still awaiting its commit, #4010) keeps
+    // staging: live writes keep it current, it effects at the swap (ruling
+    // A).
+    // A pending flight is the transition's own work (#3884). A probe on an
+    // earlier pass left CONFIG_VERDICT, and a frame read here would serve the
+    // committed screen, settle the flight and drop the hold — a superseding
+    // write's verdict would depend on that probe. Cleared for this pass; a
+    // probe in the body re-stamps it after the plain reads.
+    if (el._statusFlags & STATUS_PENDING) el._config &= ~CONFIG_VERDICT;
     if (el._config & CONFIG_HELD) {
       const tx = txOf(el);
       // Held by a blocked lane: the frame joins nothing — a lane never holds
@@ -3701,7 +3726,10 @@ function recompute(el, create = false) {
       // world (`read`), and has left it otherwise.
       if (tx._lane);
       else if (isEffect !== EFFECT_RENDER && !(el._config & CONFIG_VERDICT)) joinPassTx(tx);
-      else if (tx !== flushTransaction && !(el._statusFlags & STATUS_UNINITIALIZED)) {
+      else if (
+        tx !== flushTransaction &&
+        !(el._statusFlags & STATUS_UNINITIALIZED || el._config & CONFIG_HELD_FRAME)
+      ) {
         // Published mainline, it is not held: the frame this pass builds is
         // replaced on the spot (#3404) — this flush's commit retires the
         // committed frame the held pass had parked (`commitPendingNode`),
@@ -3751,12 +3779,12 @@ function recompute(el, create = false) {
   // — here, the finally below, updateIfNecessary — carries it (#3543).
   el._flags = REACTIVE_RECOMPUTING_DEPS | (el._flags & REACTIVE_ZOMBIE);
   el._time = clock;
-  // The pass's previous value: its staging, else the lane's value for a
-  // lane's node (lanes.ts), else the committed one.
+  // The pass's previous value: its staging, else a lane node's lane value
+  // when it has one (lanes.ts), else the committed one.
   let value =
     el._pendingValue !== NOT_PENDING
       ? el._pendingValue
-      : el._config & CONFIG_OVERRIDE
+      : el._config & CONFIG_OVERRIDE && el._x._lane !== NOT_PENDING
         ? el._x._lane
         : el._value;
   let oldHeight = el._height;
@@ -4035,6 +4063,10 @@ function recompute(el, create = false) {
           // derives from the future (`read`), an untracked one throws
           // (A19 exc. 1).
           el._statusFlags |= STATUS_UNINITIALIZED;
+          // A boundary that has not shown content catches it: its fallback
+          // waits for the commit (#3540). (The pass's own status clear above
+          // dropped what the read recorded.)
+          GlobalQueue._fresh?.(el);
         }
       }
       // insertSubs only walks _subs (no scheduling of its own), so a
@@ -4068,16 +4100,18 @@ function recompute(el, create = false) {
   }
   // A first pass that went pending where the born-held arm would have held
   // its value (it read a held node, or a verdict lane's mount read a staging,
-  // #3851) is born into that transaction without holding it: the hold never
-  // waits for a first load (the direction rule), but the answer lands into it
-  // while it is live (A29, #3800).
+  // #3851) is held like it: its answer is the hold's, and the hold waits
+  // for it (A29, #3800) — unless a boundary that has not shown content
+  // catches it: then it is the boundary's, and the hold does not wait (#3540).
   if (
     create &&
     lane === null &&
     (joined || (prevLane && el._flags & REACTIVE_STAGED_READ)) &&
     el._statusFlags & STATUS_PENDING
-  )
-    ext(el)._bornIn = flushTransaction ?? passTx;
+  ) {
+    const t = flushTransaction ?? passTx;
+    if (t !== null && !t._lane && !GlobalQueue._fresh?.(el)) holdNode(el, t);
+  }
   // Dependencies are the committed frame's until it is replaced (A30, #3410):
   // a pass that staged its value leaves the previous pass's tail linked for
   // `commitPendingNode` to trim, so a write to a dependency the committed
@@ -4261,7 +4295,6 @@ function ext(el) {
     _pendingFirstChild: null,
     _pendingDisposal: null,
     _transaction: null,
-    _bornIn: null,
     _reask: false,
     _flushed: NOT_PENDING,
     _flushedAt: -1,
@@ -4283,8 +4316,16 @@ function ext(el) {
  * boundary's, not the tick's (A29's boundary exemption, #3540). */
 function joinPass(c, el) {
   c._flags |= REACTIVE_JOINED;
+  // A new memo's first pass is the hold's work (born held) but not the
+  // tick's: a render effect that reads it decides — under a boundary that
+  // catches it, the boundary's; otherwise the tick joins the hold (#3540:
+  // the reader's position, not where the memo was created). Its catch, if
+  // any, is at its staging.
   if (el._statusFlags & STATUS_UNINITIALIZED || c._type !== EFFECT_RENDER)
-    joinPassTx(txOf(el), GlobalQueue._fresh?.(c));
+    joinPassTx(
+      txOf(el),
+      (!c._type && c._statusFlags & STATUS_UNINITIALIZED) || GlobalQueue._fresh?.(c)
+    );
 }
 /** A15's stale reader (shared-hole and reveal corollaries): a render effect
  * reading a node held by a transaction that is not the flush's. It is served
@@ -4292,11 +4333,11 @@ function joinPass(c, el) {
  * re-derived after that transaction's landing (`_reruns`,
  * REACTIVE_FRAME_READ) so the frame catches up with it once it is the
  * committed world. Not a frame born into that transaction (held and never
- * committed — created by one of its held passes, A29): that one reads its
- * transaction's values and keeps staging. Not of a flight whose inputs are
- * already visible (CONFIG_INPUTS_PUBLISHED, #3305): its committed value
- * would tear against them, so the reveal observes the flight instead. Once
- * per pass.
+ * committed — created by one of its held passes, A29; `bornInto`): that
+ * one reads its transaction's values and keeps staging. Not of a flight
+ * whose inputs are already visible (CONFIG_INPUTS_PUBLISHED, #3305): its
+ * committed value would tear against them, so the reveal observes the
+ * flight instead. Once per pass.
  *
  * Lane work is a stale reader too (maintainer, 2026-10-01: a lane sees the
  * screen plus its own guesses). A held write is held because showing it
@@ -4333,14 +4374,22 @@ function frameRead(c, el) {
   // Lane work and verdict readers are never the transaction's pass, whichever
   // flush runs it: a node T holds re-enters T when it re-runs (`recompute`'s
   // head), and the pass may then read a guess and become the lane's.
-  if (
-    (t === flushTransaction && passLane === null && !verdict) ||
-    (c._statusFlags & STATUS_UNINITIALIZED && c._config & CONFIG_HELD && txOf(c) === t)
-  )
-    return false;
+  if ((t === flushTransaction && passLane === null && !verdict) || bornInto(c, t)) return false;
   staleReader(c, t);
   return true;
 }
+/** A node born into transaction `t`: held by it and never committed (A29,
+ * ruling A) — uninitialized (born held), or a member of the frame one of its
+ * held passes built (CONFIG_HELD_FRAME). Its branch exists only in `t`: it
+ * has no screen to read, so it reads `t`'s values, whichever flush runs it,
+ * and keeps staging (#4010). */
+function bornInto(c, t) {
+  return (
+    (c._statusFlags & STATUS_UNINITIALIZED || c._config & CONFIG_HELD_FRAME) &&
+    c._config & CONFIG_HELD &&
+    txOf(c) === t
+  );
+}
 /** The computed whose pass a creation under `owner` belongs to (a root's is
  * its nearest computed ancestor's), or null outside every pass. */
 function creatorPass(owner) {
@@ -4877,7 +4926,8 @@ function read(el) {
   // effect keeps its DOM by throwing, a memo has no DOM and is handed the
   // value. `[isPending(x), x()]` reads `[true, stale]` in either order (A10)
   // — unless the flight committed beneath inputs already on screen
-  // (`observeFlight`).
+  // (`observeFlight`), or the reader was born into the flight's transaction
+  // (#4010): it has no screen, and waits on the flight with its frame.
   if (
     owner._statusFlags & STATUS_PENDING &&
     !committed &&
@@ -5017,11 +5067,14 @@ function serve(el, c) {
  * write never shows through the lane. A verdict lane's work likewise: the
  * lane holds verdicts, not the frame's other stagings (#3851) — except a
  * verdict reader, which answered for itself (the lane seam, lanes.ts). Not
- * a read of a node born staged: it has no committed value to re-derive on,
- * and a re-run would read the same staging and re-queue every round. */
+ * a read of a node born staged at all: it has no committed value to
+ * re-derive on, and a re-run would read the same staging and re-queue every
+ * round (#3969: nor does it make a later lane read a re-derive, `enterLane`). */
 function stagedRead(c, el) {
-  c._flags |= REACTIVE_STAGED_READ;
-  if (passLane !== null && !(el?._statusFlags & STATUS_UNINITIALIZED)) stagedReaders.push(c);
+  if (!(el?._statusFlags & STATUS_UNINITIALIZED)) {
+    c._flags |= REACTIVE_STAGED_READ;
+    if (passLane !== null) stagedReaders.push(c);
+  }
 }
 /** A10 for a staged node: a verdict reader (the pass entered a window) that
  * also reads a frame's proposal plainly sees the screen — `[latest(q), q()]`
@@ -5030,9 +5083,10 @@ function stagedRead(c, el) {
  * #3322 — one run, on the committed world), or with the hold. Before any
  * transaction the answer is the seam's and the reader watches it
  * (verdict.ts). A node born into the future has no screen: its staging is
- * its only value (A29). */
+ * its only value (A29). Nor has a reader born into the flush's transaction
+ * (`bornInto`, #4010): its branch exists only there. */
 function stagedScreen(c) {
-  if (flushTransaction === null) return false;
+  if (flushTransaction === null || bornInto(c, flushTransaction)) return false;
   staleReader(c, flushTransaction);
   return true;
 }
@@ -5050,9 +5104,10 @@ function notePromotedWrite(el) {
   el._config |= CONFIG_PROMOTED;
   promotedWrites.push(el);
 }
-/** Cold half of setSignal's snapshot arm (see there): first write during
- * capture to a plain signal without a live snapshot records the pre-write
- * value. Only plain user signals qualify. Computeds reach setSignal from an
+/** Cold half of setSignal's snapshot arm (see there), shared with a store
+ * container's structural notify: first write during capture to a plain
+ * signal without a live snapshot records the pre-write value. Only plain
+ * user signals qualify. Computeds reach setSignal from an
  * async landing (asyncWrite), and a value arriving from async during the pass
  * REVEALS — the creation-time arm skips pending computeds for the same
  * reason. Firewall leaves belong to a projection whose compute is the tree's
@@ -5268,7 +5323,7 @@ function markRefresh(node) {
 }
 
 export {
-  CONFIG_INPUTS_PUBLISHED as $,
+  REACTIVE_CHECK as $,
   list as A,
   clock as B,
   CONFIG_GUESS as C,
@@ -5285,154 +5340,158 @@ export {
   NOT_PENDING as N,
   setPassLane as O,
   REACTIVE_JOINED as P,
-  stagedRead as Q,
+  REACTIVE_STAGED_READ as Q,
   REACTIVE_DISPOSED as R,
   STATUS_PENDING as S,
-  attrHooks as T,
-  holdNode as U,
-  joinFuture as V,
-  CONFIG_SLOT_NODE as W,
-  commitPendingNode as X,
-  REACTIVE_IN_HEAP as Y,
-  REACTIVE_DIRTY as Z,
-  REACTIVE_CHECK as _,
+  stagedRead as T,
+  CONFIG_SLOT_NODE as U,
+  attrHooks as V,
+  holdNode as W,
+  joinFuture as X,
+  commitPendingNode as Y,
+  REACTIVE_IN_HEAP as Z,
+  REACTIVE_DIRTY as _,
   CONFIG_OVERRIDE as a,
-  CONFIG_REDERIVE as a$,
-  setVerdict as a0,
-  context as a1,
-  REACTIVE_PROBED as a2,
-  globalQueue as a3,
-  staleReader as a4,
-  REACTIVE_STAGED_READ as a5,
-  verdict as a6,
-  link as a7,
-  pullComputed as a8,
-  strictRead as a9,
-  EFFECT_USER as aA,
-  reportDiagnostic as aB,
-  computed as aC,
-  staleValues as aD,
-  CONFIG_AUTO_DISPOSE as aE,
-  EFFECT_TRACKED as aF,
-  unwrapStatusError as aG,
-  haltReactivity as aH,
-  setStrictRead as aI,
-  StatusError as aJ,
-  trimStaleDeps as aK,
-  setTrackedQueueCallback as aL,
-  setEffectStatusNotify as aM,
-  _hitUnhandledAsync as aN,
-  resetUnhandledAsync as aO,
-  ROOT_ERROR_HOOK as aP,
-  registerGraph as aQ,
-  runWithOwner as aR,
-  setMemo as aS,
-  $REFRESH as aT,
-  markRefresh as aU,
-  createRoot as aV,
-  getObserver as aW,
-  dispose as aX,
-  TimeoutError as aY,
-  untrack as aZ,
-  dirtyQueue as a_,
-  warnStrictReadUntracked as aa,
-  markLateLinker as ab,
-  spectating as ac,
-  STATUS_ERROR as ad,
-  unflushedValue as ae,
-  stagedReaders as af,
-  enterAction as ag,
-  setEffectCallback as ah,
-  exitAction as ai,
-  isThenable as aj,
-  actionDepth as ak,
-  flush as al,
-  setQuestion as am,
-  emitDiagnostic as an,
-  enterCallback as ao,
-  exitCallback as ap,
-  getOwner as aq,
-  inEffectCallback as ar,
-  signal as as,
-  setSignal as at,
-  cleanup as au,
-  read as av,
-  NoOwnerError as aw,
-  ContextNotFoundError as ax,
-  createEffectNode as ay,
-  recompute as az,
+  untrack as a$,
+  CONFIG_INPUTS_PUBLISHED as a0,
+  setVerdict as a1,
+  context as a2,
+  REACTIVE_PROBED as a3,
+  bornInto as a4,
+  globalQueue as a5,
+  staleReader as a6,
+  verdict as a7,
+  link as a8,
+  pullComputed as a9,
+  createEffectNode as aA,
+  recompute as aB,
+  EFFECT_USER as aC,
+  reportDiagnostic as aD,
+  computed as aE,
+  staleValues as aF,
+  CONFIG_AUTO_DISPOSE as aG,
+  EFFECT_TRACKED as aH,
+  unwrapStatusError as aI,
+  haltReactivity as aJ,
+  setStrictRead as aK,
+  StatusError as aL,
+  trimStaleDeps as aM,
+  setTrackedQueueCallback as aN,
+  setEffectStatusNotify as aO,
+  _hitUnhandledAsync as aP,
+  resetUnhandledAsync as aQ,
+  ROOT_ERROR_HOOK as aR,
+  registerGraph as aS,
+  runWithOwner as aT,
+  setMemo as aU,
+  $REFRESH as aV,
+  markRefresh as aW,
+  createRoot as aX,
+  getObserver as aY,
+  dispose as aZ,
+  TimeoutError as a_,
+  strictRead as aa,
+  warnStrictReadUntracked as ab,
+  joinPass as ac,
+  markLateLinker as ad,
+  spectating as ae,
+  STATUS_ERROR as af,
+  unflushedValue as ag,
+  stagedReaders as ah,
+  enterAction as ai,
+  setEffectCallback as aj,
+  exitAction as ak,
+  isThenable as al,
+  actionDepth as am,
+  flush as an,
+  setQuestion as ao,
+  emitDiagnostic as ap,
+  enterCallback as aq,
+  exitCallback as ar,
+  getOwner as as,
+  inEffectCallback as at,
+  signal as au,
+  setSignal as av,
+  cleanup as aw,
+  read as ax,
+  NoOwnerError as ay,
+  ContextNotFoundError as az,
   CONFIG_VERDICT as b,
-  passTx as b0,
-  CONFIG_FRESH_READ as b1,
-  createOwner as b2,
-  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as b3,
-  ownedScopeWriteMessage as b4,
-  DEV as b5,
-  isEqual as b6,
-  CONFIG_MANUAL_WRITE as b7,
-  notePromotedWrite as b8,
-  slotSignal as b9,
-  setSnapshotCapture as bA,
-  setAttributionHooks as bB,
-  liveRootOwners as bC,
-  ownerPath as bD,
-  isSuppressed as bE,
-  blockersOf as bF,
-  CONFIG_PLUMBING as bG,
-  anyExcluded as bH,
-  isExcluded as bI,
-  CONFIG_WIDE as bJ,
-  GRAPH_SIZE_WARN_AT as bK,
-  noteFanOut as bL,
-  CONFIG_SUPERSEDES as bM,
-  stagedScreen as ba,
-  CONFIG_PROMOTED as bb,
-  setSlotUnobserved as bc,
-  joinPassTx as bd,
-  asyncTailFlights as be,
-  untrackDepth as bf,
-  checkPostAwaitRead as bg,
-  insertIntoHeap as bh,
-  isDisposed as bi,
-  handleAsync as bj,
-  addPendingSource as bk,
-  propagateStatus as bl,
-  forEachDependent as bm,
-  settlePendingSource as bn,
-  notifyEpoch as bo,
-  SUPPORTS_PROXY as bp,
-  REACTIVE_ZOMBIE as bq,
-  OBSERVE as br,
-  clearSnapshots as bs,
-  enforceLoadingBoundary as bt,
-  getNextChildId as bu,
-  markSnapshotScope as bv,
-  peekNextChildId as bw,
-  releaseSnapshotScope as bx,
-  resetErrorHalt as by,
-  setConsoleFooter as bz,
+  dirtyQueue as b0,
+  CONFIG_REDERIVE as b1,
+  passTx as b2,
+  CONFIG_FRESH_READ as b3,
+  createOwner as b4,
+  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as b5,
+  ownedScopeWriteMessage as b6,
+  DEV as b7,
+  isEqual as b8,
+  CONFIG_MANUAL_WRITE as b9,
+  peekNextChildId as bA,
+  releaseSnapshotScope as bB,
+  resetErrorHalt as bC,
+  setConsoleFooter as bD,
+  setSnapshotCapture as bE,
+  setAttributionHooks as bF,
+  liveRootOwners as bG,
+  ownerPath as bH,
+  isSuppressed as bI,
+  blockersOf as bJ,
+  CONFIG_PLUMBING as bK,
+  anyExcluded as bL,
+  isExcluded as bM,
+  CONFIG_WIDE as bN,
+  GRAPH_SIZE_WARN_AT as bO,
+  noteFanOut as bP,
+  CONFIG_SUPERSEDES as bQ,
+  snapshotCaptureActive as ba,
+  captureWriteSnapshot as bb,
+  notePromotedWrite as bc,
+  slotSignal as bd,
+  stagedScreen as be,
+  CONFIG_PROMOTED as bf,
+  setSlotUnobserved as bg,
+  joinPassTx as bh,
+  asyncTailFlights as bi,
+  untrackDepth as bj,
+  checkPostAwaitRead as bk,
+  insertIntoHeap as bl,
+  isDisposed as bm,
+  handleAsync as bn,
+  addPendingSource as bo,
+  propagateStatus as bp,
+  forEachDependent as bq,
+  settlePendingSource as br,
+  notifyEpoch as bs,
+  SUPPORTS_PROXY as bt,
+  REACTIVE_ZOMBIE as bu,
+  OBSERVE as bv,
+  clearSnapshots as bw,
+  enforceLoadingBoundary as bx,
+  getNextChildId as by,
+  markSnapshotScope as bz,
   REACTIVE_PROBE_UNANSWERED as c,
   blocked as d,
-  enqueueSub as e,
-  CONFIG_AUTHORITATIVE as f,
-  tracking as g,
-  CONFIG_CHILDREN_FORBIDDEN as h,
-  sameLane as i,
-  CONFIG_HELD as j,
-  flushTransaction as k,
-  STATUS_UNINITIALIZED as l,
-  NotReadyError as m,
+  REACTIVE_LANE_DIRTY as e,
+  enqueueSub as f,
+  CONFIG_AUTHORITATIVE as g,
+  tracking as h,
+  CONFIG_CHILDREN_FORBIDDEN as i,
+  sameLane as j,
+  CONFIG_HELD as k,
+  flushTransaction as l,
+  STATUS_UNINITIALIZED as m,
   nextQuestion as n,
-  REACTIVE_SCREEN_READ as o,
+  NotReadyError as o,
   passLane as p,
   question as q,
   resolveTx as r,
   schedule as s,
   txOf as t,
-  REACTIVE_FRAME_READ as u,
-  REACTIVE_LANE_READ as v,
-  ext as w,
-  REACTIVE_RECOMPUTING_DEPS as x,
-  queuePendingNode as y,
-  REACTIVE_LANE_DIRTY as z
+  REACTIVE_SCREEN_READ as u,
+  REACTIVE_FRAME_READ as v,
+  REACTIVE_LANE_READ as w,
+  ext as x,
+  REACTIVE_RECOMPUTING_DEPS as y,
+  queuePendingNode as z
 };