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

package/dist/dev.js

@@ -1,167 +1,228 @@
 import {
   C as CONFIG_GUESS,
-  s as schedule,
   N as NOT_PENDING,
-  a as CONFIG_OVERRIDE,
+  a as NotReadyError,
+  b as CONFIG_AUTHORITATIVE,
+  e as enqueueSub,
+  c as CONFIG_OVERRIDE,
+  s as schedule,
   q as question,
   n as nextQuestion,
+  i as installLaneHooks,
   G as GlobalQueue,
-  R as REACTIVE_DISPOSED,
-  b as CONFIG_VERDICT,
-  c as REACTIVE_PROBE_UNANSWERED,
-  d as blocked,
-  e as REACTIVE_LANE_DIRTY,
-  f as enqueueSub,
   r as resolveTx,
-  g as CONFIG_AUTHORITATIVE,
-  t as txOf,
-  h as tracking,
-  i as CONFIG_CHILDREN_FORBIDDEN,
-  p as passLane,
-  S as STATUS_PENDING,
-  E as EFFECT_RENDER,
-  j as sameLane,
+  d as newTransaction,
+  o as ownFlights,
+  R as REACTIVE_DISPOSED,
+  f as CONFIG_VERDICT,
+  g as REACTIVE_PROBE_UNANSWERED,
+  h as blocked,
+  j as REACTIVE_LANE_DIRTY,
   k as CONFIG_HELD,
-  l as flushTransaction,
-  m as STATUS_UNINITIALIZED,
-  o as NotReadyError,
-  u as REACTIVE_SCREEN_READ,
-  v as REACTIVE_FRAME_READ,
-  w as REACTIVE_LANE_READ,
-  x as ext,
-  y as REACTIVE_RECOMPUTING_DEPS,
-  z as queuePendingNode,
-  A as list,
-  B as clock,
-  D as insertSubs,
-  F as laneDirty,
-  H as merge$1,
-  I as newTransaction,
-  J as reruns,
-  K as CONFIG_STAGED,
-  L as releaseQueues,
-  M as ownFlights,
-  O as setPassLane,
-  P as REACTIVE_JOINED,
-  Q as REACTIVE_STAGED_READ,
-  T as stagedRead,
-  U as CONFIG_SLOT_NODE,
-  V as attrHooks,
+  t as txOf,
+  l as clock,
+  m as insertSubs,
+  p as laneDirty,
+  u as REACTIVE_LANE_READ,
+  v as ext,
+  S as STATUS_UNINITIALIZED,
+  w as REACTIVE_RECOMPUTING_DEPS,
+  x as queuePendingNode,
+  y as list,
+  z as STATUS_ERROR,
+  A as tracking,
+  B as CONFIG_CHILDREN_FORBIDDEN,
+  D as passLane,
+  E as STATUS_PENDING,
+  F as EFFECT_RENDER,
+  H as sameLane,
+  I as flushTransaction,
+  J as REACTIVE_SCREEN_READ,
+  K as REACTIVE_FRAME_READ,
+  L as attrHooks,
+  M as commitPendingNode,
+  O as REACTIVE_IN_HEAP,
+  P as REACTIVE_DIRTY,
+  Q as REACTIVE_CHECK,
+  T as CONFIG_INPUTS_PUBLISHED,
+  U as releaseQueues,
+  V as CONFIG_SLOT_NODE,
   W as holdNode,
   X as joinFuture,
-  Y as commitPendingNode,
-  Z as REACTIVE_IN_HEAP,
-  _ as REACTIVE_DIRTY,
-  $ as REACTIVE_CHECK,
-  a0 as CONFIG_INPUTS_PUBLISHED,
-  a1 as setVerdict,
-  a2 as context,
-  a3 as REACTIVE_PROBED,
-  a4 as bornInto,
-  a5 as globalQueue,
-  a6 as staleReader,
+  Y as reruns,
+  Z as CONFIG_STAGED,
+  _ as merge$1,
+  $ as setPassLane,
+  a0 as REACTIVE_JOINED,
+  a1 as REACTIVE_STAGED_READ,
+  a2 as stagedRead,
+  a3 as setVerdict,
+  a4 as context,
+  a5 as installVerdictHooks,
+  a6 as REACTIVE_PROBED,
   a7 as verdict,
   a8 as link,
   a9 as pullComputed,
   aa as strictRead,
   ab as warnStrictReadUntracked,
-  ac as joinPass,
-  ad as markLateLinker,
-  ae as spectating,
-  af as STATUS_ERROR,
-  ag as unflushedValue,
-  ah as stagedReaders,
-  ai as enterAction,
-  aj as setEffectCallback,
-  ak as exitAction,
-  al as isThenable,
-  am as actionDepth,
-  an as flush,
-  ao as setQuestion,
-  ap as emitDiagnostic,
-  aq as enterCallback,
-  ar as exitCallback,
-  as as getOwner,
-  at as inEffectCallback,
-  au as signal,
-  av as setSignal,
-  aw as cleanup,
-  ax as read,
-  ay as NoOwnerError,
-  az as ContextNotFoundError,
-  aA as createEffectNode,
-  aB as recompute,
-  aC as EFFECT_USER,
-  aD as reportDiagnostic,
-  aE as computed,
-  aF as staleValues,
-  aG as CONFIG_AUTO_DISPOSE,
-  aH as EFFECT_TRACKED,
-  aI as unwrapStatusError,
-  aJ as haltReactivity,
-  aK as setStrictRead,
-  aL as StatusError,
-  aM as trimStaleDeps,
-  aN as setTrackedQueueCallback,
-  aO as setEffectStatusNotify,
-  aP as _hitUnhandledAsync,
-  aQ as resetUnhandledAsync,
-  aR as ROOT_ERROR_HOOK,
-  aS as registerGraph,
-  aT as runWithOwner,
-  aU as setMemo,
-  aV as $REFRESH,
-  aW as markRefresh,
-  aX as createRoot,
-  aY as getObserver,
-  aZ as dispose,
-  a_ as TimeoutError,
-  a$ as untrack,
-  b0 as dirtyQueue,
-  b1 as CONFIG_REDERIVE,
-  b2 as passTx,
-  b3 as CONFIG_FRESH_READ,
-  b4 as createOwner,
-  b5 as REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE,
-  b6 as ownedScopeWriteMessage,
-  b7 as DEV$1,
-  b8 as isEqual,
-  b9 as CONFIG_MANUAL_WRITE,
-  ba as snapshotCaptureActive,
-  bb as captureWriteSnapshot,
-  bc as notePromotedWrite,
-  bd as slotSignal,
-  be as stagedScreen,
-  bf as CONFIG_PROMOTED,
-  bg as setSlotUnobserved,
-  bh as joinPassTx,
-  bi as asyncTailFlights,
-  bj as untrackDepth,
-  bk as checkPostAwaitRead,
-  bl as insertIntoHeap,
-  bm as isDisposed,
-  bn as handleAsync,
-  bo as addPendingSource,
-  bp as propagateStatus,
-  bq as forEachDependent,
-  br as settlePendingSource,
-  bs as notifyEpoch,
-  bt as SUPPORTS_PROXY,
-  bu as REACTIVE_ZOMBIE,
-  bv as OBSERVE$1
+  ac as staleReader,
+  ad as globalQueue,
+  ae as joinPass,
+  af as markLateLinker,
+  ag as spectating,
+  ah as unflushedValue,
+  ai as CONFIG_STAGED_ERROR,
+  aj as stagedReaders,
+  ak as bornInto,
+  al as enterAction,
+  am as setEffectCallback,
+  an as exitAction,
+  ao as isThenable,
+  ap as actionDepth,
+  aq as flush,
+  ar as setQuestion,
+  as as emitDiagnostic,
+  at as enterCallback,
+  au as exitCallback,
+  av as getOwner,
+  aw as inEffectCallback,
+  ax as setExternalHooks,
+  ay as signal,
+  az as setSignal,
+  aA as cleanup,
+  aB as read,
+  aC as DEV$1,
+  aD as CONFIG_TRANSPARENT,
+  aE as NoOwnerError,
+  aF as ContextNotFoundError,
+  aG as createEffectNode,
+  aH as recompute,
+  aI as EFFECT_USER,
+  aJ as reportDiagnostic,
+  aK as computed,
+  aL as staleValues,
+  aM as CONFIG_AUTO_DISPOSE,
+  aN as EFFECT_TRACKED,
+  aO as heldRunHook,
+  aP as unwrapStatusError,
+  aQ as haltReactivity,
+  aR as setStrictRead,
+  aS as StatusError,
+  aT as trimStaleDeps,
+  aU as setTrackedQueueCallback,
+  aV as setEffectStatusNotify,
+  aW as _hitUnhandledAsync,
+  aX as resetUnhandledAsync,
+  aY as ROOT_ERROR_HOOK,
+  aZ as registerGraph,
+  a_ as runWithOwner,
+  a$ as setMemo,
+  b0 as $REFRESH,
+  b1 as markRefresh,
+  b2 as createRoot,
+  b3 as getObserver,
+  b4 as dispose,
+  b5 as TimeoutError,
+  b6 as untrack,
+  b7 as dirtyQueue,
+  b8 as CONFIG_REDERIVE,
+  b9 as passTx,
+  ba as CONFIG_FRESH_READ,
+  bb as createOwner,
+  bc as writeHook,
+  bd as REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE,
+  be as ownedScopeWriteMessage,
+  bf as isEqual,
+  bg as CONFIG_MANUAL_WRITE,
+  bh as snapshotCaptureActive,
+  bi as captureWriteSnapshot,
+  bj as notePromotedWrite,
+  bk as slotSignal,
+  bl as stagedScreen,
+  bm as CONFIG_PROMOTED,
+  bn as setSlotUnobserved,
+  bo as installStoreHooks,
+  bp as joinPassTx,
+  bq as asyncTailFlights,
+  br as untrackDepth,
+  bs as checkPostAwaitRead,
+  bt as disposalDepth,
+  bu as insertIntoHeap,
+  bv as isDisposed,
+  bw as handleAsync,
+  bx as addPendingSource,
+  by as propagateStatus,
+  bz as forEachDependent,
+  bA as settlePendingSource,
+  bB as notifyEpoch,
+  bC as SUPPORTS_PROXY,
+  bD as releaseMarksHook,
+  bE as installMarkHooks,
+  bF as CONFIG_LAGS,
+  bG as REACTIVE_REASK,
+  bH as heldUnder,
+  bI as unhold,
+  bJ as laneStageHook,
+  bK as REACTIVE_ZOMBIE,
+  bL as installBoundaryHooks,
+  bM as CAUGHT_REARMED,
+  bN as OBSERVE$1
 } from "./dev-shared.js";
 export {
-  bw as clearSnapshots,
-  bx as enforceLoadingBoundary,
-  by as getNextChildId,
-  bz as markSnapshotScope,
-  bA as peekNextChildId,
-  bB as releaseSnapshotScope,
-  bC as resetErrorHalt,
-  bD as setConsoleFooter,
-  bE as setSnapshotCapture
+  bO as clearSnapshots,
+  bP as enforceLoadingBoundary,
+  bQ as getNextChildId,
+  bR as markSnapshotScope,
+  bS as peekNextChildId,
+  bT as releaseSnapshotScope,
+  bU as resetErrorHalt,
+  bV as setConsoleFooter,
+  bW as setSnapshotCapture,
+  bX as setWriteHook
 } from "./dev-shared.js";
 
+// Truth reads (`until`, `refresh`; CONFIG_AUTHORITATIVE) over lane nodes.
+// Side-effect free and apart from lanes.ts so a truth reader alone does not
+// retain the lane engine: its reads reach these only through `laneRead`,
+// which exists once something installs lanes (`createOptimistic`, verdicts).
+/** A lane node's current value: its guess, or the latest it derived — the
+ * staging a shown lane holds for its next reveal, else its slot; the
+ * committed value while it has none (its first lane pass in flight). */
+function laneValueOf(el) {
+  if (!(el._config & CONFIG_GUESS) && el._pendingValue !== NOT_PENDING) return el._pendingValue;
+  const v = el._x._lane;
+  return v !== NOT_PENDING ? v : el._value;
+}
+/** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
+ * the first one installs these on GlobalQueue (signals.ts `watch`).
+ *
+ * A truth reader's read of a lane node: the lane's value when it is the
+ * truth (#3943), else the truth staged beneath a guess, else the committed
+ * value. */
+function truthRead(el) {
+  if (truth(el)) return laneValueOf(el);
+  if (!(el._config & CONFIG_GUESS)) throw new NotReadyError(null);
+  return el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value;
+}
+/** A guess confirmed: its lane's truth readers re-read — of the lane's
+ * derivations too, which may be the truth now (#3943). */
+function truthConfirmed(l) {
+  for (let i = 0; i < l._nodes.length; i++)
+    for (let s = l._nodes[i]._subs; s !== null; s = s._nextSub)
+      if (s._sub._config & CONFIG_AUTHORITATIVE) enqueueSub(s._sub);
+}
+/** A lane node's value is the truth when every guess beneath it is
+ * confirmed — its source staged a value equal to the guess — and nothing
+ * beneath it is held in the parent: same inputs, same value. */
+function truth(n) {
+  if (n._config & CONFIG_GUESS)
+    return n._pendingValue !== NOT_PENDING && n._equals && n._equals(n._x._lane, n._pendingValue);
+  if (n._pendingValue !== NOT_PENDING) return;
+  if (n._config & CONFIG_OVERRIDE)
+    for (let d = n._deps; d; d = d._nextDep) if (!truth(d._dep)) return;
+  return 1;
+}
+
 // Lanes (plan sec. 28 replay, 2026-10-02; maintainer rulings 2026-10-01/02). 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
