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

package/dist/dev.js

@@ -1,163 +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 enqueueSub,
   r as resolveTx,
-  f as CONFIG_AUTHORITATIVE,
+  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,
   t as txOf,
-  g as tracking,
-  h as CONFIG_CHILDREN_FORBIDDEN,
-  p as passLane,
-  S as STATUS_PENDING,
-  E as EFFECT_RENDER,
-  i as sameLane,
-  j as CONFIG_HELD,
-  k as flushTransaction,
-  l as STATUS_UNINITIALIZED,
-  m as NotReadyError,
-  o as REACTIVE_SCREEN_READ,
-  u as REACTIVE_FRAME_READ,
-  v as REACTIVE_LANE_READ,
-  w as ext,
-  x as REACTIVE_RECOMPUTING_DEPS,
-  y as queuePendingNode,
-  z as REACTIVE_LANE_DIRTY,
-  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 stagedRead,
-  T as attrHooks,
-  U as holdNode,
-  V as joinFuture,
-  W as CONFIG_SLOT_NODE,
-  X as commitPendingNode,
-  Y as REACTIVE_IN_HEAP,
-  Z as REACTIVE_DIRTY,
-  _ as REACTIVE_CHECK,
-  $ as CONFIG_INPUTS_PUBLISHED,
-  a0 as setVerdict,
-  a1 as context,
-  a2 as REACTIVE_PROBED,
-  a3 as globalQueue,
-  a4 as staleReader,
-  a5 as REACTIVE_STAGED_READ,
-  a6 as verdict,
-  a7 as link,
-  a8 as pullComputed,
-  a9 as strictRead,
-  aa as warnStrictReadUntracked,
-  ab as markLateLinker,
-  ac as spectating,
-  ad as STATUS_ERROR,
-  ae as unflushedValue,
-  af as stagedReaders,
-  ag as enterAction,
-  ah as setEffectCallback,
-  ai as exitAction,
-  aj as isThenable,
-  ak as actionDepth,
-  al as flush,
-  am as setQuestion,
-  an as emitDiagnostic,
-  ao as enterCallback,
-  ap as exitCallback,
-  aq as getOwner,
-  ar as inEffectCallback,
-  as as signal,
-  at as setSignal,
-  au as cleanup,
-  av as read,
-  aw as NoOwnerError,
-  ax as ContextNotFoundError,
-  ay as createEffectNode,
-  az as recompute,
-  aA as EFFECT_USER,
-  aB as reportDiagnostic,
-  aC as computed,
-  aD as staleValues,
-  aE as CONFIG_AUTO_DISPOSE,
-  aF as EFFECT_TRACKED,
-  aG as unwrapStatusError,
-  aH as haltReactivity,
-  aI as setStrictRead,
-  aJ as StatusError,
-  aK as trimStaleDeps,
-  aL as setTrackedQueueCallback,
-  aM as setEffectStatusNotify,
-  aN as _hitUnhandledAsync,
-  aO as resetUnhandledAsync,
-  aP as ROOT_ERROR_HOOK,
-  aQ as registerGraph,
-  aR as runWithOwner,
-  aS as setMemo,
-  aT as $REFRESH,
-  aU as markRefresh,
-  aV as createRoot,
-  aW as getObserver,
-  aX as dispose,
-  aY as TimeoutError,
-  aZ as untrack,
-  a_ as dirtyQueue,
-  a$ as CONFIG_REDERIVE,
-  b0 as passTx,
-  b1 as CONFIG_FRESH_READ,
-  b2 as createOwner,
-  b3 as REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE,
-  b4 as ownedScopeWriteMessage,
-  b5 as DEV$1,
-  b6 as isEqual,
-  b7 as CONFIG_MANUAL_WRITE,
-  b8 as notePromotedWrite,
-  b9 as slotSignal,
-  ba as stagedScreen,
-  bb as CONFIG_PROMOTED,
-  bc as setSlotUnobserved,
-  bd as joinPassTx,
-  be as asyncTailFlights,
-  bf as untrackDepth,
-  bg as checkPostAwaitRead,
-  bh as insertIntoHeap,
-  bi as isDisposed,
-  bj as handleAsync,
-  bk as addPendingSource,
-  bl as propagateStatus,
-  bm as forEachDependent,
-  bn as settlePendingSource,
-  bo as notifyEpoch,
-  bp as SUPPORTS_PROXY,
-  bq as REACTIVE_ZOMBIE,
-  br as OBSERVE$1
+  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 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 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 {
-  bs as clearSnapshots,
-  bt as enforceLoadingBoundary,
-  bu as getNextChildId,
-  bv as markSnapshotScope,
-  bw as peekNextChildId,
-  bx as releaseSnapshotScope,
-  by as resetErrorHalt,
-  bz as setConsoleFooter,
-  bA 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
@@ -190,19 +255,13 @@ export {
 // carries none of this.
 /** Live lanes (parented). Scanned at every seam while non-empty. */
 const lanes = [];
+/** A pass left a shown slot the equality gate can no longer see (#3892). */
+const LEFT_SHOWN = 1 << 20;
 function newLane(parent) {
   const l = newTransaction(true, 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) {
@@ -267,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;
@@ -299,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
@@ -326,8 +391,10 @@ function enterLane(l, c) {
     // The pass read a held write before its first lane read (it joined the
     // frame's future as mainline would): lane work sees the screen — the
     // seam re-derives it on the committed world next round (`stagedReaders`,
-    // the park's repair), as it does a lane pass that read a staging.
-    if (c._flags & REACTIVE_JOINED) stagedRead(c);
+    // the park's repair), as it does a lane pass that read a staging. Not a
+    // pass whose held reads were all of nodes born held (no staged read,
+    // `stagedRead`): it has no committed world to re-derive on (#3969).
+    if (c._flags & REACTIVE_JOINED && c._flags & REACTIVE_STAGED_READ) stagedRead(c);
     return;
   }
   if (sameLane(p, l)) return setPassLane(l);
@@ -402,17 +469,22 @@ function verdictLane(t) {
  * propagation (async.ts `propagateStatus`), the node gone pending. */
 function laneStage(el, l, create, errored) {
   if (!(create || errored || el._flags & REACTIVE_LANE_READ || el._config & CONFIG_GUESS)) {
-    if (el._x !== null) {
-      if (el._x._transaction?._lane) el._x._transaction = null;
-      el._x._lane = NOT_PENDING;
-    }
-    el._config &= -2305;
+    const x = el._x;
+    if (x !== null) {
+      const tx = x._transaction;
+      // Cleared before equality, so a return to the committed value notifies
+      // nobody. The seam wakes it unless the frame is still held (#3892).
+      if (tx?._shown && !blocked(resolveTx(tx._parent))) el._flags |= LEFT_SHOWN;
+      if (tx?._lane) x._transaction = null;
+      x._lane = NOT_PENDING;
+    }
+    el._config &= -1050881;
     return false;
   }
   if (!el._type) {
     if (!(el._config & CONFIG_OVERRIDE)) {
       el._pendingValue = NOT_PENDING;
-      el._config = (el._config & ~CONFIG_HELD) | CONFIG_OVERRIDE;
+      el._config = (el._config & -1048833) | CONFIG_OVERRIDE;
       ext(el);
     }
     // A written guess whose own pass is the lane's work — its source is a
@@ -464,6 +536,11 @@ function supersede(n, value, changed) {
   // lane opened (two actions guessing one slot entangle, A34 (1)) — the
   // truth is held by the transaction that lands, not the merged-away one.
   const parent = resolveTx(l._parent ?? l);
+  // A store row answered by a new object the store would reconcile into
+  // the guessed one unchanged is an echo, not a correction (#3898): the
+  // server's object never matches the guess by reference.
+  if (changed && n._config & CONFIG_SLOT_NODE && GlobalQueue._echoes?.(n._x._lane, value))
+    changed = false;
   if (changed) {
     // Observe: a displayed guess is being replaced by a differing truth — a
     // landing's (superseded), or the value it covered (reverted: the body
@@ -476,17 +553,15 @@ function supersede(n, value, changed) {
     if (l._shown) n._value = n._x._lane;
     n._config &= -10241;
     n._x._lane = NOT_PENDING;
-    n._pendingValue = value;
     holdNode(n, parent);
-    joinFuture(parent);
     if (n._subs !== null) insertSubs(n);
   } else {
-    n._pendingValue = value;
     n._config |= CONFIG_HELD;
-    joinFuture(parent);
-    for (let s = n._subs; s !== null; s = s._nextSub)
-      if (s._sub._config & CONFIG_AUTHORITATIVE) enqueueSub(s._sub);
+    // A confirmation is silent (A17); only truth readers are told.
+    GlobalQueue._confirmed?.(l);
   }
+  n._pendingValue = value;
+  joinFuture(parent);
 }
 /** 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
@@ -586,7 +661,7 @@ function dissolveLane(l, into, except) {
       } else {
         if (x._pendingFirstChild !== null || x._pendingDisposal !== null)
           GlobalQueue._dispose(n, false, true);
-        n._config &= -385;
+        n._config &= -1048961;
       }
     }
   }
@@ -621,11 +696,12 @@ function dissolveLane(l, into, except) {
  * member throws like any. */
 function laneRead(c, el) {
   const guess = el._config & CONFIG_GUESS;
-  if (c !== null && c._config & CONFIG_AUTHORITATIVE)
-    return guess && el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value;
+  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
@@ -734,6 +810,10 @@ function laneSeam(l, leaked) {
   reruns(l);
   for (let i = 0; i < l._nodes.length; i++) {
     const n = l._nodes[i];
+    if (n._flags & LEFT_SHOWN) {
+      n._flags ^= LEFT_SHOWN;
+      insertSubs(n);
+    }
     const x = n._x;
     if (x._transaction !== l) continue;
     if (!(n._config & CONFIG_GUESS) && !n._type && n._pendingValue !== NOT_PENDING) {
@@ -848,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
@@ -886,14 +962,30 @@ GlobalQueue._laneSeams = leaks => {
             : !blocked(l._parent)))
       )
         continue;
+      // A leaked effect re-derives seated in its lane from its first read: it
+      // carries no lane value (`laneStage`), so without this its pass starts
+      // as mainline, joins the parked frame on its first held read and reads
+      // the staging, then re-enters the lane at its guess read and leaks
+      // again — every round (#4014). A computed is already seated by its
+      // override, and a written guess's own pass stays the frame's.
+      if (l != null && l._lane && r._type) r._flags |= REACTIVE_LANE_DIRTY;
       enqueueSub(r);
       if (l != null && l._lane && leaked.indexOf(l) === -1) leaked.push(l);
     }
   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++) {
@@ -905,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
@@ -957,9 +1048,12 @@ function route(c, t) {
  * every flush (fuzzer F12). True when the reader is served the committed
  * value — not over a flight committed beneath inputs already on screen (A15
  * reveal corollary, #3305): that value would tear against them, and the
- * reveal observes the flight. */
+ * reveal observes the flight. Nor for a reader born into the flight's
+ * transaction (`bornInto`, #4010): it has no screen — it waits on the flight
+ * with the rest of its frame. */
 function observeFlight(c, el) {
-  if (el._config & CONFIG_INPUTS_PUBLISHED) return false;
+  if (el._config & CONFIG_INPUTS_PUBLISHED || (el._config & CONFIG_HELD && bornInto(c, txOf(el))))
+    return false;
   if (globalQueue._running) {
     joinFuture(null);
     if (!(el._config & CONFIG_HELD)) queuePendingNode(el);
@@ -983,9 +1077,10 @@ let probeFound = false;
  * reader re-derives there. `latest` shows the proposal that lands — a
  * rewrite or a landing reaches its reader through the link it holds — so a
  * re-run would only repeat the frame. */
-function verdictRead(c, t, rerun = probing) {
+function verdictRead(c, t, plain) {
   route(c, t);
-  if (rerun) staleReader(c, t);
+  if (plain) staleReader(c, t);
+  else if (probing && t._reruns[t._reruns.length - 1] !== c) t._reruns.push(c);
 }
 /** A verdict read of a node staged or in flight but not held yet: whether it
  * will be is the seam's.
@@ -1055,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). */
@@ -1068,11 +1163,14 @@ function pendingVerdict(c, el) {
   }
 }
 /** The pass entering a verdict window is a verdict reader (CONFIG_VERDICT):
- * a dependency going pending re-derives it, the verdict having changed. */
+ * a dependency going pending re-derives it, the verdict having changed. Not
+ * an untracked window: that is a snapshot, like any untracked read (#3946 —
+ * a router's link claim probing inside the computation that creates the
+ * anchor). A throw still reaches the pass through `untrack`. */
 function markVerdictReader(window) {
   let c = context;
   if (c?._root) c = c._parentComputed;
-  if (c !== null) {
+  if (c !== null && tracking) {
     c._config |= CONFIG_VERDICT;
     c._flags |= REACTIVE_PROBED;
     // Observe tier: which windows this pass entered (1 `isPending`, 2
@@ -1096,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;
@@ -1122,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;
 }
@@ -1154,7 +1289,8 @@ function heldLatest(el, c) {
  * - an errored derivation throws for every reader (#2897). */
 function verdictValue(el, c) {
   const owner = el;
-  const tracked = c !== null && tracking && !(c._config & CONFIG_CHILDREN_FORBIDDEN);
+  const owned = c !== null && !(c._config & CONFIG_CHILDREN_FORBIDDEN);
+  const tracked = owned && tracking;
   if (c !== null && tracking) {
     link(el, c);
     if (owner._fn !== undefined) {
@@ -1174,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);
@@ -1233,9 +1372,14 @@ function verdictValue(el, c) {
       }
       return el._value;
     }
-    // Born into the future: its staging is its only value.
-    if (el._pendingValue !== NOT_PENDING && !(owner._statusFlags & STATUS_PENDING))
-      return el._pendingValue;
+    // Born into the future: its staging is its only value. It has no
+    // committed value, so no verdict: `isPending` reads it as its read does —
+    // the owner joins the hold (held with it, or caught by a boundary that
+    // 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 staged(el);
+    }
   } else if (el._pendingValue !== NOT_PENDING) {
     if (owner._statusFlags & STATUS_PENDING && !uninitialized)
       pendingVerdict(tracked ? c : null, owner);
@@ -1251,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;
@@ -1273,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 = () => {
@@ -1519,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.
@@ -1541,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;
@@ -1568,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
@@ -1728,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
@@ -1823,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;
@@ -1954,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.
@@ -2042,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) {
@@ -2123,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) {
@@ -2172,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);
@@ -2220,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);
@@ -2249,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;
@@ -2309,21 +2658,31 @@ function createReaction(effectFn, options) {
  *   joined it (L2, born held — A29) and delivers at that commit: the
  *   committed view, never a foreign hold's unrevealed frame. */
 function watch(fn, onValue, onError, config = 0, inPass, own = flushTransaction) {
+  if (config & CONFIG_AUTHORITATIVE) {
+    GlobalQueue._truth = truthRead;
+    GlobalQueue._confirmed = truthConfirmed;
+  }
   // `config` is on the node for its first pass too (the pass runs inside
   // `computed()`): `until`'s predicate is authoritative from its first read,
   // or an already-displayed guess would satisfy it in a later slice. (REDERIVE
   // 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 (
@@ -2334,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));
     },
@@ -2446,17 +2806,24 @@ function refresh(target) {
   const own = flushTransaction;
   const promise = new Promise((res, rej) => {
     queueMicrotask(() => {
-      // No createRoot: the microtask has no ambient owner, so the watcher is
-      // naturally detached, and settle disposes the node directly (dev keeps
-      // a root husk purely to stay quiet about the missing owner). The
-      // capture runs inside the watcher's own pass, where the ambient owner
-      // IS the watcher — exactly what dispose() takes.
+      // The root is load-bearing: an ownerless computed is auto-disposing,
+      // and the settle walk releases an unobserved one instead of re-running
+      // it, so the waiter would never see the refetch land (#3888). Settle
+      // disposes the waiter directly; the capture runs inside the watcher's
+      // own pass, where the ambient owner IS the watcher — exactly what
+      // dispose() takes.
       let waiter = null;
       const make = () =>
         watch(
           () => {
             if (waiter === null) waiter = getOwner();
-            return read(node);
+            // Authoritative: the truth beneath a guess (`until`'s view). A
+            // guessed node's own re-ask is not answered by it (#3895): park
+            // on that flight, or reject with its error.
+            const v = read(node);
+            if (node._config & CONFIG_GUESS && node._statusFlags & (STATUS_PENDING | STATUS_ERROR))
+              throw node._x?._error;
+            return v;
           },
           value => {
             res(typeof target === "function" ? value : target);
@@ -2466,7 +2833,7 @@ function refresh(target) {
             rej(err);
             dispose(waiter);
           },
-          CONFIG_FRESH_READ,
+          CONFIG_FRESH_READ | CONFIG_AUTHORITATIVE,
           undefined,
           own
         );
@@ -2688,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;
@@ -2977,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
@@ -2991,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
@@ -2998,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];
@@ -3041,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;
@@ -3143,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);
@@ -3247,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
@@ -3343,6 +3682,15 @@ function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 
+let optHooks = null;
+function installOptHooks(hooks) {
+  optHooks = hooks;
+}
+let affectsHooks = null;
+function installAffectsHooks(hooks) {
+  affectsHooks = hooks;
+}
+
 /**
  * Store — plain stores on L2 (plan sec. 31, S1).
  *
@@ -3373,14 +3721,6 @@ function compare(key, a, b) {
  * setter (`wk`); overlay drafts for large plain records; no new named
  * fields on array targets; zero allocation for adopted-but-unread objects.
  */
-let optHooks = null;
-function installOptHooks(hooks) {
-  optHooks = hooks;
-}
-let affectsHooks = null;
-function installAffectsHooks(hooks) {
-  affectsHooks = hooks;
-}
 /** Key of the deep-witness slot node (never a user key). */
 const $DEEP = Symbol("STORE_DEEP");
 // ---------------------------------------------------------------------------
@@ -3570,17 +3910,22 @@ function releaseSlot(node) {
 function noteNode(target, node, key) {
   if (target.fam !== null) target.fam.live.add(target);
   markDescendants(target);
-  if (affectsHooks !== null) affectsHooks.born(target, node, key);
+  if (affectsHooks !== null) affectsHooks._born(target, node, key);
 }
 // Shared slot-node release handler: registered once; the core sweep
 // 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
@@ -3640,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;
@@ -3693,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 &&
@@ -3716,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);
@@ -3746,6 +4093,7 @@ function notifyContainer(k, pb) {
   if (k._config & CONFIG_OVERRIDE) setSignal(k, pb);
   else {
     if (k._config & CONFIG_HELD) joinFuture(txOf(k));
+    if (snapshotCaptureActive) captureWriteSnapshot(k, k._value);
     insertSubs(k);
     schedule();
   }
@@ -3763,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)
@@ -3851,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))
@@ -4081,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);
       }
@@ -4114,10 +4464,14 @@ 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;
+GlobalQueue._storeWrappable = isWrappable;
 /** A projection's creation run commits directly (a memo's first value is
  * its `_value`, not a staging): the draft still writes a clone of the seed,
  * nothing is staged on the nodes, and the setter's exit folds the touched
@@ -4144,7 +4498,10 @@ function foldTarget(t, old) {
           // the adopted object (shared ownership — never cloned).
           t.pb = null;
           t.wk = null;
-        } else if (t.ovl && (t.v !== old || !overlayRebuilds(t, pb))) {
+        } else if (
+          t.ovl &&
+          (t.v !== old || (!overlayRebuilds(t, pb) && k?._x?._snapshotValue !== old))
+        ) {
           // Overlay flatten (#3044): the backing keeps its identity, so the
           // `t.v === old` gate below skips path copying (the parent slot
           // already points here) and the adopted-notify (setter
@@ -4158,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);
@@ -4334,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);
@@ -4355,16 +4716,19 @@ function notifyWrites(t) {
       ) {
         // Accessor keys: the node is linked for shape-change notification,
         // its value is never served (the getter runs with the proxy
-        // receiver on read) — FORCE wakes the readers.
+        // receiver on read) — FORCE wakes the readers. A data descriptor
+        // falls through so the cleared-acc hot read serves it (#3949);
+        // an own getter's descriptor has no `value`, so the compare below
+        // would otherwise keep the getter's result (or FORCE) for `undefined`.
         node.acc = isOwnAccessor(pb, key);
         const od = Object.getOwnPropertyDescriptor(old, key);
         const nd = Object.getOwnPropertyDescriptor(pb, key);
-        if ((od && (od.get || od.set)) || (nd && (nd.get || nd.set))) {
+        if (!nd || nd.get || nd.set) {
           if (od?.get !== nd?.get || od?.set !== nd?.set || od?.value !== nd?.value)
             setSignal(node, () => FORCE);
           continue;
         }
-        if (!isEqual(od?.value, nd?.value)) setSignal(node, () => nd?.value);
+        if (od?.get || od?.set || !isEqual(od?.value, nd.value)) setSignal(node, () => nd.value);
         continue;
       }
       const nv = t.del !== null && t.del.has(key) ? undefined : pb[key];
@@ -4462,14 +4826,15 @@ function notifyKeyDiff(node, key, old, neu, probe = true) {
     node.acc = isOwnAccessor(neu, key);
     const od = Object.getOwnPropertyDescriptor(old, key);
     const nd = Object.getOwnPropertyDescriptor(neu, key);
-    if ((od && (od.get || od.set)) || (nd && (nd.get || nd.set))) {
+    // Data descriptors fall through, as in notifyWrites (#3949).
+    if (!nd || nd.get || nd.set) {
       if (od?.get !== nd?.get || od?.set !== nd?.set || od?.value !== nd?.value)
         setSignal(node, () => FORCE);
       return;
     }
     const ov = od?.value;
     const nv = nd?.value;
-    if (!isEqual(ov, nv) && !targetsEqual(ov, nv))
+    if (od?.get || od?.set || (!isEqual(ov, nv) && !targetsEqual(ov, nv)))
       setSignal(node, typeof nv === "function" ? () => nv : nv);
   } else {
     const ov = old[key];
@@ -4710,7 +5075,67 @@ function readSource(target, key, shape = false) {
 /** Did the HELD staging (the container node's, not a mainline layer above
  * it) change `key`? */
 function heldKeyChanged(target, key, shape = true) {
-  return changedBetween(target, target.k._value, target.k._pendingValue, key, shape);
+  return (
+    changedBetween(target, target.k._value, target.k._pendingValue, key, shape) &&
+    !adoptChild(target, key)
+  );
+}
+/** The values of a held frame, built once per frame: neither the committed
+ * frame nor the held staging changes while the hold stands (a draft writes a
+ * clone), so the set stays true for every first read of the hold. */
+const frameRaws = new WeakMap();
+function rawsOf(frame) {
+  let raws = frameRaws.get(frame);
+  if (raws === undefined) frameRaws.set(frame, (raws = new Set(Object.values(frame))));
+  return raws;
+}
+/** The same row at a slot, as the adoption pairs rows (reconcile.ts): two
+ * objects whose keys agree — positionally for an unkeyed family. */
+function sameRow$1(pv, nv, keyFn) {
+  return (
+    pv !== null &&
+    typeof pv === "object" &&
+    nv !== null &&
+    typeof nv === "object" &&
+    (keyFn === null || sameKey(keyFn(pv), keyFn(nv)))
+  );
+}
+/** A key of a held adoption whose old and new values are the same row that
+ * nothing had proxied when the adoption ran, so `descend` never paired
+ * them: paired now, as it would have been (#3712) — one target, the old
+ * raw its committed frame, the new raw its staging, held by the same
+ * transaction. Both raws resolve to it, so the slot reads as unchanged and
+ * the row's own leaves decide: `id` the same in both frames holds no one,
+ * `version` holds. A record's keys pair by name; an array's by the family's
+ * key — without a family the pairing is not known here and the hold stands. */
+function adoptChild(target, key) {
+  const k = target.k;
+  const old = asBacking(k._value);
+  const ov = old[key];
+  const nv = k._pendingValue[key];
+  const keyFn = Array.isArray(old) ? target.fam?.key : null;
+  if (
+    target.s ||
+    keyFn === undefined ||
+    !sameRow$1(ov, nv, keyFn) ||
+    !isWrappable(ov) ||
+    !isWrappable(nv) ||
+    Array.isArray(ov) !== Array.isArray(nv) ||
+    lookupTarget(ov, target.fam) !== undefined ||
+    lookupTarget(nv, target.fam) !== undefined ||
+    // A raw in both frames (the same objects swapped or reordered) is its
+    // own row: pairing it with another would alias the two after the commit.
+    rawsOf(old).has(nv) ||
+    rawsOf(k._pendingValue).has(ov)
+  )
+    return false;
+  // A raw-marked value wraps to itself, a proxy to its own target: neither
+  // is a fresh target around `ov`.
+  const ct = wrap(ov, target, key)[$TARGET];
+  if (ct === undefined || ct.v !== ov) return false;
+  adoptPB(ct, nv, false);
+  holdNode(getContainerNode(ct), txOf(k));
+  return true;
 }
 /** A family target's unheld staging, read with no pass (a handler). */
 function familyAhead(target) {
@@ -4839,11 +5264,13 @@ function pullFamily(target) {
     // One that already observes the flight (linked by the pass that saw it
     // go up — the frame's hold, `blocked`) keeps observing it: a re-run for
     // another reason (a guess it read, the seam) that dropped the link would
-    // release the hold with the flight still up.
+    // release the hold with the flight still up. An errored derive has no
+    // landing to learn of: the error is what the frame shows.
     const c = context;
     if (
       c !== null &&
       c._type === EFFECT_RENDER &&
+      !(fw._statusFlags & STATUS_ERROR) &&
       fw._config & CONFIG_HELD &&
       flushTransaction !== txOf(fw) &&
       !linkedTo(c, fw)
@@ -4928,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.
@@ -4955,7 +5398,7 @@ const traps = {
     // (The witness before the pull: a mark on an uninitialized derived
     // store is witnessed, then the pull throws — loading, declared pending.)
     if (verdict !== null && affectsHooks !== null && getObserver() === null)
-      affectsHooks.witness(target, key);
+      affectsHooks._witness(target, key);
     if (target.fam !== null) pullFamily(target);
     // Hot inline case: existing PLAIN node (non-accessor) read outside any
     // draft — the dbmon/uibench effect re-read shape. Core's `read()` serves
@@ -5102,7 +5545,7 @@ const traps = {
     // (The witness before the pull: a mark on an uninitialized derived
     // store is witnessed, then the pull throws — loading, declared pending.)
     if (verdict !== null && affectsHooks !== null && getObserver() === null)
-      affectsHooks.witness(target, key);
+      affectsHooks._witness(target, key);
     if (target.fam !== null) pullFamily(target);
     const src = readSource(target, key);
     // A tracked reader's presence node answers (born from the two frames;
@@ -5127,7 +5570,7 @@ const traps = {
   },
   ownKeys(target) {
     if (verdict !== null && affectsHooks !== null && getObserver() === null)
-      affectsHooks.witness(target, undefined);
+      affectsHooks._witness(target, undefined);
     if (target.fam !== null) pullFamily(target);
     return visibleKeys(target, enumerationSource(target));
   },
@@ -5135,7 +5578,7 @@ const traps = {
     if (key === $OWNER || key === $RECORD) return undefined;
     const obs = getObserver();
     if (verdict !== null && affectsHooks !== null && obs === null)
-      affectsHooks.witness(target, key);
+      affectsHooks._witness(target, key);
     if (target.fam !== null) pullFamily(target);
     // An enumerator (spread, Object.entries) already holds the container
     // node and reads its frame; a descriptor read on its own tracks
@@ -5175,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)) {
@@ -5219,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);
@@ -5231,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;
   }
@@ -5262,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",
@@ -5298,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;
@@ -5365,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);
@@ -5379,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);
@@ -5638,150 +6102,29 @@ function updatePath(current, args, i = 0) {
  * Path parts can be:
  * - a single key — `"user"`, `0`
  * - an array of keys — `[0, 1, 2]`
- * - a range over an array — `{ from?, to?, by? }`
- * - a filter `(item, index) => boolean` for arrays
- *
- * The final argument is the new value or an updater `(prev) => next`. Use
- * `storePath.DELETE` to remove a property.
- *
- * @example
- * ```ts
- * const [state, setState] = createStore({ user: { name: "Ada" }, todos: [] });
- *
- * setState(storePath("user", "name", "Grace"));
- * setState(storePath("todos", t => !t.done, "done", true)); // mark all undone as done
- * setState(storePath("user", "nickname", storePath.DELETE));
- * ```
- */
-const storePath = /* @__PURE__ */ Object.assign(
-  function storePath(...args) {
-    return state => {
-      updatePath(state, args);
-    };
-  },
-  { DELETE }
-);
-
-/**
- * Store — the store half of `affects()` (plan sec. 29, plan sec. 37; A24 (4), #2882,
- * #2893, #2904).
- *
- * A mark on a store is a mark on nodes (affects.ts: a count on the node, a
- * dependency walk at probe time): `affects(record, key)` marks the slot's
- * leaf; `affects(record)` marks a carrier (the record's `$AFFECTS` leaf)
- * and every live node in the record's subtree — the edges existing readers
- * subscribed through. Coverage is by RAW IDENTITY, not read path (#2882: a
- * captured row proxy, a derived store sharing the source's raw, never read
- * through the declaration's proxy): the identities reachable at the
- * declaration are the mark's `scope`, so a node born inside the window on
- * a covered record inherits the mark (released with the carrier's last),
- * and an untracked probe through a record with no nodes is witnessed into
- * the verdict. A mark declared on a draft (inside a setter) or over an
- * optimistic family walks the view the writer sees.
- *
- * Installed by `store/index.ts`: a program with stores carries it; one
- * without pays nothing (affects.ts asks `GlobalQueue._storeMarks`).
- */
-/** The keyless mark's carrier key: a leaf of the record no read serves. */
-const $AFFECTS = Symbol("STORE_AFFECTS");
-const scopes = new Map();
-/** The nodes an `affects(store[, key])` declaration marks (affects.ts
- * registers each). */
-function storeMarks(t, key) {
-  if (key === undefined) {
-    const carrier = getNode(t, $AFFECTS);
-    let entry = scopes.get(carrier);
-    if (entry === undefined) scopes.set(carrier, (entry = { scope: new Set(), inherited: [] }));
-    const found = [carrier];
-    walk(t.px, entry, found, t.fam, new Set());
-    return found;
-  }
-  const node = t.n?.[key] ?? getNode(t, key);
-  let entry = scopes.get(node);
-  if (entry === undefined) scopes.set(node, (entry = { scope: new Set(), inherited: [], key }));
-  entry.scope.add(t.v);
-  if (t.pb !== null) entry.scope.add(t.pb);
-  return [node];
-}
-/** The identities reachable from `value` into the scope (the draft's and
- * the committed backing both, when a draft is open; an optimistic family's
- * view), every live node under each record into `found`. Untracked by
- * construction: raws, never traps. */
-function walk(value, entry, found, fam, visited) {
-  if (!isWrappable(value)) return;
-  const t = value[$TARGET] ?? lookupTarget(value, fam);
-  let raw = t !== undefined ? (t.pb ?? t.v) : value;
-  if (visited.has(raw)) return;
-  visited.add(raw);
-  entry.scope.add(raw);
-  if (t !== undefined) {
-    if (t.pb !== null) entry.scope.add(t.v);
-    // The writer's view: the tick's own unflushed guesses are in motion too.
-    if (t.fam?.opt === true) raw = optHooks.view(t, raw, true);
-    const nodes = t.n;
-    if (nodes !== null)
-      for (const k of Reflect.ownKeys(nodes))
-        // Another mark's carrier is its own channel: counting it here would
-        // extend that scope's lifetime to this declaration's.
-        if (k !== $AFFECTS) found.push(nodes[k]);
-    const has = t.h;
-    if (has !== null) for (const k of Reflect.ownKeys(has)) found.push(has[k]);
-    if (t.k !== null) found.push(t.k);
-    if (t.dk !== null) found.push(t.dk);
-    fam = t.fam ?? fam;
-  }
-  for (const k of Reflect.ownKeys(raw)) {
-    if (k === $OWNER) continue;
-    const d = Object.getOwnPropertyDescriptor(raw, k);
-    if (d === undefined || d.get !== undefined) continue;
-    walk(d.value, entry, found, fam, visited);
-  }
-}
-/** A live scope covering `t`'s identity (keyed: for `key`). Chained
- * backings (§7b): a view's backing is another store's proxy — marks cover
- * the BASE raw, so every identity along the chain is checked. */
-function covering(t, key, skip) {
-  for (const [carrier, entry] of scopes) {
-    if (carrier === skip || (entry.key !== undefined && entry.key !== key)) continue;
-    for (let r = t.v; ; ) {
-      if (entry.scope.has(r)) return carrier;
-      const inner = r?.[$TARGET];
-      if (inner === undefined) break;
-      const backing = inner.pb ?? inner.v;
-      if (backing === r) break;
-      r = backing;
-    }
-  }
-  return null;
-}
-installAffectsHooks({
-  // A node born on a record a live mark covers inherits it (released with
-  // the carrier's last registration).
-  born(t, node, key) {
-    if (key === $AFFECTS) return;
-    const carrier = covering(t, key, node);
-    if (carrier === null) return;
-    GlobalQueue._mark(node);
-    scopes.get(carrier).inherited.push(node);
+ * - a range over an array — `{ from?, to?, by? }`
+ * - a filter `(item, index) => boolean` for arrays
+ *
+ * The final argument is the new value or an updater `(prev) => next`. Use
+ * `storePath.DELETE` to remove a property.
+ *
+ * @example
+ * ```ts
+ * const [state, setState] = createStore({ user: { name: "Ada" }, todos: [] });
+ *
+ * setState(storePath("user", "name", "Grace"));
+ * setState(storePath("todos", t => !t.done, "done", true)); // mark all undone as done
+ * setState(storePath("user", "nickname", storePath.DELETE));
+ * ```
+ */
+const storePath = /* @__PURE__ */ Object.assign(
+  function storePath(...args) {
+    return state => {
+      updatePath(state, args);
+    };
   },
-  // An untracked probe (`isPending(() => s.x)` with no observer) reading a
-  // record a live mark covers: no node carries the mark for it — the
-  // verdict is told directly.
-  witness(t, key) {
-    const own = t.n?.[$AFFECTS];
-    if ((own !== undefined && own._x !== null && own._x._marks !== 0) || covering(t, key) !== null)
-      GlobalQueue._witnessMark();
-  }
-});
-GlobalQueue._storeMarks = storeMarks;
-/** The carrier's last mark released (affects.ts): its scope dies, and the
- * nodes that inherited the mark release theirs. */
-GlobalQueue._releaseMarkScope = carrier => {
-  const entry = scopes.get(carrier);
-  if (entry === undefined) return;
-  scopes.delete(carrier);
-  GlobalQueue._releaseMarks(entry.inherited);
-};
+  { DELETE }
+);
 
 /**
  * Store — reconcile: the immutable-diff adoption channel (INTERNALS §3).
@@ -5874,17 +6217,7 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
       for (const end = Math.min(plen, nlen); i < end; i++) {
         const nv = nextRows[i];
         const pvRaw = prevRows[i];
-        if (
-          pvRaw !== nv &&
-          !(
-            pvRaw !== null &&
-            typeof pvRaw === "object" &&
-            nv !== null &&
-            typeof nv === "object" &&
-            sameKey(keyFn(pvRaw), keyFn(nv))
-          )
-        )
-          break; // misaligned: fall to the keyed remainder below
+        if (pvRaw !== nv && !sameRow$1(pvRaw, nv, keyFn)) break; // misaligned: fall to the keyed remainder below
         if (
           (pvRaw !== nv || (nv !== null && typeof nv === "object" && isOwned(nv))) &&
           nv !== null &&
@@ -6274,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 —
@@ -6296,7 +6634,9 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, aroundDraftWri
     // A flight went up (NotReady out of the pass — the derive's own, with
     // the derive as its source): the leaves' readers learn it from here —
     // they do not subscribe to the derive.
-    if (e instanceof NotReadyError && !first) wakeFamily(fam, e);
+    // A synchronous error the same way (#3956: a rerun that finds the
+    // entry failed throws): every live reader re-derives and meets it.
+    if (!first) e instanceof NotReadyError ? wakeFamily(fam, e) : errorFamily(fam);
     throw e;
   }
   // A pass that returned with a flight up (an iterator's sync first yield):
@@ -6313,11 +6653,23 @@ 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(),
     node: null,
     live: new Set(),
-    shallow: !!options?.shallow
+    shallow: !!options?.shallow,
+    // The row key, for a child paired after the adoption (store.ts
+    // `adoptChild`, #3712) as the adoption pairs them.
+    key:
+      typeof keyOption === "function"
+        ? keyOption
+        : keyOption === null
+          ? null
+          : row => (isWrappable(row) ? row[keyOption] : undefined)
   };
   const store = wrap(seed, null, null, fam);
   if (fam.shallow) {
@@ -6326,24 +6678,25 @@ 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();
-    runProjectionComputed(store, fn, options?.key === undefined ? "id" : options.key);
+    runProjectionComputed(store, fn, keyOption);
   }, 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;
 }
@@ -6494,8 +6847,38 @@ function rowSame(a, b, keyFn) {
   if (keyFn === null || !isWrappable(a) || !isWrappable(b)) return false;
   const ka = keyFn(unwrapValue(a));
   const kb = keyFn(unwrapValue(b));
+  // Keyless rows are identified by position — reconcile's fallback when the
+  // key is missing. The caller already paired these by index, so two keyless
+  // rows are the same row and the landing confirms the arrangement instead of
+  // dissolving it. Dissolving held an external echo under the action, and a
+  // mainline `until` then timed out on a source that already contained it
+  // (#3898). Keyed rows still match only on the key.
+  if (ka === undefined && kb === undefined) return true;
   return ka !== undefined && sameKey(ka, kb);
 }
+/** Whether reconcile would write anything into `a` from `b`: wrappable
+ * pairs descend, leaves compare as its writes do. A key mismatch is a
+ * replacement, which a content difference already says. Plain data — the
+ * server's echo of a guessed row is a new object with the same contents. */
+function echoes(a, b) {
+  if (a === b) return true;
+  if (!isWrappable(a) || !isWrappable(b)) return false;
+  a = unwrapValue(a);
+  b = unwrapValue(b);
+  const ak = Object.keys(a);
+  if (Array.isArray(a) !== Array.isArray(b) || ak.length !== Object.keys(b).length) return false;
+  for (const k of ak) if (!hasOwn.call(b, k) || !echoes(a[k], b[k])) return false;
+  return true;
+}
+// A cycle (a row that references itself) is not plain data: no match, so
+// the landing stays a correction.
+GlobalQueue._echoes = (a, b) => {
+  try {
+    return echoes(a, b);
+  } catch {
+    return false;
+  }
+};
 function arrangementEqual(a, b, keyFn) {
   if (Array.isArray(a) !== Array.isArray(b)) return false;
   if (Array.isArray(a)) {
@@ -6840,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(),
@@ -6856,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);
@@ -6865,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);
@@ -7934,55 +8320,59 @@ function deep(value) {
   return deep$1(value);
 }
 
-// `affects()` — the declaration verb of the pending model (A24 (4), ruled
-// 2026-07-13; the #2893 audit corollaries; rebuilt on L2 2026-10-02 as ruled:
-// transaction-inert).
-//
-// A mark is a declared in-flight change: the marked node — and everything
-// derived from it — reads pending (`isPending` → true) from the declaration
-// until the surrounding transaction lands (an ambient mark, declared outside
-// one, releases at the next seam). The marked values stay readable: no reader
-// suspends on a mark, a mark holds nothing and entangles nothing — it is not
-// a node of its transaction (`blocked` never sees it), and a reader of marked
-// 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.
+// 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`), listed with its
-// scope (the transaction's `_marks`, or the ambient list). Coverage of the
+// 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 at registration and at
-// release (`repoll`): the only notification a mark makes.
-//
-// 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. */
+// 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;
-/** 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()) {
+ * 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 & CONFIG_VERDICT) enqueueSub(sub);
-    if (!sub._type) repoll(sub, seen);
+    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 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. */
+ * 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) {
@@ -7991,18 +8381,183 @@ function marked(el, seen) {
     }
   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).
+ *
+ * A mark on a store is a mark on nodes (affects.ts: a count on the node, a
+ * dependency walk at probe time): `affects(record, key)` marks the slot's
+ * leaf; `affects(record)` marks a carrier (the record's `$AFFECTS` leaf)
+ * and every live node in the record's subtree — the edges existing readers
+ * subscribed through. Coverage is by RAW IDENTITY, not read path (#2882: a
+ * captured row proxy, a derived store sharing the source's raw, never read
+ * through the declaration's proxy): the identities reachable at the
+ * declaration are the mark's `scope`, so a node born inside the window on
+ * a covered record inherits the mark (released with the carrier's last),
+ * and an untracked probe through a record with no nodes is witnessed into
+ * the verdict. A mark declared on a draft (inside a setter) or over an
+ * optimistic family walks the view the writer sees.
+ *
+ * Imported by `affects()`, which installs it on its first store target
+ * (#3891, after #3912): a program with stores that never declares a mark
+ * carries none of it. It never imports store.ts — the engine's top level —
+ * so a program declaring marks without stores carries this module alone:
+ * the store's nodes and its wrappability test come through `GlobalQueue`
+ * (`_storeNode`, `_storeWrappable`), and node birth and the untracked traps
+ * reach back through `affectsHooks` (hooks.ts).
+ */
+/** The keyless mark's carrier key: a leaf of the record no read serves. */
+const $AFFECTS = Symbol("STORE_AFFECTS");
+const scopes = new Map();
+function scopeOf(carrier, key) {
+  let entry = scopes.get(carrier);
+  if (entry === undefined)
+    scopes.set(carrier, (entry = { _scope: new Set(), _inherited: [], _key: key }));
+  return entry;
+}
+/** The nodes an `affects(store[, key])` declaration marks (affects.ts
+ * registers each). */
+function storeMarks(t, key) {
+  const node = GlobalQueue._storeNode(t, key === undefined ? $AFFECTS : key);
+  const entry = scopeOf(node, key);
+  if (key === undefined) {
+    const found = [node];
+    walk(t.px, entry, found, t.fam, new Set());
+    return found;
+  }
+  entry._scope.add(t.v);
+  if (t.pb !== null) entry._scope.add(t.pb);
+  return [node];
+}
+/** The identities reachable from `value` into the scope (the draft's and
+ * the committed backing both, when a draft is open; an optimistic family's
+ * view), every live node under each record into `found`. Untracked by
+ * construction: raws, never traps. */
+function walk(value, entry, found, fam, visited) {
+  if (!GlobalQueue._storeWrappable(value)) return;
+  const t = value[$TARGET] ?? lookupTarget(value, fam);
+  let raw = t !== undefined ? (t.pb ?? t.v) : value;
+  if (visited.has(raw)) return;
+  visited.add(raw);
+  entry._scope.add(raw);
+  if (t !== undefined) {
+    if (t.pb !== null) entry._scope.add(t.v);
+    // The writer's view: the tick's own unflushed guesses are in motion too.
+    if (t.fam?.opt === true) raw = optHooks.view(t, raw, true);
+    const nodes = t.n;
+    if (nodes !== null)
+      for (const k of Reflect.ownKeys(nodes))
+        // Another mark's carrier is its own channel: counting it here would
+        // extend that scope's lifetime to this declaration's.
+        if (k !== $AFFECTS) found.push(nodes[k]);
+    const has = t.h;
+    if (has !== null) for (const k of Reflect.ownKeys(has)) found.push(has[k]);
+    if (t.k !== null) found.push(t.k);
+    if (t.dk !== null) found.push(t.dk);
+    fam = t.fam ?? fam;
+  }
+  for (const k of Reflect.ownKeys(raw))
+    if (k !== $OWNER) {
+      const d = Object.getOwnPropertyDescriptor(raw, k);
+      if (d.get === undefined) walk(d.value, entry, found, fam, visited);
+    }
+}
+/** A live scope covering `t`'s identity (keyed: for `key`). Chained
+ * backings (§7b): a view's backing is another store's proxy — marks cover
+ * the BASE raw, so every identity along the chain is checked. */
+function covering(t, key, skip) {
+  for (const [carrier, entry] of scopes) {
+    if (carrier === skip || (entry._key !== undefined && entry._key !== key)) continue;
+    for (let r = t.v; ; ) {
+      if (entry._scope.has(r)) return carrier;
+      const inner = r?.[$TARGET];
+      if (inner === undefined) break;
+      const backing = inner.pb ?? inner.v;
+      if (backing === r) break;
+      r = backing;
+    }
+  }
+  return null;
+}
+/** The store's side: node birth and the untracked traps call it (store.ts,
+ * through `affectsHooks`) — with no live mark too: an empty scope map is
+ * no work. */
+const hooks = {
+  // A node born on a record a live mark covers inherits it (released with
+  // the carrier's last registration).
+  _born(t, node, key) {
+    if (scopes.size === 0 || key === $AFFECTS) return;
+    const carrier = covering(t, key, node);
+    if (!carrier) return;
+    GlobalQueue._mark(node);
+    scopes.get(carrier)._inherited.push(node);
+  },
+  // An untracked probe (`isPending(() => s.x)` with no observer) reading a
+  // record a live mark covers: no node carries the mark for it — the
+  // verdict is told directly.
+  _witness(t, key) {
+    if (t.n?.[$AFFECTS]?._x?._marks || covering(t, key)) GlobalQueue._witnessMark();
+  }
+};
+/** `affects()` calls it before a store-targeted declaration (idempotent). */
+function installStoreAffects() {
+  installAffectsHooks(hooks);
+}
+/** The carrier's last mark released (affects.ts): its scope dies, and the
+ * nodes that inherited the mark release theirs. */
+function releaseMarkScope(carrier) {
+  const entry = scopes.get(carrier);
+  if (entry === undefined) return;
+  scopes.delete(carrier);
+  releaseMarksHook(entry._inherited);
+}
+
+// `affects()` — the declaration verb of the pending model (A24 (4), ruled
+// 2026-07-13; the #2893 audit corollaries; rebuilt on L2 2026-10-02 as ruled:
+// transaction-inert).
+//
+// A mark is a declared in-flight change: the marked node — and everything
+// derived from it — reads pending (`isPending` → true) from the declaration
+// until the surrounding transaction lands (an ambient mark, declared outside
+// one, releases at the next seam). The marked values stay readable: no reader
+// suspends on a mark, a mark holds nothing and entangles nothing — it is not
+// a node of its transaction (`blocked` never sees it), and a reader of marked
+// 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: 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.
+/** Marks declared outside a transaction: released at the next seam. */
+const ambient = [];
 /** 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.
-      GlobalQueue._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;
 }
@@ -8018,10 +8573,6 @@ function register(node) {
   }
   repoll(node);
 }
-function mark(node) {
-  ext(node)._marks++;
-  active++;
-}
 function affects(target, key) {
   if (arguments.length > 2)
     invalid(
@@ -8032,7 +8583,8 @@ function affects(target, key) {
   // record's carrier and every live node under it.
   const t = target?.[$TARGET];
   if (t !== undefined) {
-    const nodes = GlobalQueue._storeMarks(t, key);
+    installStoreAffects();
+    const nodes = storeMarks(t, key);
     for (let i = 0; i < nodes.length; i++) register(nodes[i]);
     schedule();
     return;
@@ -8058,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").
@@ -8084,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 ||
@@ -8092,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
@@ -8183,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
@@ -8218,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). */
@@ -8234,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
@@ -8251,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))) {
@@ -8260,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) {
@@ -8273,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) &&
@@ -8284,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
@@ -8350,12 +9073,18 @@ 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
-        // lane's reader reveals with the lane, this round.)
-        if (!pass) continue;
+        // lane's reader reveals with the lane, this round.) A boundary that
+        // has not shown content catches it instead: the fallback stays until
+        // the reader is committed (#3540: what a fresh boundary catches holds
+        // nothing outside it).
+        if (!pass || !b._initialized) continue;
         joinFuture(txOf(r));
       }
       b._readers.delete(r);
@@ -8377,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() {
@@ -8390,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) {
@@ -8416,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;
@@ -8449,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) {
@@ -8481,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;
@@ -8541,7 +9287,8 @@ function createBoundary(type, fn, show, onFn) {
     _gated: false,
     _collapsed: false,
     _error: type === STATUS_ERROR ? signal(undefined, ERROR_SIGNAL) : null,
-    _show: show
+    _show: show,
+    _fb: null
   };
   const controller = type === STATUS_PENDING ? owner._context[REVEAL] : null;
   if (getOwner())
@@ -8626,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.
@@ -8667,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;
@@ -8682,6 +9427,20 @@ function createBoundary(type, fn, show, onFn) {
       if (b._fallback && b._type & STATUS_PENDING && attrHooks !== null)
         attrHooks.boundaryFallback(b, b._tree, false);
       b._fallback = false;
+      // The fallback dies when the content that replaces it is on screen —
+      // with this flush's commits when the pass is the frame's, at the
+      // landing when the frame parks (the run is held with it, as the old
+      // children of a held pass are) — not now: a held swap keeps the
+      // fallback on screen, live, until it commits. A pass back to the
+      // fallback before then finds it still built and keeps it.
+      const fb = b._fb;
+      if (fb !== null)
+        globalQueue.enqueue(EFFECT_RENDER, () => {
+          if (!b._fallback && b._fb === fb) {
+            dispose(fb);
+            b._fb = null;
+          }
+        });
       release(b);
       // Shown: the slot leaves its reveal order (a later re-arm gates nobody
       // else; the frontier moves on).
@@ -8724,7 +9483,22 @@ function fallback(b) {
     if (!globalQueue._running) schedule();
   }
   b._fallback = true;
-  return b._show(b);
+  // Built in its own scope, like `Show`'s function child, once per show
+  // (D-39: the fallback is the display until a new answer replaces the
+  // error): a re-derive of the output while it shows — a second reader
+  // caught, the same error propagated again through a sibling's re-run, a
+  // retry pending after `reset()`, a later error — keeps the built
+  // fallback, its DOM and focus with it (#3991). A later error reaches it
+  // through the error accessor; only a fallback reading the accessor at its
+  // top level is rebuilt by it. Created beside the output — in its owner,
+  // outside the boundary, as the output is: its errors and runs are the
+  // enclosing boundary's — with the output's id, so what it builds gets the
+  // ids a build under the output would; disposed once content is on screen.
+  if (b._fb === null) {
+    const out = getOwner();
+    b._fb = runWithOwner(out._parent, () => computed(() => b._show(b), { id: out.id }));
+  }
+  return read(b._fb);
 }
 const ERROR_SIGNAL = { ownedWrite: true, _noSnapshot: true };
 /**
@@ -8800,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
@@ -9048,6 +9827,7 @@ export {
   affects,
   configureClientErrors,
   createContext,
+  createDeferred,
   createEffect,
   createErrorBoundary,
   createLoadingBoundary,
@@ -9093,6 +9873,9 @@ export {
   resolvedTable,
   runWithOwner,
   setContext,
+  setReadWatch,
+  setSignalIdentities,
+  signalName,
   snapshot,
   sourceGet,
   sourceHas,
@@ -9101,6 +9884,7 @@ export {
   storeHasFamily,
   storeHasOptimisticFamily,
   storeIsShallow,
+  storeName,
   storePath,
   until,
   untrack,