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

package/dist/dev-shared.js

@@ -306,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
@@ -2032,8 +2034,18 @@ function nextQuestion() {
 }
 const MAINLINE_QUESTION = 0x7fffffff;
 let inEffectCallback = false;
-function setEffectCallback(value) {
-  inEffectCallback = value;
+/** 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) {
@@ -2421,8 +2433,9 @@ class GlobalQueue {
  * 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. */
+ * 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
@@ -2430,6 +2443,7 @@ function reruns(u) {
     // 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
@@ -2440,13 +2454,14 @@ function reruns(u) {
     }
   }
   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);
-  reruns(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
@@ -2461,7 +2476,16 @@ function land(u) {
   // `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);
+  // 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
@@ -2720,8 +2744,22 @@ function flush(fn) {
   // (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) {
-  for (let i = 0; i < queue.length; i++) queue[i](type);
+  {
+    const prev = queueEvent;
+    queueEvent = dispatchingEvent();
+    try {
+      for (let i = 0; i < queue.length; i++) queue[i](type);
+    } finally {
+      queueEvent = prev;
+    }
+    return;
+  }
 }
 
 /**
@@ -2943,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) {
@@ -3011,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) {
@@ -3094,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);
@@ -3160,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);
@@ -3237,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) ||
@@ -3304,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,
@@ -3407,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.
@@ -3523,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
@@ -3686,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;
@@ -3703,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);
     }
@@ -3715,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);
@@ -3755,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 &&
@@ -3766,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
@@ -3794,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);
@@ -3806,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) => {
@@ -3863,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);
     }
@@ -3945,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",
@@ -3978,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;
@@ -4907,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) {
@@ -5056,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.
@@ -5099,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 {
@@ -5111,6 +5210,7 @@ function untrack(fn, strictReadLabel) {
     tracking = prevTracking;
     {
       strictRead = prevStrictRead;
+      strictReadEvent = prevStrictReadEvent;
       untrackDepth--;
     }
   }
@@ -5317,7 +5417,7 @@ function read(el) {
     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,
@@ -5438,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,
@@ -5865,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,
@@ -5876,135 +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,
-  haltReactivityAt as aQ,
-  setStrictRead as aR,
-  StatusError as aS,
-  trimStaleDeps as aT,
-  setTrackedQueueCallback as aU,
-  setEffectStatusNotify as aV,
-  _hitUnhandledAsync as aW,
-  resetUnhandledAsync as aX,
-  ROOT_ERROR_HOOK as aY,
-  registerGraph as aZ,
-  runWithOwner as a_,
+  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,
-  liveRootOwners as b$,
-  $REFRESH as b0,
-  markRefresh as b1,
-  createRoot as b2,
-  getObserver as b3,
-  dispose as b4,
-  TimeoutError as b5,
-  untrack as b6,
-  dirtyQueue as b7,
-  CONFIG_REDERIVE as b8,
-  passTx as b9,
-  settlePendingSource as bA,
-  joinPassAt as bB,
-  notifyEpoch as bC,
-  SUPPORTS_PROXY as bD,
-  releaseMarksHook as bE,
-  installMarkHooks as bF,
-  CONFIG_LAGS as bG,
-  REACTIVE_REASK as bH,
-  haltReactivity as bI,
-  heldUnder as bJ,
-  unhold as bK,
-  laneStageHook as bL,
-  REACTIVE_ZOMBIE as bM,
-  installBoundaryHooks as bN,
-  CAUGHT_REARMED as bO,
-  OBSERVE as bP,
-  clearSnapshots as bQ,
-  enforceLoadingBoundary as bR,
-  getNextChildId as bS,
-  markSnapshotScope as bT,
-  peekNextChildId as bU,
-  releaseSnapshotScope as bV,
-  resetErrorHalt as bW,
-  setConsoleFooter as bX,
-  setSnapshotCapture as bY,
-  setWriteHook as bZ,
-  setAttributionHooks as b_,
-  CONFIG_FRESH_READ as ba,
-  createOwner as bb,
-  writeHook as bc,
-  REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE as bd,
-  ownedScopeWriteMessage as be,
-  isEqual as bf,
-  CONFIG_MANUAL_WRITE as bg,
-  snapshotCaptureActive as bh,
-  captureWriteSnapshot as bi,
-  notePromotedWrite as bj,
-  slotSignal as bk,
-  stagedScreen as bl,
-  CONFIG_PROMOTED as bm,
-  setSlotUnobserved as bn,
-  installStoreHooks as bo,
-  joinPassTx as bp,
-  asyncTailFlights as bq,
-  untrackDepth as br,
-  checkPostAwaitRead as bs,
-  disposalDepth as bt,
-  insertIntoHeap as bu,
-  isDisposed as bv,
-  handleAsync as bw,
-  addPendingSource as bx,
-  propagateStatus as by,
-  forEachDependent as bz,
+  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,
-  ownerPath as c0,
-  isSuppressed as c1,
-  blockersOf as c2,
-  CONFIG_PLUMBING as c3,
-  anyExcluded as c4,
-  isExcluded as c5,
-  CONFIG_WIDE as c6,
-  GRAPH_SIZE_WARN_AT as c7,
-  noteFanOut as c8,
-  CONFIG_SUPERSEDES as c9,
+  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,