@@ -201,14 +262,6 @@ function newLane(parent) {
   lanes.push(l);
   return l;
 }
-/** A lane node's current value: its guess, or the latest it derived — the
- * staging a shown lane holds for its next reveal, else its slot; the
- * committed value while it has none (its first lane pass in flight). */
-function laneValueOf(el) {
-  if (!(el._config & CONFIG_GUESS) && el._pendingValue !== NOT_PENDING) return el._pendingValue;
-  const v = el._x._lane;
-  return v !== NOT_PENDING ? v : el._value;
-}
 /** What the screen shows for a lane's node: the lane's value once the lane
  * has revealed, the committed truth before. */
 function display(el) {
@@ -273,23 +326,28 @@ function applyGuesses(parent) {
     const n = pendingGuesses[i];
     const v = pendingGuesses[i + 1];
     let changed = true;
+    // The frame already holding the slot: a guess over it is a second
+    // suggestion for the slot, and two cannot finish apart (A34 (1)) — the
+    // frames entangle.
+    let holder = null;
     if (n._config & CONFIG_OVERRIDE) {
       // A lane's node already: a guess re-asked, or a derivation guessed
-      // over (its staging is void — the guess is the value now). Two
-      // suggestions for one slot cannot finish apart (A34 (1)): the frames
-      // entangle. The same value re-asked renews the question; nothing to
-      // notify.
+      // over (its staging is void — the guess is the value now). The same
+      // value re-asked renews the question; nothing to notify.
       changed = !n._equals || !n._equals(laneValueOf(n), v);
       if (!(n._config & CONFIG_GUESS)) {
         n._pendingValue = NOT_PENDING;
         n._config |= CONFIG_GUESS;
       }
       n._x._lane = v;
-      const holder = txOf(n)._parent;
-      if (parent !== null && holder !== null) merge$1(parent, holder);
+      holder = txOf(n)._parent;
     } else {
       let l;
-      if (n._config & CONFIG_HELD) l = newLane(txOf(n));
+      // A held node: a truth staged there, or what a corrected guess showed.
+      // The guess composes on it, so it ends with that hold — and with its
+      // own frame's (F-11): it lands only when both have (the board's rapid
+      // adds — a later add's row reverted with an earlier add's landing).
+      if (n._config & CONFIG_HELD) l = newLane((holder = txOf(n)));
       else {
         if (parent === null && inFlight$1(n)) parent = newTransaction(false);
         if (parent === null) continue;
@@ -305,6 +363,7 @@ function applyGuesses(parent) {
       n._config |= CONFIG_OVERRIDE | CONFIG_GUESS;
       list(n, l);
     }
+    if (parent !== null && holder !== null) merge$1(parent, holder);
     ext(n)._q = pendingGuesses[i + 2];
     if (changed) {
       // The lane's members re-derive as its work (REACTIVE_LANE_DIRTY): a
@@ -504,37 +563,6 @@ function supersede(n, value, changed) {
   n._pendingValue = value;
   joinFuture(parent);
 }
-/** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
- * the first one installs these on GlobalQueue (signals.ts `watch`).
- *
- * A truth reader's read of a lane node: the lane's value when it is the
- * truth (#3943), else the truth staged beneath a guess, else the committed
- * value. */
-function truthRead(el) {
-  return truth(el)
-    ? laneValueOf(el)
-    : el._config & CONFIG_GUESS && el._pendingValue !== NOT_PENDING
-      ? el._pendingValue
-      : el._value;
-}
-/** A guess confirmed: its lane's truth readers re-read — of the lane's
- * derivations too, which may be the truth now (#3943). */
-function truthConfirmed(l) {
-  for (let i = 0; i < l._nodes.length; i++)
-    for (let s = l._nodes[i]._subs; s !== null; s = s._nextSub)
-      if (s._sub._config & CONFIG_AUTHORITATIVE) enqueueSub(s._sub);
-}
-/** A lane node's value is the truth when every guess beneath it is
- * confirmed — its source staged a value equal to the guess — and nothing
- * beneath it is held in the parent: same inputs, same value. */
-function truth(n) {
-  if (n._config & CONFIG_GUESS)
-    return n._pendingValue !== NOT_PENDING && n._equals && n._equals(n._x._lane, n._pendingValue);
-  if (n._pendingValue !== NOT_PENDING) return;
-  if (n._config & CONFIG_OVERRIDE)
-    for (let d = n._deps; d; d = d._nextDep) if (!truth(d._dep)) return;
-  return 1;
-}
 /** A lane's end, two ways. `into === null`: the parent landed — the lane's
  * values are the truth now: a guess lands the truth staged beneath it or
  * reverts to the one it covered (`_value`, untouched by the guess); a
@@ -669,9 +697,11 @@ function dissolveLane(l, into, except) {
 function laneRead(c, el) {
   const guess = el._config & CONFIG_GUESS;
   if (c !== null && c._config & CONFIG_AUTHORITATIVE) return GlobalQueue._truth(el);
+  const status = el._statusFlags;
+  // An errored member's lane value predates its error; the error is the answer (#4106).
+  if (!guess && status & STATUS_ERROR) return NOT_PENDING;
   if (c === null) return laneValueOf(el);
   const l = txOf(el);
-  const status = el._statusFlags;
   if (!tracking || c._config & CONFIG_CHILDREN_FORBIDDEN) {
     // An untracked read inside lane work derives from the lane like a
     // tracked one, minus the subscription — `untrack` is about
@@ -898,20 +928,16 @@ function answered(el) {
   }
   return q;
 }
-GlobalQueue._laneRead = laneRead;
-GlobalQueue._laneStage = laneStage;
-GlobalQueue._laneOutcome = laneOutcome;
-GlobalQueue._laneWrite = laneWrite;
 /** The lanes alive before this seam's guesses opened theirs (a prefix of
  * `lanes`; nothing dissolves one between here and the seam loop): a lane
  * born at the seam has no work to judge yet (its passes run next round) —
  * it is neither shown nor blocked until it has. */
 let judged = 0;
-GlobalQueue._applyGuesses = parent => {
+const applyGuessesAt = parent => {
   judged = lanes.length;
   if (pendingGuesses.length !== 0) applyGuesses(parent);
 };
-GlobalQueue._laneSeams = leaks => {
+const laneSeams = leaks => {
   // Passes that read a write the parked frame holds as the screen
   // (`stagedReaders`: lane work, a verdict reader before the verdict): they
   // re-derive on the committed world next round (and register as stale
@@ -949,8 +975,17 @@ GlobalQueue._laneSeams = leaks => {
   for (let k = Math.min(judged, lanes.length) - 1; k >= 0; k--)
     laneSeam(lanes[k], leaked.indexOf(lanes[k]) !== -1);
 };
-GlobalQueue._laneCorrections = () => lanes.length !== 0 && laneCorrections();
-GlobalQueue._endLanes = endLanes;
+installLaneHooks(
+  laneRead,
+  laneStage,
+  laneOutcome,
+  laneWrite,
+  applyGuessesAt,
+  laneSeams,
+  () => lanes.length !== 0 && laneCorrections(),
+  endLanes,
+  lanesBlocked
+);
 GlobalQueue._laneGuesses = t => {
   const out = [];
   for (let i = 0; i < lanes.length; i++) {
@@ -962,7 +997,6 @@ GlobalQueue._laneGuesses = t => {
   }
   return out;
 };
-GlobalQueue._lanesBlocked = lanesBlocked;
 GlobalQueue._verdictLane = verdictLane;
 
 // Verdicts (plan sec. 28 replay, 2026-10-02; maintainer, 2026-10-01: verdicts are
@@ -1116,7 +1150,7 @@ function heldNotFinal(owner) {
     !latestActive &&
     !owner._x._reask &&
     !(owner._statusFlags & STATUS_UNINITIALIZED) &&
-    (!owner._equals || !owner._equals(owner._value, owner._pendingValue))
+    (!!owner._x._shownError || !owner._equals || !owner._equals(owner._value, owner._pendingValue))
   );
 }
 /** `isPending`'s answer for an unheld node whose flight is up (cause ii). */
@@ -1160,6 +1194,38 @@ function latest(fn) {
     setVerdict(prevVerdict);
   }
 }
+/**
+ * Reports whether what `fn` reads is still waiting on an update. Read the
+ * values in question inside `fn`: the probe answers `true` while any of
+ * them depends on a change that is in flight — a write or an async source
+ * that has started producing a new value whose result has not landed yet —
+ * and `false` once the latest value is the one on screen. The answer is
+ * tracked like any read, so a memo or effect that calls `isPending` re-runs
+ * when it flips.
+ *
+ * A read that has no value yet is loading, not pending: inside `fn` it
+ * follows the surrounding `Loading` path like any other read, and the probe
+ * reports only updates to a value that already exists. A bare `refresh()`
+ * does not flip `isPending`; pair it with `affects()` to make the re-ask
+ * visible.
+ *
+ * @param fn expression to probe; read the values in question inside it
+ *
+ * @returns `true` while a read inside `fn` depends on a change that has not committed yet
+ *
+ * @example
+ * ```ts
+ * const [query, setQuery] = createSignal("");
+ * const results = createMemo(() => searchProducts(query()));
+ * const stale = createMemo(() => isPending(results));
+ *
+ * setQuery("shoes");
+ * // stale() is true until the new results land, while results() keeps
+ * // serving the previous list — dim it instead of showing a spinner.
+ * ```
+ *
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/is-pending
+ */
 function isPending(fn) {
   markVerdictReader(1);
   const prevProbing = probing;
@@ -1186,12 +1252,17 @@ function isPending(fn) {
     setVerdict(prevVerdict);
   }
 }
+/** The staging, or the staged error thrown (D-41). */
+function staged(el) {
+  if (el._config & CONFIG_STAGED_ERROR) throw el._pendingValue;
+  return el._pendingValue;
+}
 /** `latest()` of a held node: the flushed staging — the proposal — and, for
  * a tracked reader of a rewrite not yet flushed, the late-linker re-run in
  * the flush that carries it. */
 function heldLatest(el, c) {
   const u = unflushedValue(el);
-  if (u === NOT_PENDING) return el._pendingValue;
+  if (u === NOT_PENDING) return staged(el);
   if (c !== null) markLateLinker(c);
   return u;
 }
@@ -1239,7 +1310,10 @@ function verdictValue(el, c) {
     probeFound = true;
     if (tracked && flushTransaction !== null) verdictRead(c, flushTransaction);
   }
-  if (el._config & CONFIG_OVERRIDE) {
+  if (
+    el._config & CONFIG_OVERRIDE &&
+    !(owner._statusFlags & STATUS_ERROR && !(el._config & CONFIG_GUESS))
+  ) {
     const l = txOf(el);
     if (tracked) verdictRead(c, l._parent ?? l);
     const flying = (owner._statusFlags & STATUS_PENDING) !== 0 && !quietPending(owner);
@@ -1304,7 +1378,7 @@ function verdictValue(el, c) {
     // has not shown content) and answers for the commit, where it is final.
     if (el._pendingValue !== NOT_PENDING && !(owner._statusFlags & STATUS_PENDING)) {
       if (probing && owned) joinPass(c, el);
-      return el._pendingValue;
+      return staged(el);
     }
   } else if (el._pendingValue !== NOT_PENDING) {
     if (owner._statusFlags & STATUS_PENDING && !uninitialized)
@@ -1321,7 +1395,7 @@ function verdictValue(el, c) {
       // A28: an unflushed write is not what `latest` serves; a tracked
       // reader derived from the flushed world runs again in the carrying
       // flush.
-      if (globalQueue._running) return el._pendingValue;
+      if (globalQueue._running) return staged(el);
       if (c !== null) markLateLinker(c);
     }
     return el._value;
@@ -1343,7 +1417,7 @@ function verdictValue(el, c) {
 // Installed at module evaluation — present exactly when something imports
 // `latest` or `isPending`. (`read` dispatches to `verdictValue` through
 // `verdict`, set while a window is open.)
-GlobalQueue._observeFlight = observeFlight;
+installVerdictHooks(observeFlight);
 /** A store read inside an untracked `isPending` probe found a live mark on
  * a record with no node to carry it (store/affects.ts): not final. */
 GlobalQueue._witnessMark = () => {
@@ -1589,7 +1663,7 @@ let externalSourceConfig = null;
  * ```
  */
 // Wires a freshly created computed through the active external-source bridge.
-// Lives here (installed on GlobalQueue while a config is active) rather than
+// Lives here (installed as a scheduler hook while a config is active) rather than
 // inline in core: esbuild cannot literal-track the mutable config binding the
 // way rollup does, so an inline `if (externalSourceConfig)` block ships in
 // every bundle even though only enableExternalSource() can make it reachable.
@@ -1611,8 +1685,8 @@ function externalUntrack(fn) {
 // removed on reset) so core's presence checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-  GlobalQueue._wireExternalSource = externalSourceConfig ? wireExternalSource : undefined;
-  GlobalQueue._externalUntrack = externalSourceConfig ? externalUntrack : undefined;
+  if (externalSourceConfig) setExternalHooks(wireExternalSource, externalUntrack);
+  else setExternalHooks(undefined, undefined);
 }
 function enableExternalSource(config) {
   const { factory, untrack: untrackFn = fn => fn() } = config;
@@ -1638,6 +1712,61 @@ function enableExternalSource(config) {
   syncExternalHooks();
 }
 
+// Deferred hydration, dependency edges: plain-signal identities.
+// While on (`setSignalIdentities`; the server-components client turns it on
+// before hydrating), a plain signal created under an id-bearing owner is
+// named `<owner id>~<n>`, n counting the plain signals (and plain store
+// roots: `createStore` over an object, store/edges.ts) created under that
+// owner in its current pass (transparent owners defer to the nearest
+// id-bearing one, as child ids do). The server names the same signal the
+// same way and restarts the count on every re-run, so an edge it shipped (a
+// slot fill read it) matches the client node; the write hook receives the
+// node and looks its name up (`signalName`). The count restarts when the owner's pass
+// generation (`_depGen`, bumped by every recompute) moves on. Only the
+// frames client imports this module, so nothing here ships without it.
+// Names live in a side table, not on the node: frames reads them across the
+// package boundary, where a mangled field would not survive.
+let counts = null;
+const names = new WeakMap();
+/** @internal The identity of a plain signal named while identities were on. */
+function signalName(node) {
+  return node === undefined ? undefined : names.get(node);
+}
+function identify(node) {
+  let o = getOwner();
+  if (!o) return;
+  while (o._config & CONFIG_TRANSPARENT && o._parent) o = o._parent;
+  if (o.id == null) return;
+  const gen = o._depGen;
+  let c = counts.get(o);
+  if (c === undefined || c[0] !== gen) counts.set(o, (c = [gen, 0]));
+  const sid = o.id + "~" + c[1]++;
+  // A store root named twice (one object made into two stores, or a store
+  // handed to `createStore`) is one target under two server names: its
+  // writes cannot be attributed (an empty name).
+  names.set(node, names.has(node) ? "" : sid);
+}
+/** @internal Name plain signals from now on (`on`), or stop. */
+function setSignalIdentities(on) {
+  counts = on ? counts || new WeakMap() : null;
+  signalHook = on ? identify : null;
+}
+/**
+ * @internal Called with every plain signal `createSignal` makes, and every
+ * plain store root `createStore` makes, while set (the namer above). Never
+ * set unless `setSignalIdentities` is imported, so a bundle without it keeps
+ * only a null check.
+ */
+let signalHook = null;
+/**
+ * @internal Dev only: `watch` is called with every node read while set (the
+ * dev hook `onRead`) — the frames client's identity-drift check watches the
+ * named signals a deferred occurrence reads as it mounts. A no-op in prod.
+ */
+function setReadWatch(watch) {
+  DEV$1.hooks.onRead = watch || undefined;
+}
+
 /**
  * Context provides a form of dependency injection. It is used to save from needing to pass
  * data as props through intermediate components. This function creates a new context object
@@ -1798,7 +1927,7 @@ function runEffect(node, type) {
   // hidden subtree. The synchronous first render on creation is not a queued
   // run and goes through. `_modified` stays set; the boundary re-queues the
   // run (`release`).
-  if (GlobalQueue._heldRun && GlobalQueue._heldRun(node)) return;
+  if (heldRunHook?.(node)) return;
   // Error arm (#2840), user effects only: a compute-phase error that is still
   // the node's settled state at effect time runs the bundle's error handler in
   // this same imperative, writable scope. Unwrap the StatusError used for
@@ -1893,7 +2022,7 @@ function trackedEffect(fn, options) {
     // pass, but several passes in one flush each enqueue `_run` into the same
     // user queue, and this gate is what collapses them into one run.
     if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
-    if (GlobalQueue._heldRun && GlobalQueue._heldRun(node)) return;
+    if (heldRunHook?.(node)) return;
     setTrackedQueueCallback(true);
     try {
       node._modified = false;
@@ -2024,6 +2153,155 @@ function reportClientError(error, owner, thrower) {
   }
 }
 
+/**
+ * Ownership stamp (#3360): every backing the store ALLOCATES (CoW clones,
+ * privatized committed backings) carries its owning target under this
+ * enumerable symbol. One property write replaces the two weak-collection
+ * registrations (ownership set + raw→target map) a fresh object used to pay
+ * per draft — V8's identity-hash + ephemeron cost dominated the one-key
+ * write floor. Enumerable so a spread copy (the plain-data clone path) stays
+ * on the fast path and carries the stamp along.
+ *
+ * Owned backings are never user-reachable (`snapshot` copies them, the traps
+ * hide the key), so every raw key walk in the store must skip `$OWNER`, and
+ * ownership is answered by `isOwned` — a user object never carries it.
+ * Overlay drafts (`Object.create(v)` over an owned `v`) inherit the stamp.
+ */
+const $OWNER = Symbol("STORE_OWNER");
+/** raw → target for plain (family-less) stores. Family stores use their own
+ * map so one raw can wrap once per family (§7b). */
+const storeLookup = new WeakMap();
+function setLookup(raw, t) {
+  (t.fam?.map ?? storeLookup).set(raw, t);
+}
+function isOwned(raw) {
+  return raw[$OWNER] !== undefined;
+}
+/** The target wrapping `raw` in `fam` (or the plain lookup). An owned raw
+ * answers from its stamp; a user raw from the map. */
+function lookupTarget(raw, fam) {
+  const owner = raw[$OWNER];
+  return owner !== undefined && owner.fam === fam ? owner : (fam?.map ?? storeLookup).get(raw);
+}
+function devAssertNeverUserMutation(target) {
+  return;
+}
+/** Sticky descendants flag up the parent chain (§6d): adoption descends
+ * into a changed child pair only where a target with nodes exists below. */
+function markDescendants(target) {
+  let t = target;
+  while (t && !t.d) {
+    t.d = true;
+    t = t.u;
+  }
+}
+/** Observe tier: the owner in scope at `createStore` (attribution names and
+ * owner paths); the `_owner` write never reaches the proxy. */
+const storeOwners = new WeakMap();
+/** Brand keys the proxy answers directly (never user data). */
+const $TRACK = Symbol("STORE_TRACK"),
+  $TARGET = Symbol("STORE_TARGET"),
+  $PROXY = Symbol("STORE_PROXY"),
+  $RECORD = Symbol("VIEW_RECORD");
+// ---------------------------------------------------------------------------
+// raw marking (R42 / RUL-12: a value is never both wrapped and raw)
+const rawValues = new WeakSet();
+let rawValuesUsed = false;
+function isRawValue(value) {
+  return rawValuesUsed && rawValues.has(value);
+}
+/** Mark a value so no store ever wraps it (sticky; it reads as a leaf). */
+function markRaw(value) {
+  if (isWrappable(value)) {
+    rawValuesUsed = true;
+    rawValues.add(value);
+  }
+  return value;
+}
+/** A shallow store's ingested record: raw by contract (values served
+ * verbatim, slots replaced by reference). */
+function markRawOne(v) {
+  if (isWrappable(v)) {
+    if (v[$TARGET] !== undefined) return;
+    if (lookupTarget(v, null) !== undefined)
+      throw new Error(
+        "shallow store: an ingested record is already tracked as a deep store — one value cannot present both wrapped and raw"
+      );
+    rawValuesUsed = true;
+    rawValues.add(v);
+  }
+}
+function markRawIngest(container) {
+  if (Array.isArray(container)) {
+    for (let i = 0, len = container.length; i < len; i++) markRawOne(container[i]);
+  } else {
+    for (const k in container) markRawOne(container[k]);
+  }
+}
+// ---------------------------------------------------------------------------
+// wrappability
+const OBJECT_PROTO = Object.prototype;
+const wrappableProtos = new WeakMap();
+function isWrappable(obj) {
+  if (obj == null || typeof obj !== "object" || Object.isFrozen(obj)) return false;
+  const proto = Object.getPrototypeOf(obj);
+  if (proto === OBJECT_PROTO || proto === null) return true;
+  if (Array.isArray(obj)) return true;
+  let wrappable = wrappableProtos.get(proto);
+  if (wrappable === undefined) {
+    wrappable =
+      Object.prototype.toString.call(obj) === "[object Object]" &&
+      (typeof Node === "undefined" || !(obj instanceof Node));
+    wrappableProtos.set(proto, wrappable);
+  }
+  return wrappable;
+}
+function ownEnumerableKeys(o) {
+  return Reflect.ownKeys(o).filter(k => Object.prototype.propertyIsEnumerable.call(o, k));
+}
+// ---------------------------------------------------------------------------
+// write override: a projection's draft ops carry it (the derive is the
+// author — its writes must land outside the sync setter scope too, in a
+// continuation after an `await`/`yield`). Projections return in S3; the
+// traps already honour it.
+let writeOverride = false;
+function setWriteOverride(value) {
+  writeOverride = value;
+}
+
+/**
+ * Deferred hydration, dependency edges for stores. Only the frames client
+ * imports this module, so nothing here ships without it.
+ *
+ * A plain store root (`createStore` over an object) is named like a plain
+ * signal (core/identities.ts: `<owner id>~<n>`, on the same count), and the
+ * whole store goes by that one name: the server records it for any read of
+ * the store, at any depth, and a setter call on the store — on its root or
+ * on a proxy nested in it — is a write to it. Its readers mount at the
+ * setter's entry, before the draft runs, as a plain signal's do.
+ */
+/**
+ * @internal The name of the store `x` belongs to — `x` a store proxy (a
+ * setter's entry) or one of its property nodes (the setter notifying it) —
+ * or undefined when it has none or it cannot be placed: a projection or
+ * optimistic family, a store chained over another store's proxy, a root
+ * named twice, or a proxy reached through a store other than the one it
+ * was named as the root of.
+ */
+function storeName(x) {
+  if (x === undefined) return undefined;
+  let t = x._config & CONFIG_SLOT_NODE ? x._host : x[$TARGET];
+  if (t === undefined) return undefined;
+  // Up to the root; a target on the way named as a root of its own is one
+  // object in two stores.
+  while (t.u !== null) {
+    if (t.fam !== null || t.ch || signalName(t) !== undefined) return undefined;
+    t = t.u;
+  }
+  if (t.fam !== null || t.ch) return undefined;
+  return signalName(t) || undefined;
+}
+
 /**
  * Low-level reactive-cleanup primitive. Registers a callback that runs when
  * the surrounding owner is disposed.
@@ -2112,6 +2390,7 @@ function createSignal(first, second) {
   }
   const node = signal(first, second);
   registerGraph(node, getOwner());
+  if (signalHook !== null) signalHook(node);
   return [accessor(node), setSignal.bind(null, node)];
 }
 function createOptimistic(first, second) {
@@ -2193,7 +2472,7 @@ function createMemo(compute, options) {
  * );
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-effect
  */
 function createEffect(compute, effectFn, options) {
   if (effectFn === undefined) {
@@ -2242,7 +2521,7 @@ function createEffect(compute, effectFn, options) {
  * }
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-render-effect
  */
 function createRenderEffect(compute, effectFn, options) {
   effect(compute, effectFn, undefined, options);
@@ -2290,7 +2569,7 @@ function createRenderEffect(compute, effectFn, options) {
  * });
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-tracked-effect
  */
 function createTrackedEffect(compute, options) {
   trackedEffect(compute, options);
@@ -2319,7 +2598,7 @@ function createTrackedEffect(compute, options) {
  * setCount(1); // logs once, reaction re-armed for next change
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-reaction
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-reaction
  */
 function createReaction(effectFn, options) {
   let cl = undefined;
@@ -2389,15 +2668,21 @@ function watch(fn, onValue, onError, config = 0, inPass, own = flushTransaction)
   // after: the first pass's own error is the promise's rejection.)
   computed(
     () => {
-      let v;
+      let v,
+        failed = false;
       try {
         v = fn();
       } catch (e) {
         if (e instanceof NotReadyError) throw e;
-        queueMicrotask(() => onError(unwrapStatusError(e)));
-        return;
+        // An error is an answer (D-41): delivered by the same frame rule.
+        v = unwrapStatusError(e);
+        failed = true;
       }
       const c = getOwner();
+      // A truth reader waits out a `createDeferred` flight its value derives
+      // from, which serves everyone else the stale answer (D-40).
+      const lag = config & CONFIG_AUTHORITATIVE && GlobalQueue._lagging?.(c);
+      if (lag) throw new NotReadyError(lag);
       // (Outside a flush a mainline pass joins through `passTx`.)
       const joined = flushTransaction ?? passTx;
       if (
@@ -2408,6 +2693,7 @@ function watch(fn, onValue, onError, config = 0, inPass, own = flushTransaction)
         staleReader(c, resolveTx(joined));
         return;
       }
+      if (failed) return void queueMicrotask(() => onError(v));
       inPass?.(v);
       queueMicrotask(() => onValue(v));
     },
@@ -2769,122 +3055,6 @@ function onSettled(callback) {
       });
 }
 
-/**
- * Ownership stamp (#3360): every backing the store ALLOCATES (CoW clones,
- * privatized committed backings) carries its owning target under this
- * enumerable symbol. One property write replaces the two weak-collection
- * registrations (ownership set + raw→target map) a fresh object used to pay
- * per draft — V8's identity-hash + ephemeron cost dominated the one-key
- * write floor. Enumerable so a spread copy (the plain-data clone path) stays
- * on the fast path and carries the stamp along.
- *
- * Owned backings are never user-reachable (`snapshot` copies them, the traps
- * hide the key), so every raw key walk in the store must skip `$OWNER`, and
- * ownership is answered by `isOwned` — a user object never carries it.
- * Overlay drafts (`Object.create(v)` over an owned `v`) inherit the stamp.
- */
-const $OWNER = Symbol("STORE_OWNER");
-/** raw → target for plain (family-less) stores. Family stores use their own
- * map so one raw can wrap once per family (§7b). */
-const storeLookup = new WeakMap();
-function setLookup(raw, t) {
-  (t.fam?.map ?? storeLookup).set(raw, t);
-}
-function isOwned(raw) {
-  return raw[$OWNER] !== undefined;
-}
-/** The target wrapping `raw` in `fam` (or the plain lookup). An owned raw
- * answers from its stamp; a user raw from the map. */
-function lookupTarget(raw, fam) {
-  const owner = raw[$OWNER];
-  return owner !== undefined && owner.fam === fam ? owner : (fam?.map ?? storeLookup).get(raw);
-}
-function devAssertNeverUserMutation(target) {
-  return;
-}
-/** Sticky descendants flag up the parent chain (§6d): adoption descends
- * into a changed child pair only where a target with nodes exists below. */
-function markDescendants(target) {
-  let t = target;
-  while (t && !t.d) {
-    t.d = true;
-    t = t.u;
-  }
-}
-/** Observe tier: the owner in scope at `createStore` (attribution names and
- * owner paths); the `_owner` write never reaches the proxy. */
-const storeOwners = new WeakMap();
-/** Brand keys the proxy answers directly (never user data). */
-const $TRACK = Symbol("STORE_TRACK"),
-  $TARGET = Symbol("STORE_TARGET"),
-  $PROXY = Symbol("STORE_PROXY"),
-  $RECORD = Symbol("VIEW_RECORD");
-// ---------------------------------------------------------------------------
-// raw marking (R42 / RUL-12: a value is never both wrapped and raw)
-const rawValues = new WeakSet();
-let rawValuesUsed = false;
-function isRawValue(value) {
-  return rawValuesUsed && rawValues.has(value);
-}
-/** Mark a value so no store ever wraps it (sticky; it reads as a leaf). */
-function markRaw(value) {
-  if (isWrappable(value)) {
-    rawValuesUsed = true;
-    rawValues.add(value);
-  }
-  return value;
-}
-/** A shallow store's ingested record: raw by contract (values served
- * verbatim, slots replaced by reference). */
-function markRawOne(v) {
-  if (isWrappable(v)) {
-    if (v[$TARGET] !== undefined) return;
-    if (lookupTarget(v, null) !== undefined)
-      throw new Error(
-        "shallow store: an ingested record is already tracked as a deep store — one value cannot present both wrapped and raw"
-      );
-    rawValuesUsed = true;
-    rawValues.add(v);
-  }
-}
-function markRawIngest(container) {
-  if (Array.isArray(container)) {
-    for (let i = 0, len = container.length; i < len; i++) markRawOne(container[i]);
-  } else {
-    for (const k in container) markRawOne(container[k]);
-  }
-}
-// ---------------------------------------------------------------------------
-// wrappability
-const OBJECT_PROTO = Object.prototype;
-const wrappableProtos = new WeakMap();
-function isWrappable(obj) {
-  if (obj == null || typeof obj !== "object" || Object.isFrozen(obj)) return false;
-  const proto = Object.getPrototypeOf(obj);
-  if (proto === OBJECT_PROTO || proto === null) return true;
-  if (Array.isArray(obj)) return true;
-  let wrappable = wrappableProtos.get(proto);
-  if (wrappable === undefined) {
-    wrappable =
-      Object.prototype.toString.call(obj) === "[object Object]" &&
-      (typeof Node === "undefined" || !(obj instanceof Node));
-    wrappableProtos.set(proto, wrappable);
-  }
-  return wrappable;
-}
-function ownEnumerableKeys(o) {
-  return Reflect.ownKeys(o).filter(k => Object.prototype.propertyIsEnumerable.call(o, k));
-}
-// ---------------------------------------------------------------------------
-// write override: a projection's draft ops carry it (the derive is the
-// author — its writes must land outside the sync setter scope too, in a
-// continuation after an `await`/`yield`). Projections return in S3; the
-// traps already honour it.
-let writeOverride = false;
-function setWriteOverride(value) {
-  writeOverride = value;
-}
-
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : undefined;
   const indexes = map.length > 1;
@@ -3058,6 +3228,79 @@ function commitSmallMove(data, newItems, newLen, srcPos, dstPos, runs) {
   }
   return true;
 }
+/** Stage a PURE REMOVAL without the key map: when the new window is the old
+ * window with items dropped, in order (one-item removals, every-nth, the
+ * table filters), a two-pointer walk lands every survivor in the window
+ * stage with one key call per item and returns the leavers; a shape that is
+ * not an ordered subsequence returns null with the node stage cleared, and
+ * the map path below starts from scratch (it rewrites every window slot of
+ * `temp` / `rows` / `indexes`, so only `tempNodes`' `!== undefined` probe
+ * needs the reset). The stage arrays are scratch — nothing live is touched. */
+function stageRemoval(data, newItems, start, end, newEnd, temp, tempNodes, rows, indexes) {
+  const key = data._key;
+  const oldItems = data._items;
+  const nodes = data._nodes;
+  const removed = [];
+  let i = start;
+  for (let j = start; j <= newEnd; i++, j++) {
+    const nk = key ? key(newItems[j]) : newItems[j];
+    while (i <= end && (key ? key(oldItems[i]) : oldItems[i]) !== nk) removed.push(nodes[i++]);
+    if (i > end) {
+      tempNodes.fill(undefined);
+      return null;
+    }
+    temp[j] = data._mappings[i];
+    tempNodes[j - start] = nodes[i];
+    if (rows) rows[j - start] = data._rows[i];
+    if (indexes) indexes[j - start] = data._indexes[i];
+  }
+  for (; i <= end; i++) removed.push(nodes[i]);
+  return removed;
+}
+/** Land a staged window into the live bookkeeping arrays in place: shift the
+ * suffix by `dif` (a loop walked from the side that never overwrites an
+ * unread slot), take the window from the stage, write survivors' row and
+ * index signals. Its own function so the general path's body stays under
+ * the JIT's optimization budget — the inlined commit measured ~10% slower on
+ * full-window reorders (the small-move note has the same finding). */
+function commitWindow(data, newItems, newLen, start, end, newEnd, tempNodes, rows, indexes) {
+  const nodes = data._nodes;
+  const liveRows = data._rows;
+  const liveIndexes = data._indexes;
+  const oldLen = data._len;
+  const dif = newLen - oldLen;
+  let i, j;
+  if (dif > 0) {
+    // Grow first: a store past the end from the top is a third slower than
+    // filling a pre-sized tail (measured on 1k refs, 2026-10-15).
+    nodes.length = newLen;
+    if (liveRows) liveRows.length = newLen;
+    if (liveIndexes) liveIndexes.length = newLen;
+    for (i = oldLen - 1, j = newLen - 1; i > end; i--, j--) {
+      nodes[j] = nodes[i];
+      if (liveRows) liveRows[j] = liveRows[i];
+      if (liveIndexes) liveIndexes[j] = liveIndexes[i];
+    }
+  } else if (dif < 0) {
+    for (i = end + 1, j = newEnd + 1; i < oldLen; i++, j++) {
+      nodes[j] = nodes[i];
+      if (liveRows) liveRows[j] = liveRows[i];
+      if (liveIndexes) liveIndexes[j] = liveIndexes[i];
+    }
+    nodes.length = newLen;
+    if (liveRows) liveRows.length = newLen;
+    if (liveIndexes) liveIndexes.length = newLen;
+  }
+  for (j = start; j <= newEnd; j++) {
+    nodes[j] = tempNodes[j - start];
+    if (liveRows) setSignal((liveRows[j] = rows[j - start]), newItems[j]);
+    if (liveIndexes) setSignal((liveIndexes[j] = indexes[j - start]), j);
+  }
+  for (j = newEnd + 1; j < newLen; j++) {
+    if (liveRows) setSignal(liveRows[j], newItems[j]);
+    if (liveIndexes && dif !== 0) setSignal(liveIndexes[j], j);
+  }
+}
 function updateKeyedMap() {
   // Untracked reads inside the internal owner resolve via _parentComputed:
   // routed through the node, a store-proxy lookup sees pending writes (not a
@@ -3072,6 +3315,10 @@ function updateKeyedMap() {
   runWithOwner(this._owner, () => {
     let i,
       j,
+      // The stage slot a mapper writes its row/index signal into: `j` on the
+      // create-all path, `j - start` on the general path, whose stage arrays
+      // are sized to the changed WINDOW, not the list.
+      slot,
       rows,
       indexes,
       // Mappers write freshly-created row/index signals into the STAGE
@@ -3079,19 +3326,19 @@ function updateKeyedMap() {
       mapper = this._rows
         ? this._byIndex
           ? () => {
-              rows[j] = signal(newItems[j], pureOptions);
-              return this._map(accessor(rows[j]), j);
+              rows[slot] = signal(newItems[j], pureOptions);
+              return this._map(accessor(rows[slot]), j);
             }
           : () => {
-              rows[j] = signal(newItems[j], pureOptions);
-              indexes && (indexes[j] = signal(j, pureOptions));
-              return this._map(accessor(rows[j]), indexes ? accessor(indexes[j]) : undefined);
+              rows[slot] = signal(newItems[j], pureOptions);
+              indexes && (indexes[slot] = signal(j, pureOptions));
+              return this._map(accessor(rows[slot]), indexes ? accessor(indexes[slot]) : undefined);
             }
         : this._indexes
           ? () => {
               const item = newItems[j];
-              indexes[j] = signal(j, pureOptions);
-              return this._map(item, accessor(indexes[j]));
+              indexes[slot] = signal(j, pureOptions);
+              return this._map(item, accessor(indexes[slot]));
             }
           : () => {
               const item = newItems[j];
@@ -3122,7 +3369,10 @@ function updateKeyedMap() {
       rows = this._rows && new Array(newLen);
       indexes = this._indexes && new Array(newLen);
       try {
-        for (j = 0; j < newLen; j++) mappings[j] = runWithOwner((nodes[j] = createOwner()), mapper);
+        for (j = 0; j < newLen; j++) {
+          slot = j;
+          mappings[j] = runWithOwner((nodes[j] = createOwner()), mapper);
+        }
       } catch (err) {
         for (i = 0; i <= j; i++) nodes[i]?.dispose();
         throw err;
@@ -3224,81 +3474,89 @@ function updateKeyedMap() {
         if (k <= hi && trySmallMove(this, newItems, newLen, start)) return;
       }
       const dif = newLen - this._len;
+      // WINDOW-SIZED STAGING, IN-PLACE COMMIT (2026-10-15). The strong-abort
+      // contract (#2903) only needs the pass to touch nothing live before
+      // every mapper has succeeded; it never needed four fresh newLen-sized
+      // arrays. Only the changed window [start, newEnd] is staged — the
+      // prefix and suffix are, by construction, the rows that did not move
+      // relative to each other — and at commit the bookkeeping arrays
+      // (`_nodes`, `_rows`, `_indexes`) take the window in place with the
+      // suffix shifted by a plain loop (`copyWithin` is a generic
+      // per-element builtin in V8 — 30× slower than the loop on 1k refs,
+      // measured 2026-10-15). `_mappings` alone is
+      // rebuilt: its fresh identity is the change signal downstream relies
+      // on. A one-row edit on a 500-row list used to allocate ~20 KB of
+      // staging plus a position-sized chain array per commit (uibench's
+      // one-item tree ops at 4–6× Octane, jfb-reorder `removefirst` at
+      // 2.5×); now it stages one slot.
+      const wLen = newEnd - start + 1;
       const temp = new Array(newLen);
-      const tempNodes = new Array(newLen);
-      rows = this._rows ? new Array(newLen) : undefined;
-      indexes = this._indexes ? new Array(newLen) : undefined;
-      // 0) prepare a map of all indices in the changed window of newItems,
-      // scanning backwards so we encounter them in natural order
-      newIndices = new Map();
-      newIndicesNext = new Array(newEnd + 1);
-      for (j = newEnd; j >= start; j--) {
-        item = newItems[j];
-        key = this._key ? this._key(item) : item;
-        i = newIndices.get(key);
-        newIndicesNext[j] = i === undefined ? -1 : i;
-        newIndices.set(key, j);
-      }
-      // 1) step through the old changed window and see if items can be found
-      // in the new set; if so, stage them at their new positions; if not,
-      // queue them for disposal at commit
-      for (i = start; i <= end; i++) {
-        item = this._items[i];
-        key = this._key ? this._key(item) : item;
-        j = newIndices.get(key);
-        if (j !== undefined && j !== -1) {
-          temp[j] = this._mappings[i];
-          tempNodes[j] = this._nodes[i];
-          rows && (rows[j] = this._rows[i]);
-          indexes && (indexes[j] = this._indexes[i]);
-          j = newIndicesNext[j];
+      const tempNodes = new Array(wLen);
+      rows = this._rows ? new Array(wLen) : undefined;
+      indexes = this._indexes ? new Array(wLen) : undefined;
+      // A shrinking pass is tried as a pure removal first (stageRemoval: no
+      // key map, one key call per item); anything else takes the map path.
+      const pure =
+        dif < 0
+          ? stageRemoval(this, newItems, start, end, newEnd, temp, tempNodes, rows, indexes)
+          : null;
+      if (pure !== null) {
+        // (The list-churn census below wants removals AND creations in one
+        // pass; a pure removal has none, so no item ledger is kept here.)
+        if (pure.length !== 0) removed = pure;
+      } else {
+        // 0) prepare a map of all indices in the changed window of newItems,
+        // scanning backwards so we encounter them in natural order
+        newIndices = new Map();
+        newIndicesNext = new Array(wLen);
+        for (j = newEnd; j >= start; j--) {
+          item = newItems[j];
+          key = this._key ? this._key(item) : item;
+          i = newIndices.get(key);
+          newIndicesNext[j - start] = i === undefined ? -1 : i;
           newIndices.set(key, j);
-        } else {
-          (removed ??= []).push(this._nodes[i]);
-          if (true && attrHooks !== null) (removedItems ??= []).push(item);
-        }
-      }
-      // 2) create new rows into the temp arrays; an abort disposes only these
-      try {
-        for (j = start; j <= newEnd; j++) {
-          if (tempNodes[j] !== undefined) continue;
-          (created ??= []).push((tempNodes[j] = createOwner()));
-          if (true && attrHooks !== null) (createdItems ??= []).push(newItems[j]);
-          temp[j] = runWithOwner(tempNodes[j], mapper);
         }
-      } catch (err) {
-        if (created) for (i = 0; i < created.length; i++) created[i].dispose();
-        throw err;
-      }
-      // 3) commit: land the retained prefix and suffix plus the staged window
-      // into the fresh arrays, swap them in (new identity for downstream
-      // change propagation), then dispose exited rows
-      for (i = 0; i < start; i++) {
-        temp[i] = this._mappings[i];
-        tempNodes[i] = this._nodes[i];
-        rows && (rows[i] = this._rows[i]);
-        indexes && (indexes[i] = this._indexes[i]);
-      }
-      for (j = start; j <= newEnd; j++) {
-        if (rows) write(rows[j], newItems[j]);
-        if (indexes) write(indexes[j], j);
-      }
-      for (j = newEnd + 1; j < newLen; j++) {
-        temp[j] = this._mappings[j - dif];
-        tempNodes[j] = this._nodes[j - dif];
-        if (rows) {
-          rows[j] = this._rows[j - dif];
-          write(rows[j], newItems[j]);
+        // 1) step through the old changed window and see if items can be found
+        // in the new set; if so, stage them at their new positions; if not,
+        // queue them for disposal at commit
+        for (i = start; i <= end; i++) {
+          item = this._items[i];
+          key = this._key ? this._key(item) : item;
+          j = newIndices.get(key);
+          if (j !== undefined && j !== -1) {
+            temp[j] = this._mappings[i];
+            tempNodes[j - start] = this._nodes[i];
+            rows && (rows[j - start] = this._rows[i]);
+            indexes && (indexes[j - start] = this._indexes[i]);
+            j = newIndicesNext[j - start];
+            newIndices.set(key, j);
+          } else {
+            (removed ??= []).push(this._nodes[i]);
+            if (true && attrHooks !== null) (removedItems ??= []).push(item);
+          }
         }
-        if (indexes) {
-          indexes[j] = this._indexes[j - dif];
-          if (dif !== 0) write(indexes[j], j);
+        // 2) create new rows into the window stage; an abort disposes only these
+        try {
+          for (j = start; j <= newEnd; j++) {
+            if (tempNodes[j - start] !== undefined) continue;
+            (created ??= []).push((tempNodes[j - start] = createOwner()));
+            if (true && attrHooks !== null) (createdItems ??= []).push(newItems[j]);
+            slot = j - start;
+            temp[j] = runWithOwner(tempNodes[j - start], mapper);
+          }
+        } catch (err) {
+          if (created) for (i = 0; i < created.length; i++) created[i].dispose();
+          throw err;
         }
       }
+      // 3) commit: the retained prefix and suffix land in the fresh mapped
+      // array; the bookkeeping arrays take the staged window IN PLACE (own
+      // function: kept out of this body on purpose, see commitWindow); then
+      // the exited rows dispose
+      for (i = 0; i < start; i++) temp[i] = this._mappings[i];
+      for (j = newEnd + 1; j < newLen; j++) temp[j] = this._mappings[j - dif];
+      commitWindow(this, newItems, newLen, start, end, newEnd, tempNodes, rows, indexes);
       this._mappings = temp;
-      this._nodes = tempNodes;
-      rows && (this._rows = rows);
-      indexes && (this._indexes = indexes);
       this._len = newLen;
       // save a copy of the mapped items for the next update
       this._items = newItems.slice(0);
@@ -3328,7 +3586,7 @@ function updateKeyedMap() {
  * const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/jsx-component-primitives/repeat
  */
 function repeat(count, map, options) {
   const wrappedMap = options?.name
@@ -3658,11 +3916,16 @@ function noteNode(target, node, key) {
 // dispatches CONFIG_SLOT_NODE nodes here (graph.ts) instead of holding a
 // per-node closure in a per-node NodeExtension. A dropped node is
 // unreachable through the store — a fresh read makes a fresh node.
+// A staged write — or a lane's value (a guess, S4) — is state only the node
+// holds: its release waits for the commit that resolves it. So does a leaf of
+// a held container (#4146): a mainline write it carried is in the held
+// staging too, where it would read as the hold's until the landing.
+const slotKept = node =>
+  node._pendingValue !== NOT_PENDING ||
+  node._config & CONFIG_OVERRIDE ||
+  node._host.k?._config & CONFIG_HELD;
 setSlotUnobserved(node => {
-  // A staged write — or a lane's value (a guess, S4) — is state only the
-  // node holds: defer the release to the commit that resolves it.
-  if (node._pendingValue !== NOT_PENDING || node._config & CONFIG_OVERRIDE)
-    deferredReleases.add(node);
+  if (slotKept(node)) deferredReleases.add(node);
   else releaseSlot(node);
 });
 /** A node born while its container has a staging is born from the two
@@ -3722,7 +3985,9 @@ function getNode(
     // the hottest store path, and the disabled cost must stay one null
     // check (nodes created before enable() stay generically named).
     if (attrHooks !== null) {
-      created._name = storeLabel(target) + "." + String(key);
+      const root = storeRoot(target);
+      created._name = (storeNames.get(root) ?? "store") + "." + String(key);
+      created._loc = storeLocs.get(root);
       stampNodeOwner(created, target);
     }
     nodes[key] = node;
@@ -3775,7 +4040,7 @@ function getContainerNode(target) {
  * staging: nothing allocates, nothing is swept at the commit (dbmon's tick
  * re-created, queued, swept and dropped ~7000 container nodes). If the
  * flush parks, the seam materializes and holds the node then
- * (`_storePark`) — the one case the staging home exists for. */
+ * (`storeParkHook`) — the one case the staging home exists for. */
 function stageOn(target, pb) {
   if (
     target.k === null &&
@@ -3798,7 +4063,7 @@ function deriveHolds(target) {
   const fw = target.fam?.node;
   return fw != null && !userWrite && (fw._config & CONFIG_HELD) !== 0;
 }
-GlobalQueue._storePark = t => {
+const storePark = t => {
   for (let i = 0; i < foldList.length; i++) {
     const target = foldList[i];
     if (target.k === null && target.pb !== null) holdNode(getContainerNode(target), t);
@@ -3846,11 +4111,16 @@ function stampNodeOwner(created, target) {
   created._owner = storeRootOwner(target) ?? null;
 }
 const storeNames = new WeakMap();
-function nameStore(proxy, name) {
-  if (attrHooks !== null && name) storeNames.set(proxy[$TARGET], name);
-}
-function storeLabel(target) {
-  return storeNames.get(storeRoot(target)) ?? "store";
+// The store's `loc` option, carried onto every property node beside its
+// label (the same gate: nodes created before the engine is installed carry
+// neither).
+const storeLocs = new WeakMap();
+function nameStore(proxy, name, loc) {
+  if (attrHooks !== null) {
+    const target = proxy[$TARGET];
+    if (name) storeNames.set(target, name);
+    if (loc) storeLocs.set(target, loc);
+  }
 }
 // ---------------------------------------------------------------------------
 // clones (CoW privatization)
@@ -3934,7 +4204,8 @@ function overlayRebuilds(t, pb) {
   if (t.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
   if (t.del !== null && t.del.size !== 0) return true;
   const wk = t.wk;
-  if (wk !== null && wk !== WK_ALL && wk.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
+  if (wk !== null && wk !== WK_ALL && wk.u === undefined && wk.size <= OVERLAY_REBUILD_MIN_ADDS)
+    return false;
   const v = t.v;
   let adds = 0;
   for (const key of Reflect.ownKeys(pb))
@@ -4164,11 +4435,7 @@ function drainFolds() {
   }
   if (deferredReleases.size !== 0) {
     for (const node of deferredReleases) {
-      if (
-        node._pendingValue === NOT_PENDING &&
-        !(node._config & CONFIG_OVERRIDE) &&
-        node._subs === null
-      ) {
+      if (node._subs === null && !slotKept(node)) {
         deferredReleases.delete(node);
         releaseSlot(node);
       }
@@ -4197,10 +4464,10 @@ GlobalQueue._slotCovered = n => {
   }
   return n._value;
 };
-GlobalQueue._storeCommit = () => {
+installStoreHooks(storePark, () => {
   drainFolds();
   optHooks?.sweep();
-};
+});
 /** The store half of `affects()` (store/affects.ts) makes its marks' nodes
  * and walks records through these: it never imports the engine. */
 GlobalQueue._storeNode = getNode;
@@ -4248,10 +4515,11 @@ function foldTarget(t, old) {
           const v = t.v;
           const wk = t.wk;
           if (wk !== null && wk !== WK_ALL) {
-            for (const key of wk) {
-              if (hasOwn$1.call(pb, key)) copyOwn(v, pb, key);
-              else delete v[key];
-            }
+            for (let w = wk; w !== undefined; w = w.u)
+              for (const key of w) {
+                if (hasOwn$1.call(pb, key)) copyOwn(v, pb, key);
+                else delete v[key];
+              }
           } else {
             for (const key of Reflect.ownKeys(pb)) {
               const d = Object.getOwnPropertyDescriptor(pb, key);
@@ -4424,7 +4692,10 @@ function notifyWrites(t) {
   // value can change when ANY key is written), or a non-plain prototype
   // (class instances: prototype getters derive from arbitrary fields).
   // Overlay pbs chain to the COMMITTED object (#3044) — plainness is the
-  // committed container's prototype, not the overlay's.
+  // committed container's prototype, not the overlay's. THIS setter's keys
+  // only (D-8, #3743): a key an earlier setter of the batch wrote and this
+  // one did not is no second proposal — its node was told then, and telling
+  // a held node its unchanged value again would join this tick to the hold.
   const wk0 = t.wk;
   const writtenKeys = wk0 === WK_ALL || t.a === true || !plainProto(t.ovl ? t.v : pb) ? null : wk0;
   if (attrHooks !== null) reportReplacedContainers(t, old, pb, writtenKeys);
@@ -5084,6 +5355,22 @@ function optRead(target) {
 const UNSAFE_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 // ---------------------------------------------------------------------------
 // traps
+/** A trap write: the target is told at the setter's exit, the key recorded
+ * in this setter's `wk`. A setter's first write to a target still staged by
+ * an earlier setter of the batch opens a set of its own (the notify visits
+ * it, D-8) and chains the earlier one behind for the fold's union. */
+function touch(target, key) {
+  let wk = target.wk;
+  if (!pendingNotify.has(target)) {
+    pendingNotify.add(target);
+    if (wk !== null && wk !== WK_ALL) {
+      wk = new Set();
+      wk.u = target.wk;
+      target.wk = wk;
+    }
+  }
+  if (wk !== WK_ALL) (target.wk ??= new Set()).add(key);
+}
 const traps = {
   get(target, key, receiver) {
     // One typeof gates every brand-symbol compare off the hot string path.
@@ -5331,16 +5618,23 @@ const traps = {
     if (key === "__proto__") return true; // pollution guard (core R30)
     const uv = target.s ? value : unwrapValue(value);
     const pb = ensurePB(target);
-    pendingNotify.add(target);
+    // #4146 (R1: node existence is unobservable; #3706: the hold's unit is
+    // the key): a user setter writing a key a HELD container's staging left
+    // unchanged would write it into the held staging — read as the hold's
+    // until its landing, while the same key with a leaf (a live reader)
+    // publishes at the flush. The key gets its leaf first, born from the two
+    // frames (`bornStaged`: a key the hold left unchanged — or added — is
+    // unstaged and held by no one; a key the hold changed is born held, A34
+    // (1)), and the write stages on it (A28; a write by the holder joins it,
+    // A34) — as it would with a reader's leaf. Kept while the container is
+    // held (`deferredReleases`).
+    if (userWrite && target.k?._config & CONFIG_HELD) deferredReleases.add(getNode(target, key));
     if (Array.isArray(pb)) {
+      touch(target, key);
       if (key === "length") target.wk = WK_ALL;
-      else if (target.wk !== WK_ALL) {
-        const wk = (target.wk ??= new Set());
-        wk.add(key);
-        wk.add("length");
-      }
+      else touch(target, "length");
     } else {
-      if (target.wk !== WK_ALL) (target.wk ??= new Set()).add(key);
+      touch(target, key);
       if (!(key in pb)) target.kc++;
     }
     if (UNSAFE_KEYS.has(key)) {
@@ -5375,8 +5669,7 @@ const traps = {
     if ("value" in desc) desc = { ...desc, value: unwrapValue(desc.value) };
     const pb = ensurePB(target);
     if (target.a || !(desc.enumerable && desc.writable && desc.configurable)) target.sc = 1;
-    pendingNotify.add(target);
-    if (target.wk !== WK_ALL) (target.wk ??= new Set()).add(key);
+    touch(target, key);
     Object.defineProperty(pb, key, desc);
     if (target.del !== null) target.del.delete(key);
     if (override) notifyWrites(target);
@@ -5387,10 +5680,22 @@ const traps = {
     const override = !draft && writeOverride;
     if (!draft && !override) return true;
     const pb = ensurePB(target);
-    pendingNotify.add(target);
-    if (target.wk !== WK_ALL) (target.wk ??= new Set()).add(key);
-    delete pb[key];
-    if (target.ovl && hasOwn$1.call(target.v, key)) (target.del ??= new Set()).add(key);
+    touch(target, key);
+    // The key count (`kc`, the overlay gate and the rebuild cap) follows a
+    // delete the way it follows an add: an own key of the draft leaving — a
+    // clone's key, or an overlay's own add — is one fewer now. An overlay's
+    // override of a committed key is the exception: the committed key's
+    // deletion is recorded in `del` and counted at the rebuild, as before.
+    // Without the decrement the natural "delete the old key, set the new
+    // one" shape drifted the count up by one per write until a three-key
+    // object crossed the overlay threshold and paid a rebuild on every
+    // commit after.
+    const committed = target.ovl && hasOwn$1.call(target.v, key);
+    if (hasOwn$1.call(pb, key)) {
+      delete pb[key];
+      committed || target.kc--;
+    }
+    if (committed) (target.del ??= new Set()).add(key);
     if (override) notifyWrites(target);
     return true;
   }
@@ -5418,7 +5723,7 @@ const ASYNC_STORE_SETTER_MESSAGE =
  * write violation — the user guard (`mapArray`'s pattern: the node-level
  * writes carry `ownedWrite`; the setter asks). */
 function devGuardStoreSetterWrite() {
-  if (context && !(context._config & CONFIG_CHILDREN_FORBIDDEN)) {
+  if (context && !(context._config & CONFIG_CHILDREN_FORBIDDEN) && !disposalDepth) {
     emitDiagnostic({
       code: "REACTIVE_WRITE_IN_OWNED_SCOPE",
       kind: "write",
@@ -5454,6 +5759,7 @@ function devGuardStoreSetterResult(result) {
   }
 }
 function storeSetter(proxy, fn, guard = true) {
+  if (writeHook !== null) writeHook(proxy);
   if (guard) devGuardStoreSetterWrite();
   const target = proxy[$TARGET];
   const prevScopes = writeScopes;
@@ -5521,6 +5827,8 @@ function createStore$1(initialValue, options) {
       throw new Error("createStore({ shallow }): value is already a store proxy");
   }
   const proxy = wrap(initialValue);
+  // Dependency edges (store/edges.ts): the root is named like a plain signal.
+  if (signalHook !== null) signalHook(proxy[$TARGET]);
   if (shallow) {
     proxy[$TARGET].s = true;
     markRawIngest(initialValue);
@@ -5535,7 +5843,7 @@ function createStore$1(initialValue, options) {
     // disabled, buys nothing.
     if (attrHooks !== null) {
       storeOwners.set(proxy[$TARGET], owner);
-      nameStore(proxy, options?.name);
+      nameStore(proxy, options?.name, options?.loc);
     }
   }
   const setter = fn => storeSetter(proxy, fn);
@@ -6299,6 +6607,11 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, aroundDraftWri
           // A landing (not the sync pass's own commit): the readers held
           // pending on the derive settle.
           if (!first || !(owner._statusFlags & STATUS_UNINITIALIZED)) settleFamily(fam);
+          // A commit is the derive's change for the readers that observed its
+          // flight (linked by `pullFamily`; a settled pull does not link), as
+          // a memo's landing is for its readers: one that caught the NotReady
+          // (a fallback value, not pending) re-runs too (#4070).
+          insertSubs(owner);
         };
         const sync = handleAsync(owner, result, commit, (error, pending) => {
           // The flight rejected: the leaves' readers learn it from here —
@@ -6340,6 +6653,9 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, aroundDraftWri
   return owner;
 }
 function createProjectionInternal(fn, seed, options) {
+  // Seedless (`fn` takes no draft): the root starts as an empty record. It is
+  // a draft like any seed, never observable before the first landing (A25).
+  seed ||= {};
   const keyOption = options?.key === undefined ? "id" : options.key;
   const fam = {
     map: new WeakMap(),
@@ -6362,9 +6678,13 @@ function createProjectionInternal(fn, seed, options) {
   }
   let nodeOptions;
   if (options?.seedLoadingValue) nodeOptions = { loadingValue: undefined };
-  if (options?.name) {
-    nodeOptions = { ...nodeOptions, name: options.name };
-    nameStore(store, options.name);
+  if (attrHooks !== null)
+    // As createStore: the owner in scope stamps the projection's property
+    // nodes, so attribution places them under it (#4035).
+    storeOwners.set(store[$TARGET], getOwner());
+  if (options?.name || options?.loc) {
+    nodeOptions = { ...nodeOptions, name: options.name, loc: options.loc };
+    nameStore(store, options.name, options.loc);
   }
   const node = computed(() => {
     if (!fam.node) fam.node = getOwner();
@@ -6372,14 +6692,11 @@ function createProjectionInternal(fn, seed, options) {
   }, nodeOptions);
   node._config &= ~CONFIG_AUTO_DISPOSE;
   fam.node = node;
+  // The derive's leaves are not its dependents: a mark's repoll
+  // (affects-marks.ts) reaches their readers through this.
+  node.fam = fam;
   return { store, node };
 }
-/**
- * A derived store: `fn` runs in a computed and writes its draft; readers of
- * the store's keys re-run only when the keys they read change (the
- * firewall). `fn` may be async or an async iterator; the seed is a draft,
- * never an observable value, until the first landing (A25).
- */
 function createProjection(fn, seed, options) {
   return createProjectionInternal(fn, seed, options).store;
 }
@@ -6906,7 +7223,9 @@ function optimisticView(
 function createOptimisticStore(first, second, third) {
   const derived = typeof first === "function";
   const options = derived ? third : second;
-  const initialValue = derived ? second : first;
+  // Seedless derived form: the root starts as an empty record (see
+  // createProjectionInternal).
+  const initialValue = derived ? second || {} : first;
   const keyOption = options?.key === undefined ? "id" : options.key;
   const fam = {
     map: new WeakMap(),
@@ -6922,7 +7241,7 @@ function createOptimisticStore(first, second, third) {
           : row => (isWrappable(row) ? row[keyOption] : undefined)
   };
   const store = wrap(initialValue, null, null, fam);
-  nameStore(store, options?.name);
+  nameStore(store, options?.name, options?.loc);
   if (fam.shallow) {
     store[$TARGET].s = true;
     markRawIngest(initialValue);
@@ -6931,7 +7250,8 @@ function createOptimisticStore(first, second, third) {
     const fn = first;
     let nodeOptions;
     if (options?.seedLoadingValue) nodeOptions = { loadingValue: undefined };
-    if (options?.name) nodeOptions = { ...nodeOptions, name: options.name };
+    if (options?.name || options?.loc)
+      nodeOptions = { ...nodeOptions, name: options.name, loc: options.loc };
     const node = computed(() => {
       if (!fam.node) fam.node = getOwner();
       runProjectionComputed(store, fn, keyOption);
@@ -8000,6 +8320,83 @@ function deep(value) {
   return deep$1(value);
 }
 
+// The mark core: a declared not-final state on a node that reads pending
+// (`isPending` → true) on the node and everything derived from it, without
+// holding anything or entangling a reader. Two declarers share it:
+// `affects()` (affects.ts — a mark scoped to a transaction, with a store
+// half) and `createDeferred` (deferred.ts — a mark whose lifetime is the
+// node's own flight). Split out so the second does not ship the first.
+//
+// Representation: a count on the marked node (`_x._marks`). Coverage of the
+// derivations is pull-derived at probe time — `isPending`'s read walks the
+// probed node's dependencies for a marked one (verdict.ts → `_marked`) — so
+// nothing is stored downstream and a mid-window recompute strands nothing.
+// The push half is the verdict readers' re-derivation when a node's marks
+// start and end (`repoll`): the only notification a mark makes.
+/** Live marks, every declarer — the gate on the probe's walk. */
+let active = 0;
+/** The verdict readers downstream of `node` — through derivations, stopping
+ * at effects — re-derive: the mark's one notification (a probe's answer
+ * changed with no value notifying anyone). Truth readers (`until`, the
+ * `refresh` waiter) too, which a lagging flight parked (deferred.ts) — but
+ * not through a derived store, whose leaves change only once its derive
+ * re-runs: they re-derive at that write. */
+function repoll(node, seen = new Set(), readers = CONFIG_VERDICT | CONFIG_AUTHORITATIVE) {
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    const sub = s._sub;
+    if (seen.has(sub)) continue;
+    seen.add(sub);
+    if (sub._config & readers) enqueueSub(sub);
+    if (!sub._type) repoll(sub, seen, readers);
+    // A derived store's derive: its leaves' readers derive from it too
+    // (store/projection.ts; a live target's property, has and keys nodes).
+    const fam = sub.fam;
+    if (fam)
+      for (const t of fam.live)
+        for (const o of [t.n, t.h, { k: t.k, d: t.dk }])
+          if (o) for (const k of Reflect.ownKeys(o)) o[k] && repoll(o[k], seen, CONFIG_VERDICT);
+  }
+}
+/** A node is covered by a live mark iff it carries one, or derives — through
+ * its current dependencies — from one that does. A store slot derives from
+ * its family's derive (a derived store's leaves are not the derive's
+ * dependents, store/projection.ts), so coverage hops there. A real error
+ * outranks an inherited mark (A24 (c)): coverage does not flow through an
+ * errored node (a direct mark on one still reads pending). Mid-recompute,
+ * only the validated prefix of the dependency list is this pass's. */
+function marked(el, seen) {
+  if (el._x !== null && el._x._marks !== 0) return true;
+  const c = el;
+  if (c._statusFlags & STATUS_ERROR || seen.has(el)) return false;
+  seen.add(el);
+  if (c._config & CONFIG_SLOT_NODE) {
+    const derive = c._host?.fam?.node;
+    return derive != null && marked(derive, seen);
+  }
+  const tail = c._flags & REACTIVE_RECOMPUTING_DEPS ? c._depsTail : undefined;
+  if (tail !== null)
+    for (let d = c._deps ?? null; d !== null; d = d._nextDep) {
+      if (marked(d._dep, seen)) return true;
+      if (d === tail) break;
+    }
+  return false;
+}
+/** One mark on `node`. The declarer repolls once its bookkeeping is done. */
+function mark(node) {
+  ext(node)._marks++;
+  active++;
+}
+/** Drops one mark from `node`: true when it was the last — the node's
+ * verdict readers have re-derived. */
+function unmark(node) {
+  active--;
+  if (--node._x._marks !== 0) return false;
+  repoll(node);
+  return true;
+}
+GlobalQueue._marked = el => active !== 0 && marked(el, new Set());
+GlobalQueue._mark = mark;
+
 /**
  * Store — the store half of `affects()` (plan sec. 29, plan sec. 37; A24 (4), #2882,
  * #2893, #2904).
@@ -8128,7 +8525,7 @@ function releaseMarkScope(carrier) {
   const entry = scopes.get(carrier);
   if (entry === undefined) return;
   scopes.delete(carrier);
-  GlobalQueue._releaseMarks(entry._inherited);
+  releaseMarksHook(entry._inherited);
 }
 
 // `affects()` — the declaration verb of the pending model (A24 (4), ruled
@@ -8144,62 +8541,23 @@ function releaseMarkScope(carrier) {
 // data joins nothing through it. A mark is never a re-ask, so a declared
 // reload's own `refresh()` cannot silence it; a real error outranks it.
 //
-// Representation: a count on the marked node (`_x._marks`), listed with its
-// scope (the transaction's `_marks`, or the ambient list). Coverage of the
-// derivations is pull-derived at probe time — `isPending`'s read walks the
-// probed node's dependencies for a marked one (verdict.ts → `_marked`) — so
-// nothing is stored downstream and a mid-window recompute strands nothing.
-// The push half is the verdict readers' re-derivation at registration and at
-// release (`repoll`): the only notification a mark makes.
+// Representation: the mark core (affects-marks.ts) — a count on the marked
+// node, coverage pull-derived at probe time, readers repolled at registration
+// and release. Here: each mark's scope (the transaction's `_marks`, or the
+// ambient list) and the store half.
 //
 // Installed on `GlobalQueue` when imported: a program that never declares a
 // mark carries none of this.
-/** Live marks, every scope — the gate on the probe's walk. */
-let active = 0;
 /** Marks declared outside a transaction: released at the next seam. */
 const ambient = [];
-/** The verdict readers downstream of `node` — through derivations, stopping
- * at effects — re-derive: the mark's one notification (a probe's answer
- * changed with no value notifying anyone). */
-function repoll(node, seen = new Set()) {
-  for (let s = node._subs; s !== null; s = s._nextSub) {
-    const sub = s._sub;
-    if (seen.has(sub)) continue;
-    seen.add(sub);
-    if (sub._config & CONFIG_VERDICT) enqueueSub(sub);
-    if (!sub._type) repoll(sub, seen);
-  }
-}
-/** A node is covered by a live mark iff it carries one, or derives — through
- * its current dependencies — from one that does. A real error outranks an
- * inherited mark (A24 (c)): coverage does not flow through an errored node
- * (a direct mark on one still reads pending). Mid-recompute, only the
- * validated prefix of the dependency list is this pass's. */
-function marked(el, seen) {
-  if (el._x !== null && el._x._marks !== 0) return true;
-  const c = el;
-  if (c._statusFlags & STATUS_ERROR || seen.has(el)) return false;
-  seen.add(el);
-  const tail = c._flags & REACTIVE_RECOMPUTING_DEPS ? c._depsTail : undefined;
-  if (tail !== null)
-    for (let d = c._deps ?? null; d !== null; d = d._nextDep) {
-      if (marked(d._dep, seen)) return true;
-      if (d === tail) break;
-    }
-  return false;
-}
 /** Releases one scope's marks (a landed transaction's, the ambient list at
  * the seam): a node whose last mark drops re-derives its verdict readers. */
 function release$1(nodes) {
   for (let i = 0; i < nodes.length; i++) {
     const n = nodes[i];
-    active--;
-    if (--n._x._marks === 0) {
-      repoll(n);
-      // A store mark's carrier: its scope (and the marks the nodes born in
-      // its window inherited) goes with it.
-      releaseMarkScope(n);
-    }
+    // A store mark's carrier: its scope (and the marks the nodes born in
+    // its window inherited) goes with the last mark.
+    if (unmark(n)) releaseMarkScope(n);
   }
   nodes.length = 0;
 }
@@ -8215,10 +8573,6 @@ function register(node) {
   }
   repoll(node);
 }
-function mark(node) {
-  ext(node)._marks++;
-  active++;
-}
 function affects(target, key) {
   if (arguments.length > 2)
     invalid(
@@ -8256,10 +8610,7 @@ function invalid(detail) {
   emitDiagnostic({ code: "INVALID_AFFECTS_TARGET", kind: "write", severity: "error", message });
   throw new Error(message);
 }
-GlobalQueue._marked = el => active !== 0 && marked(el, new Set());
-GlobalQueue._mark = mark;
-GlobalQueue._releaseMarks = release$1;
-GlobalQueue._releaseAmbientMarks = parked => {
+installMarkHooks(release$1, parked => {
   if (ambient.length === 0) return;
   // The flush parked: the declaration's window is the frame's — the marks
   // are its transaction's ("nothing async below ⇒ no window").
@@ -8282,7 +8633,7 @@ GlobalQueue._releaseAmbientMarks = parked => {
   }
   ambient.length = kept;
   if (done.length !== 0) release$1(done);
-};
+});
 function inFlight(n) {
   return (
     (n._statusFlags & STATUS_PENDING) !== 0 ||
@@ -8290,6 +8641,174 @@ function inFlight(n) {
   );
 }
 
+// `createDeferred` — an async memo that may lag, but never leads (D-40,
+// docs/create-deferred.md).
+//
+// Once the node has a committed value, its own non-final work is invisible
+// to the graph: its readers keep the committed value and hold nothing, its
+// landings are changes of their own, and only the verdict (`isPending`) and
+// the truth readers (`until`, `refresh`'s waiter) see the flight.
+//
+// Built from parts the engine already has, so core pays nothing for it:
+//
+// - **Read side: the loading window** (`_loading`, async.ts). Every pass of
+//   a node with a committed value opens the window before it asks, so a
+//   flight serves the committed value instead of throwing, and an unready
+//   source parks the node instead of pending it. `CONFIG_REDERIVE` makes a
+//   source going pending a question for the node's pass (which parks) rather
+//   than a status pushed through it to its readers.
+// - **Verdict: a mark** (affects-marks.ts) whose lifetime is the flight —
+//   started when a pass asks a new question (a `refresh()` re-ask is quiet, F-9),
+//   dropped at the landing, the rejection, a sync answer or the node's death.
+// - **Never leads:** a flight that lands while an input it read is held
+//   derived from that hold's world, so it lands into the hold (`holdNode`;
+//   `setSignal` stages it there). An input that changed after the pass
+//   would have superseded the flight, so a held input at the landing is one
+//   the pass read held.
+// - **Truth readers** wait the flight out (`GlobalQueue._lagging`, signals.ts
+//   `watch`): `await refresh(d)` delivers the landing, `until` sees only
+//   settled values.
+/** Deferred nodes with a flight up. */
+const lagging = new Set();
+/** The deferred node with a flight up that `c`'s value derives from, if
+ * any: `c` itself, or one reached through its current dependencies. */
+function lagOf(c, seen) {
+  if (lagging.has(c)) return c;
+  if (seen.has(c)) return;
+  seen.add(c);
+  if (c._config & CONFIG_SLOT_NODE) return lagOf(c._host?.fam?.node ?? c, seen);
+  const tail = c._flags & REACTIVE_RECOMPUTING_DEPS ? c._depsTail : undefined;
+  if (tail !== null)
+    for (let d = c._deps ?? null; d !== null; d = d._nextDep) {
+      const l = lagOf(d._dep, seen);
+      if (l) return l;
+      if (d === tail) break;
+    }
+}
+GlobalQueue._lagging = c => (lagging.size !== 0 ? lagOf(c, new Set()) : undefined);
+/**
+ * Creates an async memo that may lag, but never leads. Before its first
+ * answer it is an ordinary async memo: readers suspend to the nearest
+ * `<Loading>`. After it, a refetch holds nothing: readers keep the last
+ * committed value until the new one lands, and the rest of the screen moves
+ * on without it. `isPending` reports the refetch, on the node and on what
+ * derives from it. Use it for independent widgets (dashboards, feeds,
+ * search results) where the previous answer with a "refreshing" indicator is
+ * better than waiting with everything else.
+ *
+ * - It never shows a value ahead of a held change: a refetch that read a
+ *   held value lands with that hold.
+ * - A rejected refetch errors like any memo; the stale value never masks it.
+ * - `refresh(d)` is a quiet re-ask, and `await refresh(d)` and `until`
+ *   wait for the landing rather than the stale value.
+ * - Combine with `loadingValue` for a node that never suspends at all.
+ *
+ * @example
+ * ```tsx
+ * const rows = createDeferred(() => fetchRows(store.period));
+ *
+ * <section class={{ stale: isPending(() => rows()) }}>
+ *   <For each={rows()}>{row => <Row row={row} />}</For>
+ * </section>
+ * ```
+ */
+function createDeferred(fn, options) {
+  let node;
+  /** The flight in force: a promise, a stream, or the error an unready
+   * source parked the node with. */
+  let flight = null;
+  let marked = false;
+  let answered = false;
+  /** The flight `r` is over. An async answer (`held`) arriving while an
+   * input is held lands into that hold first. */
+  const land = (r, held) => {
+    if (r === null || flight !== r) return;
+    flight = null;
+    lagging.delete(node);
+    if (held)
+      for (let d = node._deps; d !== null; d = d._nextDep)
+        if (d._dep._config & CONFIG_HELD) {
+          holdNode(node, txOf(d._dep));
+          break;
+        }
+    if (marked) {
+      marked = false;
+      unmark(node);
+      schedule();
+    }
+  };
+  const ask = r => {
+    flight = r;
+    lagging.add(node);
+    if (!marked && !(node._flags & REACTIVE_REASK)) {
+      marked = true;
+      mark(node);
+      repoll(node);
+    }
+  };
+  /** Registers the flight and serves the pass's value: the committed one,
+   * or over a held landing the landing itself, which a lagging question
+   * does not replace (D-40) — restaged as the committed value, the hold's
+   * readers would re-derive against the old input. */
+  const serve = r => {
+    const v = handleAsync(node, r);
+    return node._config & CONFIG_HELD && node._pendingValue !== NOT_PENDING
+      ? node._pendingValue
+      : v;
+  };
+  const end = () => node._flags & REACTIVE_DISPOSED && land(flight);
+  return accessor(
+    computed(prev => {
+      node = getOwner();
+      node._config |= CONFIG_REDERIVE;
+      cleanup(end);
+      // Answered: the node has a real committed answer — not a first load,
+      // not a `loadingValue` window still open (both are loading, F-9).
+      // Sticky, and read before this wrapper ever opens the window itself.
+      const open = (answered ||= !(node._statusFlags & STATUS_UNINITIALIZED) && !node._loading);
+      if (open) ((node._loading = true), (node._config |= CONFIG_LAGS));
+      let r;
+      try {
+        r = fn(prev);
+      } catch (e) {
+        // The wrapping form: an unready source parks the node in the window,
+        // and the wait is its flight until the source's settle re-runs it.
+        if (open && e instanceof NotReadyError) ask(e);
+        throw e;
+      }
+      if (open && typeof r === "object" && r !== null) {
+        if (isThenable(r)) {
+          ask(r);
+          const done = () => land(r, true);
+          r.then(done, done);
+          return serve(r);
+        }
+        const iterate = r[Symbol.asyncIterator];
+        if (iterate) {
+          // A stream's flight ends at its first yield (or its end).
+          const it = iterate.call(r);
+          let first = true;
+          const done = () => land(s, true);
+          const s = {
+            // Registered ahead of the engine's own reaction to the same
+            // promise, as for a plain flight: verdict and value in one flush.
+            next: v => {
+              const p = it.next(v);
+              if (first) ((first = false), p.then(done, done));
+              return p;
+            },
+            return: v => it.return?.(v) ?? Promise.resolve({ done: true, value: v })
+          };
+          ask(s);
+          return serve({ [Symbol.asyncIterator]: () => s });
+        }
+      }
+      land(flight);
+      return r;
+    }, options)
+  );
+}
+
 // CARVE 4: `flatten` lived in boundaries.ts but is the general children
 // resolver the renderers (`web`, `universal`, `solid`'s `children()`) walk
 // through — not a boundary feature. Moved verbatim so the boundary carve
@@ -8381,7 +8900,7 @@ function flattenArray(children, results = [], options) {
  * the root holds the frame as for any reader. The tree's own status takes
  * the same route from the output's pass (`read(tree)` throws it).
  *
- * The hold (`blocked`, scheduler.ts) asks `hidden`: a reader behind a
+ * The hold (`blocked`, scheduler.ts) asks `hiddenBy`: a reader behind a
  * fallback — any boundary on its chain whose last pass chose the fallback —
  * is not on screen and holds nothing. An error boundary flipping to its
  * fallback is the same as a loading one resetting: every reader under it
@@ -8416,6 +8935,11 @@ const boundaryOf = node => node._context[BOUNDARY];
 /** Catches what reaches it: an error boundary always; a loading one until it
  * has shown content, or while re-armed. */
 const isCollecting = b => b._type === STATUS_ERROR || !b._initialized || b._armed;
+/** A reader `b` waits on: recorded for its `on`, and `b` visited at the seam. */
+function record(b, node) {
+  b._readers.add(node);
+  collecting.add(b);
+}
 /** The reader goes to the fallback: recorded, and the output re-derives
  * (a no-op while the output's own pass is running — its post-check
  * decides). */
@@ -8432,8 +8956,7 @@ function caught(b, node, error) {
     setSignal(b._error, caught);
     reportClientError(caught, b._owner, node);
   }
-  b._readers.add(node);
-  collecting.add(b);
+  record(b, node);
   if (b._armed) flip(b);
   // Already showing the fallback: one more reader to wait on changes
   // nothing on screen. The fallback is instantiated once per show — a later
@@ -8449,8 +8972,9 @@ function caught(b, node, error) {
 function flip(b) {
   b._initialized = false;
   b._lane = b._armLane;
-  if (b._lane !== null && b._output !== null)
-    GlobalQueue._laneStage(b._output, b._lane, true, false);
+  const o = b._output;
+  if (!b._lane && o._config & CONFIG_HELD && txOf(o) !== flushTransaction) unhold(o);
+  if (b._lane !== null && b._output !== null) laneStageHook(b._output, b._lane, true, false);
 }
 function redraw(b) {
   if (b._output !== null && !(b._output._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
@@ -8458,7 +8982,7 @@ function redraw(b) {
     schedule();
   }
 }
-/** GlobalQueue._catch: status from a frame reader, nearest boundary first.
+/** `catchHook` (scheduler.ts): status from a frame reader, nearest boundary first.
  * A loading boundary on the way records a pending reader whether or not it
  * catches it (its `on` may collect it later). */
 function catchStatus(node, flags, error) {
@@ -8471,7 +8995,7 @@ function catchStatus(node, flags, error) {
     // lands with its run, not a round after). Others still waiting: nothing
     // on screen changes, the fallback stays as it is.
     if (collecting.size !== 0)
-      for (let b = boundaryOf(node); b !== undefined; b = b._parent ?? undefined)
+      for (let b = boundaryOf(node); b; b = b._parent)
         if (
           !(node._statusFlags & unsettled(b)) &&
           b._readers.delete(node) &&
@@ -8482,28 +9006,29 @@ function catchStatus(node, flags, error) {
         }
     return false;
   }
-  for (let b = boundaryOf(node); b !== undefined; b = b._parent ?? undefined) {
+  for (let b = boundaryOf(node); b; b = b._parent) {
     if (!(b._type & flags)) continue;
     if (isCollecting(b)) {
       caught(b, node, error);
-      return true;
+      return b._armed ? CAUGHT_REARMED : true;
     }
-    b._readers.add(node);
-    collecting.add(b);
+    record(b, node);
   }
   return false;
 }
-/** The nearest boundary on `r`'s chain showing its fallback, if any. */
+/** The nearest loading boundary that would catch `node` was re-armed this
+ * flush. */
+function armedOver(node) {
+  for (let b = boundaryOf(node); b; b = b._parent)
+    if (b._type & STATUS_PENDING && isCollecting(b)) return b._armed;
+}
+/** The nearest boundary on `r`'s chain showing its fallback, if any
+ * (`hiddenHook`: `r` is behind a fallback). */
 function hiddenBy(r) {
-  for (let b = boundaryOf(r); b !== undefined; b = b._parent ?? undefined)
-    if (b._fallback) return b;
+  for (let b = boundaryOf(r); b; b = b._parent) if (b._fallback) return b;
   return undefined;
 }
-/** GlobalQueue._hidden: behind a fallback. */
-function hidden(r) {
-  return hiddenBy(r) !== undefined;
-}
-/** GlobalQueue._heldRun: a queued run behind a fallback waits for the reveal
+/** `heldRunHook` (scheduler.ts): a queued run behind a fallback waits for the reveal
  * (maintainer, 2026-10-02: the queue is held, the synchronous first render
  * goes through). A user effect's, which would read a DOM that is not
  * attached ("many depend on reading the DOM, something that can't happen
@@ -8548,7 +9073,10 @@ function prune(b, pass) {
   for (const r of b._readers) {
     if (r._flags & REACTIVE_DISPOSED) b._readers.delete(r);
     else if (!(r._statusFlags & mask)) {
-      if (r !== b._tree && (r._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) {
+      if (
+        (r !== b._tree || b._armed) &&
+        (r._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD
+      ) {
         // Landed, held: the content is that transaction's — the output's
         // pass enters it and the reveal lands with the reader's run. The
         // seam, past its park decision, waits for the commit instead. (A
@@ -8578,7 +9106,7 @@ function ready(b) {
       prune(b, false) === 0)
   );
 }
-/** GlobalQueue._boundarySeam, end of the seam: readers that settled, died,
+/** `boundarySeamHook` (scheduler.ts), end of the seam: readers that settled, died,
  * or landed and committed are dropped; a fallback with none left reveals
  * next round. An arm resolves: nothing collected, nothing happened. */
 function boundarySeam() {
@@ -8591,6 +9119,18 @@ function boundarySeam() {
     // A parked frame's boundary (zombie) keeps its state for its revival.
     if (flags & REACTIVE_ZOMBIE) continue;
     prune(b, false);
+    const o = b._output;
+    if (
+      b._armed &&
+      !b._initialized &&
+      o._config & CONFIG_HELD &&
+      [...b._readers].every(
+        r => !(r._statusFlags & STATUS_PENDING) && r._config & CONFIG_HELD && txOf(r) === txOf(o)
+      )
+    ) {
+      b._readers.clear();
+      b._initialized = true;
+    }
     if (b._armed && !b._initialized && !b._ahead) reportOutsideHold(b);
     b._armed = false;
     if (b._readers.size === 0) {
@@ -8617,15 +9157,17 @@ function reportOutsideHold(b) {
           if (outside(s._sub, false)) return true;
       return false;
     }
-    if (hidden(reader)) return false;
-    for (let o = boundaryOf(reader); o !== undefined; o = o._parent ?? undefined)
-      if (o === b) return false;
+    if (hiddenBy(reader)) return false;
+    for (let o = boundaryOf(reader); o; o = o._parent) if (o === b) return false;
     return true;
   };
   for (const r of b._readers) {
     const sources = r._x?._pendingSources;
     if (sources === undefined) continue;
     for (const source of sources) {
+      // Only the flight the change itself started (D-16): an outside reader
+      // of an earlier write's flight holds nothing the change waits on.
+      if (source._time !== clock) continue;
       for (let s = source._subs; s !== null; s = s._nextSub) {
         if (!outside(s._sub, true)) continue;
         const name = source._name;
@@ -8650,15 +9192,6 @@ function reportOutsideHold(b) {
     }
   }
 }
-/** The `on` pass is a verdict's: it probed itself (CONFIG_VERDICT), or it
- * read a memo that did (#3528's `createMemo(() => isPending(m2))`) — its
- * swap is display-ahead either way. */
-function verdictDerived(c) {
-  if (c._config & CONFIG_VERDICT) return true;
-  for (let d = c._deps; d !== null; d = d._nextDep)
-    if (d._dep._config & CONFIG_VERDICT) return true;
-  return false;
-}
 /** `on` changed after the mount: fresh again if anything under it is
  * pending now; collecting for the rest of the flush either way. */
 function arm(b) {
@@ -8682,20 +9215,32 @@ function arm(b) {
     return;
   }
   b._armed = true;
-  // A verdict read in `on` (`isPending`) whose frame has no transaction
-  // yet: the swap is still display-ahead — the frame gets one now (it lands
+  // A verdict read in `on` (`isPending`, or a memo of one — #3528's
+  // `createMemo(() => isPending(m2))`: the mark carries, core.ts `read`)
+  // whose frame has no transaction yet: the swap is still display-ahead — the frame gets one now (it lands
   // at this very seam if nothing holds it), and the swap is its verdict
   // lane's work, shown ahead of the frame's own runs (#3528).
   let lane = passLane;
-  if (lane === null && globalQueue._running && verdictDerived(getOwner())) {
+  if (lane === null && globalQueue._running && getOwner()._config & CONFIG_VERDICT) {
     joinFuture(null);
     lane = GlobalQueue._verdictLane(flushTransaction);
   }
   b._armLane = lane;
   b._ahead = lane !== null;
   collecting.add(b);
+  const n = b._readers.size;
+  heldUnder(b._owner, flushTransaction, r => record(b, r));
   for (const r of b._readers) {
-    if (r._statusFlags & STATUS_PENDING && !(r._flags & REACTIVE_DISPOSED)) {
+    if (
+      b._readers.size !== n ||
+      (r._statusFlags & STATUS_PENDING && !(r._flags & REACTIVE_DISPOSED))
+    ) {
+      // What it collects was forwarded through it to the boundaries above
+      // too (`catchStatus` records a reader in every boundary on the way).
+      // It is this boundary's alone now (B5, the nearest catcher): an outer
+      // re-armed by the same tick does not wait for it (D-14, U-4).
+      for (let a = b._parent; a !== null; a = a._parent)
+        for (const o of b._readers) a._readers.delete(o);
       flip(b);
       redraw(b);
       return;
@@ -8828,8 +9373,7 @@ function createBoundary(type, fn, show, onFn) {
           }
           // Forwarded: a loading boundary showing content keeps it and
           // holds the frame like any reader (recorded for its `on`).
-          b._readers.add(tree);
-          collecting.add(b);
+          record(b, tree);
         }
         // A pending passes an error boundary by (A6); an error, a loading
         // one; a loading boundary showing content forwards its pending.
@@ -8869,8 +9413,7 @@ function createBoundary(type, fn, show, onFn) {
           }
           // Forwarded: a loading boundary showing content keeps it and
           // holds the frame like any reader (recorded for its `on`).
-          b._readers.add(tree);
-          collecting.add(b);
+          record(b, tree);
         }
         // A pending passes an error boundary by (A6).
         throw e;
@@ -9031,12 +9574,17 @@ function createErrorBoundary(fn, fallback) {
 }
 // Installed at module evaluation — present exactly when something imports a
 // boundary. An app without one pays the three null checks and nothing else.
-GlobalQueue._catch = catchStatus;
-GlobalQueue._fresh = node =>
-  node._statusFlags & STATUS_UNINITIALIZED && catchStatus(node, STATUS_PENDING);
-GlobalQueue._hidden = hidden;
-GlobalQueue._boundarySeam = boundarySeam;
-GlobalQueue._heldRun = heldRun;
+installBoundaryHooks(
+  catchStatus,
+  (node, held) =>
+    !held &&
+    (node._statusFlags & STATUS_UNINITIALIZED
+      ? catchStatus(node, STATUS_PENDING)
+      : armedOver(node)),
+  hiddenBy,
+  boundarySeam,
+  heldRun
+);
 
 /**
  * Reveal order — `createRevealOrder` (`<Reveal>`): the order in which a group
@@ -9279,6 +9827,7 @@ export {
   affects,
   configureClientErrors,
   createContext,
+  createDeferred,
   createEffect,
   createErrorBoundary,
   createLoadingBoundary,
@@ -9324,6 +9873,9 @@ export {
   resolvedTable,
   runWithOwner,
   setContext,
+  setReadWatch,
+  setSignalIdentities,
+  signalName,
   snapshot,
   sourceGet,
   sourceHas,
@@ -9332,6 +9884,7 @@ export {
   storeHasFamily,
   storeHasOptimisticFamily,
   storeIsShallow,
+  storeName,
   storePath,
   until,
   untrack,