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

package/dist/dev.js

@@ -1,167 +1,230 @@
 import {
   C as CONFIG_GUESS,
-  s as schedule,
   N as NOT_PENDING,
-  a as CONFIG_OVERRIDE,
+  a as NotReadyError,
+  b as CONFIG_AUTHORITATIVE,
+  e as enqueueSub,
+  c as CONFIG_OVERRIDE,
+  s as schedule,
   q as question,
   n as nextQuestion,
+  i as installLaneHooks,
   G as GlobalQueue,
-  R as REACTIVE_DISPOSED,
-  b as CONFIG_VERDICT,
-  c as REACTIVE_PROBE_UNANSWERED,
-  d as blocked,
-  e as REACTIVE_LANE_DIRTY,
-  f as enqueueSub,
   r as resolveTx,
-  g as CONFIG_AUTHORITATIVE,
-  t as txOf,
-  h as tracking,
-  i as CONFIG_CHILDREN_FORBIDDEN,
-  p as passLane,
-  S as STATUS_PENDING,
-  E as EFFECT_RENDER,
-  j as sameLane,
+  d as newTransaction,
+  o as ownFlights,
+  R as REACTIVE_DISPOSED,
+  f as CONFIG_VERDICT,
+  g as REACTIVE_PROBE_UNANSWERED,
+  h as blocked,
+  j as REACTIVE_LANE_DIRTY,
   k as CONFIG_HELD,
-  l as flushTransaction,
-  m as STATUS_UNINITIALIZED,
-  o as NotReadyError,
-  u as REACTIVE_SCREEN_READ,
-  v as REACTIVE_FRAME_READ,
-  w as REACTIVE_LANE_READ,
-  x as ext,
-  y as REACTIVE_RECOMPUTING_DEPS,
-  z as queuePendingNode,
-  A as list,
-  B as clock,
-  D as insertSubs,
-  F as laneDirty,
-  H as merge$1,
-  I as newTransaction,
-  J as reruns,
-  K as CONFIG_STAGED,
-  L as releaseQueues,
-  M as ownFlights,
-  O as setPassLane,
-  P as REACTIVE_JOINED,
-  Q as REACTIVE_STAGED_READ,
-  T as stagedRead,
-  U as CONFIG_SLOT_NODE,
-  V as attrHooks,
+  t as txOf,
+  l as clock,
+  m as insertSubs,
+  p as laneDirty,
+  u as REACTIVE_LANE_READ,
+  v as ext,
+  S as STATUS_UNINITIALIZED,
+  w as REACTIVE_RECOMPUTING_DEPS,
+  x as queuePendingNode,
+  y as list,
+  z as STATUS_ERROR,
+  A as tracking,
+  B as CONFIG_CHILDREN_FORBIDDEN,
+  D as passLane,
+  E as STATUS_PENDING,
+  F as EFFECT_RENDER,
+  H as sameLane,
+  I as flushTransaction,
+  J as REACTIVE_SCREEN_READ,
+  K as REACTIVE_FRAME_READ,
+  L as attrHooks,
+  M as commitPendingNode,
+  O as REACTIVE_IN_HEAP,
+  P as REACTIVE_DIRTY,
+  Q as REACTIVE_CHECK,
+  T as CONFIG_INPUTS_PUBLISHED,
+  U as releaseQueues,
+  V as CONFIG_SLOT_NODE,
   W as holdNode,
   X as joinFuture,
-  Y as commitPendingNode,
-  Z as REACTIVE_IN_HEAP,
-  _ as REACTIVE_DIRTY,
-  $ as REACTIVE_CHECK,
-  a0 as CONFIG_INPUTS_PUBLISHED,
-  a1 as setVerdict,
-  a2 as context,
-  a3 as REACTIVE_PROBED,
-  a4 as bornInto,
-  a5 as globalQueue,
-  a6 as staleReader,
+  Y as reruns,
+  Z as CONFIG_STAGED,
+  _ as merge$1,
+  $ as setPassLane,
+  a0 as REACTIVE_JOINED,
+  a1 as REACTIVE_STAGED_READ,
+  a2 as stagedRead,
+  a3 as setVerdict,
+  a4 as context,
+  a5 as installVerdictHooks,
+  a6 as REACTIVE_PROBED,
   a7 as verdict,
   a8 as link,
   a9 as pullComputed,
   aa as strictRead,
   ab as warnStrictReadUntracked,
-  ac as joinPass,
-  ad as markLateLinker,
-  ae as spectating,
-  af as STATUS_ERROR,
-  ag as unflushedValue,
-  ah as stagedReaders,
-  ai as enterAction,
-  aj as setEffectCallback,
-  ak as exitAction,
-  al as isThenable,
-  am as actionDepth,
-  an as flush,
-  ao as setQuestion,
-  ap as emitDiagnostic,
-  aq as enterCallback,
-  ar as exitCallback,
-  as as getOwner,
-  at as inEffectCallback,
-  au as signal,
-  av as setSignal,
-  aw as cleanup,
-  ax as read,
-  ay as NoOwnerError,
-  az as ContextNotFoundError,
-  aA as createEffectNode,
-  aB as recompute,
-  aC as EFFECT_USER,
-  aD as reportDiagnostic,
-  aE as computed,
-  aF as staleValues,
-  aG as CONFIG_AUTO_DISPOSE,
-  aH as EFFECT_TRACKED,
-  aI as unwrapStatusError,
-  aJ as haltReactivity,
-  aK as setStrictRead,
-  aL as StatusError,
-  aM as trimStaleDeps,
-  aN as setTrackedQueueCallback,
-  aO as setEffectStatusNotify,
-  aP as _hitUnhandledAsync,
-  aQ as resetUnhandledAsync,
-  aR as ROOT_ERROR_HOOK,
-  aS as registerGraph,
-  aT as runWithOwner,
-  aU as setMemo,
-  aV as $REFRESH,
-  aW as markRefresh,
-  aX as createRoot,
-  aY as getObserver,
-  aZ as dispose,
-  a_ as TimeoutError,
-  a$ as untrack,
-  b0 as dirtyQueue,
-  b1 as CONFIG_REDERIVE,
-  b2 as passTx,
-  b3 as CONFIG_FRESH_READ,
-  b4 as createOwner,
-  b5 as REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE,
-  b6 as ownedScopeWriteMessage,
-  b7 as DEV$1,
-  b8 as isEqual,
-  b9 as CONFIG_MANUAL_WRITE,
-  ba as snapshotCaptureActive,
-  bb as captureWriteSnapshot,
-  bc as notePromotedWrite,
-  bd as slotSignal,
-  be as stagedScreen,
-  bf as CONFIG_PROMOTED,
-  bg as setSlotUnobserved,
-  bh as joinPassTx,
-  bi as asyncTailFlights,
-  bj as untrackDepth,
-  bk as checkPostAwaitRead,
-  bl as insertIntoHeap,
-  bm as isDisposed,
-  bn as handleAsync,
-  bo as addPendingSource,
-  bp as propagateStatus,
-  bq as forEachDependent,
-  br as settlePendingSource,
-  bs as notifyEpoch,
-  bt as SUPPORTS_PROXY,
-  bu as REACTIVE_ZOMBIE,
-  bv as OBSERVE$1
+  ac as staleReader,
+  ad as globalQueue,
+  ae as joinPass,
+  af as markLateLinker,
+  ag as spectating,
+  ah as unflushedValue,
+  ai as CONFIG_STAGED_ERROR,
+  aj as stagedReaders,
+  ak as bornInto,
+  al as enterAction,
+  am as setEffectCallback,
+  an as exitAction,
+  ao as isThenable,
+  ap as actionDepth,
+  aq as flush,
+  ar as setQuestion,
+  as as emitDiagnostic,
+  at as enterCallback,
+  au as exitCallback,
+  av as getOwner,
+  aw as inEffectCallback,
+  ax as setExternalHooks,
+  ay as signal,
+  az as setSignal,
+  aA as cleanup,
+  aB as read,
+  aC as DEV$1,
+  aD as CONFIG_TRANSPARENT,
+  aE as NoOwnerError,
+  aF as ContextNotFoundError,
+  aG as createEffectNode,
+  aH as recompute,
+  aI as EFFECT_USER,
+  aJ as reportDiagnostic,
+  aK as computed,
+  aL as staleValues,
+  aM as CONFIG_AUTO_DISPOSE,
+  aN as EFFECT_TRACKED,
+  aO as heldRunHook,
+  aP as unwrapStatusError,
+  aQ as haltReactivityAt,
+  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 joinPassAt,
+  bC as notifyEpoch,
+  bD as SUPPORTS_PROXY,
+  bE as releaseMarksHook,
+  bF as installMarkHooks,
+  bG as CONFIG_LAGS,
+  bH as REACTIVE_REASK,
+  bI as haltReactivity,
+  bJ as heldUnder,
+  bK as unhold,
+  bL as laneStageHook,
+  bM as REACTIVE_ZOMBIE,
+  bN as installBoundaryHooks,
+  bO as CAUGHT_REARMED,
+  bP as OBSERVE$1
 } from "./dev-shared.js";
 export {
-  bw as clearSnapshots,
-  bx as enforceLoadingBoundary,
-  by as getNextChildId,
-  bz as markSnapshotScope,
-  bA as peekNextChildId,
-  bB as releaseSnapshotScope,
-  bC as resetErrorHalt,
-  bD as setConsoleFooter,
-  bE as setSnapshotCapture
+  bQ as clearSnapshots,
+  bR as enforceLoadingBoundary,
+  bS as getNextChildId,
+  bT as markSnapshotScope,
+  bU as peekNextChildId,
+  bV as releaseSnapshotScope,
+  bW as resetErrorHalt,
+  bX as setConsoleFooter,
+  bY as setSnapshotCapture,
+  bZ as setWriteHook
 } from "./dev-shared.js";
 
+// Truth reads (`until`, `refresh`; CONFIG_AUTHORITATIVE) over lane nodes.
+// Side-effect free and apart from lanes.ts so a truth reader alone does not
+// retain the lane engine: its reads reach these only through `laneRead`,
+// which exists once something installs lanes (`createOptimistic`, verdicts).
+/** A lane node's current value: its guess, or the latest it derived — the
+ * staging a shown lane holds for its next reveal, else its slot; the
+ * committed value while it has none (its first lane pass in flight). */
+function laneValueOf(el) {
+  if (!(el._config & CONFIG_GUESS) && el._pendingValue !== NOT_PENDING) return el._pendingValue;
+  const v = el._x._lane;
+  return v !== NOT_PENDING ? v : el._value;
+}
+/** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
+ * the first one installs these on GlobalQueue (signals.ts `watch`).
+ *
+ * A truth reader's read of a lane node: the lane's value when it is the
+ * truth (#3943), else the truth staged beneath a guess, else the committed
+ * value. */
+function truthRead(el) {
+  if (truth(el)) return laneValueOf(el);
+  if (!(el._config & CONFIG_GUESS)) throw new NotReadyError(null);
+  return el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value;
+}
+/** A guess confirmed: its lane's truth readers re-read — of the lane's
+ * derivations too, which may be the truth now (#3943). */
+function truthConfirmed(l) {
+  for (let i = 0; i < l._nodes.length; i++)
+    for (let s = l._nodes[i]._subs; s !== null; s = s._nextSub)
+      if (s._sub._config & CONFIG_AUTHORITATIVE) enqueueSub(s._sub);
+}
+/** A lane node's value is the truth when every guess beneath it is
+ * confirmed — its source staged a value equal to the guess — and nothing
+ * beneath it is held in the parent: same inputs, same value. */
+function truth(n) {
+  if (n._config & CONFIG_GUESS)
+    return n._pendingValue !== NOT_PENDING && n._equals && n._equals(n._x._lane, n._pendingValue);
+  if (n._pendingValue !== NOT_PENDING) return;
+  if (n._config & CONFIG_OVERRIDE)
+    for (let d = n._deps; d; d = d._nextDep) if (!truth(d._dep)) return;
+  return 1;
+}
+
 // Lanes (plan sec. 28 replay, 2026-10-02; maintainer rulings 2026-10-01/02). A lane
 // is "a new base of a transition": the sub-frame an optimistic write opens
 // in the transition of the frame it is made in. It sees the screen plus its
@@ -201,14 +264,6 @@ function newLane(parent) {
   lanes.push(l);
   return l;
 }
-/** A lane node's current value: its guess, or the latest it derived — the
- * staging a shown lane holds for its next reveal, else its slot; the
- * committed value while it has none (its first lane pass in flight). */
-function laneValueOf(el) {
-  if (!(el._config & CONFIG_GUESS) && el._pendingValue !== NOT_PENDING) return el._pendingValue;
-  const v = el._x._lane;
-  return v !== NOT_PENDING ? v : el._value;
-}
 /** What the screen shows for a lane's node: the lane's value once the lane
  * has revealed, the committed truth before. */
 function display(el) {
@@ -273,23 +328,28 @@ function applyGuesses(parent) {
     const n = pendingGuesses[i];
     const v = pendingGuesses[i + 1];
     let changed = true;
+    // The frame already holding the slot: a guess over it is a second
+    // suggestion for the slot, and two cannot finish apart (A34 (1)) — the
+    // frames entangle.
+    let holder = null;
     if (n._config & CONFIG_OVERRIDE) {
       // A lane's node already: a guess re-asked, or a derivation guessed
-      // over (its staging is void — the guess is the value now). Two
-      // suggestions for one slot cannot finish apart (A34 (1)): the frames
-      // entangle. The same value re-asked renews the question; nothing to
-      // notify.
+      // over (its staging is void — the guess is the value now). The same
+      // value re-asked renews the question; nothing to notify.
       changed = !n._equals || !n._equals(laneValueOf(n), v);
       if (!(n._config & CONFIG_GUESS)) {
         n._pendingValue = NOT_PENDING;
         n._config |= CONFIG_GUESS;
       }
       n._x._lane = v;
-      const holder = txOf(n)._parent;
-      if (parent !== null && holder !== null) merge$1(parent, holder);
+      holder = txOf(n)._parent;
     } else {
       let l;
-      if (n._config & CONFIG_HELD) l = newLane(txOf(n));
+      // A held node: a truth staged there, or what a corrected guess showed.
+      // The guess composes on it, so it ends with that hold — and with its
+      // own frame's (F-11): it lands only when both have (the board's rapid
+      // adds — a later add's row reverted with an earlier add's landing).
+      if (n._config & CONFIG_HELD) l = newLane((holder = txOf(n)));
       else {
         if (parent === null && inFlight$1(n)) parent = newTransaction(false);
         if (parent === null) continue;
@@ -305,6 +365,7 @@ function applyGuesses(parent) {
       n._config |= CONFIG_OVERRIDE | CONFIG_GUESS;
       list(n, l);
     }
+    if (parent !== null && holder !== null) merge$1(parent, holder);
     ext(n)._q = pendingGuesses[i + 2];
     if (changed) {
       // The lane's members re-derive as its work (REACTIVE_LANE_DIRTY): a
@@ -504,37 +565,6 @@ function supersede(n, value, changed) {
   n._pendingValue = value;
   joinFuture(parent);
 }
-/** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
- * the first one installs these on GlobalQueue (signals.ts `watch`).
- *
- * A truth reader's read of a lane node: the lane's value when it is the
- * truth (#3943), else the truth staged beneath a guess, else the committed
- * value. */
-function truthRead(el) {
-  return truth(el)
-    ? laneValueOf(el)
-    : el._config & CONFIG_GUESS && el._pendingValue !== NOT_PENDING
-      ? el._pendingValue
-      : el._value;
-}
-/** A guess confirmed: its lane's truth readers re-read — of the lane's
- * derivations too, which may be the truth now (#3943). */
-function truthConfirmed(l) {
-  for (let i = 0; i < l._nodes.length; i++)
-    for (let s = l._nodes[i]._subs; s !== null; s = s._nextSub)
-      if (s._sub._config & CONFIG_AUTHORITATIVE) enqueueSub(s._sub);
-}
-/** A lane node's value is the truth when every guess beneath it is
- * confirmed — its source staged a value equal to the guess — and nothing
- * beneath it is held in the parent: same inputs, same value. */
-function truth(n) {
-  if (n._config & CONFIG_GUESS)
-    return n._pendingValue !== NOT_PENDING && n._equals && n._equals(n._x._lane, n._pendingValue);
-  if (n._pendingValue !== NOT_PENDING) return;
-  if (n._config & CONFIG_OVERRIDE)
-    for (let d = n._deps; d; d = d._nextDep) if (!truth(d._dep)) return;
-  return 1;
-}
 /** A lane's end, two ways. `into === null`: the parent landed — the lane's
  * values are the truth now: a guess lands the truth staged beneath it or
  * reverts to the one it covered (`_value`, untouched by the guess); a
@@ -668,10 +698,21 @@ 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 GlobalQueue._truth(el);
-  if (c === null) return laneValueOf(el);
   const l = txOf(el);
+  // A lane a correction folded under (D-34): store/optimistic.ts reads it.
+  // Before the authoritative arm: an `until` outside the lane reads the
+  // same truth there, and joins the hold it folded into — its posture over
+  // a foreign hold (D-31), which the truth read alone would not take.
+  const folded = c !== null && l.folded;
+  if (folded) {
+    const v = folded(c, el);
+    if (v !== NOT_PENDING) return v;
+  }
+  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);
   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
@@ -839,10 +880,12 @@ function laneWrite(el, v) {
     // question is the one being asked (`question`: a slice's, a derive's
     // continuation's — the flight's); unstamped writes and mainline are
     // current.
-    if (stale(el, question)) {
+    // A store re-bases a keyed arrangement guess over an older truth, and
+    // folds a current one beneath it (D-34): true.
+    const older = stale(el, question);
+    if (GlobalQueue._laneRebase?.(el, v, older) || older) {
       el._pendingValue = v;
       el._config |= CONFIG_HELD;
-      GlobalQueue._laneRebase?.(el, v);
       schedule();
       return v;
     }
@@ -898,20 +941,16 @@ function answered(el) {
   }
   return q;
 }
-GlobalQueue._laneRead = laneRead;
-GlobalQueue._laneStage = laneStage;
-GlobalQueue._laneOutcome = laneOutcome;
-GlobalQueue._laneWrite = laneWrite;
 /** The lanes alive before this seam's guesses opened theirs (a prefix of
  * `lanes`; nothing dissolves one between here and the seam loop): a lane
  * born at the seam has no work to judge yet (its passes run next round) —
  * it is neither shown nor blocked until it has. */
 let judged = 0;
-GlobalQueue._applyGuesses = parent => {
+const applyGuessesAt = parent => {
   judged = lanes.length;
   if (pendingGuesses.length !== 0) applyGuesses(parent);
 };
-GlobalQueue._laneSeams = leaks => {
+const laneSeams = leaks => {
   // Passes that read a write the parked frame holds as the screen
   // (`stagedReaders`: lane work, a verdict reader before the verdict): they
   // re-derive on the committed world next round (and register as stale
@@ -949,8 +988,17 @@ GlobalQueue._laneSeams = leaks => {
   for (let k = Math.min(judged, lanes.length) - 1; k >= 0; k--)
     laneSeam(lanes[k], leaked.indexOf(lanes[k]) !== -1);
 };
-GlobalQueue._laneCorrections = () => lanes.length !== 0 && laneCorrections();
-GlobalQueue._endLanes = endLanes;
+installLaneHooks(
+  laneRead,
+  laneStage,
+  laneOutcome,
+  laneWrite,
+  applyGuessesAt,
+  laneSeams,
+  () => lanes.length !== 0 && laneCorrections(),
+  endLanes,
+  lanesBlocked
+);
 GlobalQueue._laneGuesses = t => {
   const out = [];
   for (let i = 0; i < lanes.length; i++) {
@@ -962,7 +1010,6 @@ GlobalQueue._laneGuesses = t => {
   }
   return out;
 };
-GlobalQueue._lanesBlocked = lanesBlocked;
 GlobalQueue._verdictLane = verdictLane;
 
 // Verdicts (plan sec. 28 replay, 2026-10-02; maintainer, 2026-10-01: verdicts are
@@ -1116,7 +1163,7 @@ function heldNotFinal(owner) {
     !latestActive &&
     !owner._x._reask &&
     !(owner._statusFlags & STATUS_UNINITIALIZED) &&
-    (!owner._equals || !owner._equals(owner._value, owner._pendingValue))
+    (!!owner._x._shownError || !owner._equals || !owner._equals(owner._value, owner._pendingValue))
   );
 }
 /** `isPending`'s answer for an unheld node whose flight is up (cause ii). */
@@ -1160,6 +1207,38 @@ function latest(fn) {
     setVerdict(prevVerdict);
   }
 }
+/**
+ * Reports whether what `fn` reads is still waiting on an update. Read the
+ * values in question inside `fn`: the probe answers `true` while any of
+ * them depends on a change that is in flight — a write or an async source
+ * that has started producing a new value whose result has not landed yet —
+ * and `false` once the latest value is the one on screen. The answer is
+ * tracked like any read, so a memo or effect that calls `isPending` re-runs
+ * when it flips.
+ *
+ * A read that has no value yet is loading, not pending: inside `fn` it
+ * follows the surrounding `Loading` path like any other read, and the probe
+ * reports only updates to a value that already exists. A bare `refresh()`
+ * does not flip `isPending`; pair it with `affects()` to make the re-ask
+ * visible.
+ *
+ * @param fn expression to probe; read the values in question inside it
+ *
+ * @returns `true` while a read inside `fn` depends on a change that has not committed yet
+ *
+ * @example
+ * ```ts
+ * const [query, setQuery] = createSignal("");
+ * const results = createMemo(() => searchProducts(query()));
+ * const stale = createMemo(() => isPending(results));
+ *
+ * setQuery("shoes");
+ * // stale() is true until the new results land, while results() keeps
+ * // serving the previous list — dim it instead of showing a spinner.
+ * ```
+ *
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/is-pending
+ */
 function isPending(fn) {
   markVerdictReader(1);
   const prevProbing = probing;
@@ -1186,12 +1265,17 @@ function isPending(fn) {
     setVerdict(prevVerdict);
   }
 }
+/** The staging, or the staged error thrown (D-41). */
+function staged(el) {
+  if (el._config & CONFIG_STAGED_ERROR) throw el._pendingValue;
+  return el._pendingValue;
+}
 /** `latest()` of a held node: the flushed staging — the proposal — and, for
  * a tracked reader of a rewrite not yet flushed, the late-linker re-run in
  * the flush that carries it. */
 function heldLatest(el, c) {
   const u = unflushedValue(el);
-  if (u === NOT_PENDING) return el._pendingValue;
+  if (u === NOT_PENDING) return staged(el);
   if (c !== null) markLateLinker(c);
   return u;
 }
@@ -1239,7 +1323,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);
@@ -1251,6 +1338,9 @@ function verdictValue(el, c) {
             (!el._equals || !el._equals(el._x._lane, el._pendingValue))))
       )
         probeFound = true;
+      // A lane a correction folded under (D-34): `latest()` shows the hold's
+      // world whole — the truth beneath each guess, else what it covered.
+      if (latestActive && l.folded) return l.folded(null, el);
       return el._x._lane;
     }
     if (probing && flying) probeFound = true;
@@ -1304,7 +1394,7 @@ function verdictValue(el, c) {
     // has not shown content) and answers for the commit, where it is final.
     if (el._pendingValue !== NOT_PENDING && !(owner._statusFlags & STATUS_PENDING)) {
       if (probing && owned) joinPass(c, el);
-      return el._pendingValue;
+      return staged(el);
     }
   } else if (el._pendingValue !== NOT_PENDING) {
     if (owner._statusFlags & STATUS_PENDING && !uninitialized)
@@ -1321,7 +1411,7 @@ function verdictValue(el, c) {
       // A28: an unflushed write is not what `latest` serves; a tracked
       // reader derived from the flushed world runs again in the carrying
       // flush.
-      if (globalQueue._running) return el._pendingValue;
+      if (globalQueue._running) return staged(el);
       if (c !== null) markLateLinker(c);
     }
     return el._value;
@@ -1343,7 +1433,7 @@ function verdictValue(el, c) {
 // Installed at module evaluation — present exactly when something imports
 // `latest` or `isPending`. (`read` dispatches to `verdictValue` through
 // `verdict`, set while a window is open.)
-GlobalQueue._observeFlight = observeFlight;
+installVerdictHooks(observeFlight);
 /** A store read inside an untracked `isPending` probe found a live mark on
  * a record with no node to carry it (store/affects.ts): not final. */
 GlobalQueue._witnessMark = () => {
@@ -1589,7 +1679,7 @@ let externalSourceConfig = null;
  * ```
  */
 // Wires a freshly created computed through the active external-source bridge.
-// Lives here (installed on GlobalQueue while a config is active) rather than
+// Lives here (installed as a scheduler hook while a config is active) rather than
 // inline in core: esbuild cannot literal-track the mutable config binding the
 // way rollup does, so an inline `if (externalSourceConfig)` block ships in
 // every bundle even though only enableExternalSource() can make it reachable.
@@ -1611,8 +1701,8 @@ function externalUntrack(fn) {
 // removed on reset) so core's presence checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-  GlobalQueue._wireExternalSource = externalSourceConfig ? wireExternalSource : undefined;
-  GlobalQueue._externalUntrack = externalSourceConfig ? externalUntrack : undefined;
+  if (externalSourceConfig) setExternalHooks(wireExternalSource, externalUntrack);
+  else setExternalHooks(undefined, undefined);
 }
 function enableExternalSource(config) {
   const { factory, untrack: untrackFn = fn => fn() } = config;
@@ -1638,6 +1728,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
@@ -1647,6 +1792,10 @@ function enableExternalSource(config) {
  * via a `setContext` call.
  */
 function createContext(defaultValue, description) {
+  // Dev: an explicit `undefined` default is still no default (`undefined`
+  // means "not provided"); remembered so a failed read can say so (#4181).
+  if (arguments.length && defaultValue === undefined)
+    return { id: Symbol(description), defaultValue, _undefinedDefault: true };
   return { id: Symbol(description), defaultValue };
 }
 /**
@@ -1667,7 +1816,9 @@ function getContext(context, owner = getOwner()) {
   let value = owner._context[context.id];
   if (value === undefined) value = context.defaultValue;
   if (value === undefined) {
-    throw new ContextNotFoundError();
+    // Dev names the context and why it has no value: no provider, or a
+    // provider that passed `undefined` (the key is set, to `undefined`).
+    throw new ContextNotFoundError(context, context.id in owner._context);
   }
   return value;
 }
@@ -1757,7 +1908,12 @@ function notifyEffectStatus(status, error) {
       return;
     }
     if (!globalQueue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-      haltReactivity(unwrapStatusError(actualError));
+      // Dev locates the halt at the node that threw: the StatusError's
+      // source, upstream of this effect when a computed failed.
+      haltReactivityAt(
+        unwrapStatusError(actualError),
+        actualError instanceof StatusError ? actualError.source : this
+      );
       throw actualError;
     }
   } else if (this._type === EFFECT_RENDER) {
@@ -1798,7 +1954,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 +1979,7 @@ function runEffect(node, type) {
         : console.error(err);
     } catch (error) {
       if (!globalQueue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
-        haltReactivity(error);
+        haltReactivityAt(error, node);
         throw error;
       }
     }
@@ -1859,7 +2015,7 @@ function runEffect(node, type) {
     ext(node)._error = new StatusError(node, error);
     node._statusFlags |= STATUS_ERROR;
     if (!globalQueue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
-      haltReactivity(error);
+      haltReactivityAt(error, node);
       throw error;
     }
   } finally {
@@ -1893,7 +2049,7 @@ function trackedEffect(fn, options) {
     // pass, but several passes in one flush each enqueue `_run` into the same
     // user queue, and this gate is what collapses them into one run.
     if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
-    if (GlobalQueue._heldRun && GlobalQueue._heldRun(node)) return;
+    if (heldRunHook?.(node)) return;
     setTrackedQueueCallback(true);
     try {
       node._modified = false;
@@ -2024,6 +2180,155 @@ function reportClientError(error, owner, thrower) {
   }
 }
 
+/**
+ * Ownership stamp (#3360): every backing the store ALLOCATES (CoW clones,
+ * privatized committed backings) carries its owning target under this
+ * enumerable symbol. One property write replaces the two weak-collection
+ * registrations (ownership set + raw→target map) a fresh object used to pay
+ * per draft — V8's identity-hash + ephemeron cost dominated the one-key
+ * write floor. Enumerable so a spread copy (the plain-data clone path) stays
+ * on the fast path and carries the stamp along.
+ *
+ * Owned backings are never user-reachable (`snapshot` copies them, the traps
+ * hide the key), so every raw key walk in the store must skip `$OWNER`, and
+ * ownership is answered by `isOwned` — a user object never carries it.
+ * Overlay drafts (`Object.create(v)` over an owned `v`) inherit the stamp.
+ */
+const $OWNER = Symbol("STORE_OWNER");
+/** raw → target for plain (family-less) stores. Family stores use their own
+ * map so one raw can wrap once per family (§7b). */
+const storeLookup = new WeakMap();
+function setLookup(raw, t) {
+  (t.fam?.map ?? storeLookup).set(raw, t);
+}
+function isOwned(raw) {
+  return raw[$OWNER] !== undefined;
+}
+/** The target wrapping `raw` in `fam` (or the plain lookup). An owned raw
+ * answers from its stamp; a user raw from the map. */
+function lookupTarget(raw, fam) {
+  const owner = raw[$OWNER];
+  return owner !== undefined && owner.fam === fam ? owner : (fam?.map ?? storeLookup).get(raw);
+}
+function devAssertNeverUserMutation(target) {
+  return;
+}
+/** Sticky descendants flag up the parent chain (§6d): adoption descends
+ * into a changed child pair only where a target with nodes exists below. */
+function markDescendants(target) {
+  let t = target;
+  while (t && !t.d) {
+    t.d = true;
+    t = t.u;
+  }
+}
+/** Observe tier: the owner in scope at `createStore` (attribution names and
+ * owner paths); the `_owner` write never reaches the proxy. */
+const storeOwners = new WeakMap();
+/** Brand keys the proxy answers directly (never user data). */
+const $TRACK = Symbol("STORE_TRACK"),
+  $TARGET = Symbol("STORE_TARGET"),
+  $PROXY = Symbol("STORE_PROXY"),
+  $RECORD = Symbol("VIEW_RECORD");
+// ---------------------------------------------------------------------------
+// raw marking (R42 / RUL-12: a value is never both wrapped and raw)
+const rawValues = new WeakSet();
+let rawValuesUsed = false;
+function isRawValue(value) {
+  return rawValuesUsed && rawValues.has(value);
+}
+/** Mark a value so no store ever wraps it (sticky; it reads as a leaf). */
+function markRaw(value) {
+  if (isWrappable(value)) {
+    rawValuesUsed = true;
+    rawValues.add(value);
+  }
+  return value;
+}
+/** A shallow store's ingested record: raw by contract (values served
+ * verbatim, slots replaced by reference). */
+function markRawOne(v) {
+  if (isWrappable(v)) {
+    if (v[$TARGET] !== undefined) return;
+    if (lookupTarget(v, null) !== undefined)
+      throw new Error(
+        "shallow store: an ingested record is already tracked as a deep store — one value cannot present both wrapped and raw"
+      );
+    rawValuesUsed = true;
+    rawValues.add(v);
+  }
+}
+function markRawIngest(container) {
+  if (Array.isArray(container)) {
+    for (let i = 0, len = container.length; i < len; i++) markRawOne(container[i]);
+  } else {
+    for (const k in container) markRawOne(container[k]);
+  }
+}
+// ---------------------------------------------------------------------------
+// wrappability
+const OBJECT_PROTO = Object.prototype;
+const wrappableProtos = new WeakMap();
+function isWrappable(obj) {
+  if (obj == null || typeof obj !== "object" || Object.isFrozen(obj)) return false;
+  const proto = Object.getPrototypeOf(obj);
+  if (proto === OBJECT_PROTO || proto === null) return true;
+  if (Array.isArray(obj)) return true;
+  let wrappable = wrappableProtos.get(proto);
+  if (wrappable === undefined) {
+    wrappable =
+      Object.prototype.toString.call(obj) === "[object Object]" &&
+      (typeof Node === "undefined" || !(obj instanceof Node));
+    wrappableProtos.set(proto, wrappable);
+  }
+  return wrappable;
+}
+function ownEnumerableKeys(o) {
+  return Reflect.ownKeys(o).filter(k => Object.prototype.propertyIsEnumerable.call(o, k));
+}
+// ---------------------------------------------------------------------------
+// write override: a projection's draft ops carry it (the derive is the
+// author — its writes must land outside the sync setter scope too, in a
+// continuation after an `await`/`yield`). Projections return in S3; the
+// traps already honour it.
+let writeOverride = false;
+function setWriteOverride(value) {
+  writeOverride = value;
+}
+
+/**
+ * Deferred hydration, dependency edges for stores. Only the frames client
+ * imports this module, so nothing here ships without it.
+ *
+ * A plain store root (`createStore` over an object) is named like a plain
+ * signal (core/identities.ts: `<owner id>~<n>`, on the same count), and the
+ * whole store goes by that one name: the server records it for any read of
+ * the store, at any depth, and a setter call on the store — on its root or
+ * on a proxy nested in it — is a write to it. Its readers mount at the
+ * setter's entry, before the draft runs, as a plain signal's do.
+ */
+/**
+ * @internal The name of the store `x` belongs to — `x` a store proxy (a
+ * setter's entry) or one of its property nodes (the setter notifying it) —
+ * or undefined when it has none or it cannot be placed: a projection or
+ * optimistic family, a store chained over another store's proxy, a root
+ * named twice, or a proxy reached through a store other than the one it
+ * was named as the root of.
+ */
+function storeName(x) {
+  if (x === undefined) return undefined;
+  let t = x._config & CONFIG_SLOT_NODE ? x._host : x[$TARGET];
+  if (t === undefined) return undefined;
+  // Up to the root; a target on the way named as a root of its own is one
+  // object in two stores.
+  while (t.u !== null) {
+    if (t.fam !== null || t.ch || signalName(t) !== undefined) return undefined;
+    t = t.u;
+  }
+  if (t.fam !== null || t.ch) return undefined;
+  return signalName(t) || undefined;
+}
+
 /**
  * Low-level reactive-cleanup primitive. Registers a callback that runs when
  * the surrounding owner is disposed.
@@ -2112,6 +2417,7 @@ function createSignal(first, second) {
   }
   const node = signal(first, second);
   registerGraph(node, getOwner());
+  if (signalHook !== null) signalHook(node);
   return [accessor(node), setSignal.bind(null, node)];
 }
 function createOptimistic(first, second) {
@@ -2193,7 +2499,7 @@ function createMemo(compute, options) {
  * );
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-effect
  */
 function createEffect(compute, effectFn, options) {
   if (effectFn === undefined) {
@@ -2242,7 +2548,7 @@ function createEffect(compute, effectFn, options) {
  * }
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-render-effect
  */
 function createRenderEffect(compute, effectFn, options) {
   effect(compute, effectFn, undefined, options);
@@ -2290,7 +2596,7 @@ function createRenderEffect(compute, effectFn, options) {
  * });
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-tracked-effect
  */
 function createTrackedEffect(compute, options) {
   trackedEffect(compute, options);
@@ -2319,7 +2625,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;
@@ -2338,7 +2644,12 @@ function createReaction(effectFn, options) {
     }
     runWithOwner(owner, () => {
       effect(
-        () => (tracking(), (arm = getOwner())),
+        () => {
+          const node = getOwner();
+          arm = node;
+          tracking();
+          return node;
+        },
         node => {
           arm = undefined;
           cl?.();
@@ -2389,15 +2700,21 @@ function watch(fn, onValue, onError, config = 0, inPass, own = flushTransaction)
   // after: the first pass's own error is the promise's rejection.)
   computed(
     () => {
-      let v;
+      let v,
+        failed = false;
       try {
         v = fn();
       } catch (e) {
         if (e instanceof NotReadyError) throw e;
-        queueMicrotask(() => onError(unwrapStatusError(e)));
-        return;
+        // An error is an answer (D-41): delivered by the same frame rule.
+        v = unwrapStatusError(e);
+        failed = true;
       }
       const c = getOwner();
+      // A truth reader waits out a `createDeferred` flight its value derives
+      // from, which serves everyone else the stale answer (D-40).
+      const lag = config & CONFIG_AUTHORITATIVE && GlobalQueue._lagging?.(c);
+      if (lag) throw new NotReadyError(lag);
       // (Outside a flush a mainline pass joins through `passTx`.)
       const joined = flushTransaction ?? passTx;
       if (
@@ -2408,6 +2725,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));
     },
@@ -2697,192 +3015,76 @@ function until(fn, options) {
  *   onSettled(() => {
  *     const onResize = () => setWidth(window.innerWidth);
  *     window.addEventListener("resize", onResize);
- *     return () => window.removeEventListener("resize", onResize);
- *   });
- *   return width;
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Post-settle "ready" hook — no cleanup needed.
- * function Dashboard() {
- *   const data = createMemo(async () => fetchData());
- *
- *   onSettled(() => {
- *     analytics.track("dashboard.ready");
- *   });
- *
- *   return <Loading fallback={<Spinner />}><pre>{data()}</pre></Loading>;
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Event-handler — runs after the action settles.
- * function SaveButton() {
- *   const save = action(function* () {
- *     yield api.save();
- *   });
- *
- *   const handleClick = () => {
- *     save();
- *     onSettled(() => toast("Saved!"));
- *   };
- *
- *   return <button onClick={handleClick}>Save</button>;
- * }
- * ```
- *
- * @param callback Function to run; may return a cleanup function that fires
- *   on owner disposal
- */
-function onSettled(callback) {
-  const owner = getOwner();
-  owner && !(owner._config & CONFIG_CHILDREN_FORBIDDEN)
-    ? trackedEffect(() => untrack(callback), { name: "onSettled" })
-    : globalQueue.enqueue(EFFECT_USER, function fire() {
-        // Settled means derived. A settle that reverts optimism (or replays
-        // gated reads) only enqueues the affected subscribers; the pass after
-        // the commit re-derives them. Fired in the commit pass, the callback
-        // read the optimistic source already reverted beside a sync memo of it
-        // still holding the optimistic value — reads do not pull (#3411). Fall
-        // to the next pass while the heap has work; `run` swapped the queue,
-        // so this lands there, and `enqueue` keeps the drain alive.
-        if (dirtyQueue._max >= dirtyQueue._min) return globalQueue.enqueue(EFFECT_USER, fire);
-        // Unowned, out-of-band fire (no owner, or a children-forbidden one this
-        // one-shot must not bind to): a returned cleanup has no lifecycle to
-        // attach to. Reject it in dev; in production the return is simply
-        // dropped — never bound to an unrelated owner or run eagerly.
-        const cleanup = callback();
-        if (cleanup !== undefined) {
-          const message =
-            "[SETTLED_CLEANUP_UNOWNED] onSettled returned a cleanup in an unowned scope; a cleanup can only be honored under an owner. Call your setup helper from an owned scope (e.g. the component body) instead of from inside an event handler, tracked effect, or another onSettled.";
-          emitDiagnostic({
-            code: "SETTLED_CLEANUP_UNOWNED",
-            kind: "lifecycle",
-            severity: "error",
-            message
-          });
-          throw new Error(message);
-        }
-      });
-}
-
-/**
- * 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;
+ *     return () => window.removeEventListener("resize", onResize);
+ *   });
+ *   return width;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Post-settle "ready" hook — no cleanup needed.
+ * function Dashboard() {
+ *   const data = createMemo(async () => fetchData());
+ *
+ *   onSettled(() => {
+ *     analytics.track("dashboard.ready");
+ *   });
+ *
+ *   return <Loading fallback={<Spinner />}><pre>{data()}</pre></Loading>;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Event-handler — runs after the action settles.
+ * function SaveButton() {
+ *   const save = action(function* () {
+ *     yield api.save();
+ *   });
+ *
+ *   const handleClick = () => {
+ *     save();
+ *     onSettled(() => toast("Saved!"));
+ *   };
+ *
+ *   return <button onClick={handleClick}>Save</button>;
+ * }
+ * ```
+ *
+ * @param callback Function to run; may return a cleanup function that fires
+ *   on owner disposal
+ */
+function onSettled(callback) {
+  const owner = getOwner();
+  owner && !(owner._config & CONFIG_CHILDREN_FORBIDDEN)
+    ? trackedEffect(() => untrack(callback), { name: "onSettled" })
+    : globalQueue.enqueue(EFFECT_USER, function fire() {
+        // Settled means derived. A settle that reverts optimism (or replays
+        // gated reads) only enqueues the affected subscribers; the pass after
+        // the commit re-derives them. Fired in the commit pass, the callback
+        // read the optimistic source already reverted beside a sync memo of it
+        // still holding the optimistic value — reads do not pull (#3411). Fall
+        // to the next pass while the heap has work; `run` swapped the queue,
+        // so this lands there, and `enqueue` keeps the drain alive.
+        if (dirtyQueue._max >= dirtyQueue._min) return globalQueue.enqueue(EFFECT_USER, fire);
+        // Unowned, out-of-band fire (no owner, or a children-forbidden one this
+        // one-shot must not bind to): a returned cleanup has no lifecycle to
+        // attach to. Reject it in dev; in production the return is simply
+        // dropped — never bound to an unrelated owner or run eagerly.
+        const cleanup = callback();
+        if (cleanup !== undefined) {
+          const message =
+            "[SETTLED_CLEANUP_UNOWNED] onSettled returned a cleanup in an unowned scope; a cleanup can only be honored under an owner. Call your setup helper from an owned scope (e.g. the component body) instead of from inside an event handler, tracked effect, or another onSettled.";
+          emitDiagnostic({
+            code: "SETTLED_CLEANUP_UNOWNED",
+            kind: "lifecycle",
+            severity: "error",
+            message
+          });
+          throw new Error(message);
+        }
+      });
 }
 
 function mapArray(list, map, options) {
@@ -3058,6 +3260,79 @@ function commitSmallMove(data, newItems, newLen, srcPos, dstPos, runs) {
   }
   return true;
 }
+/** Stage a PURE REMOVAL without the key map: when the new window is the old
+ * window with items dropped, in order (one-item removals, every-nth, the
+ * table filters), a two-pointer walk lands every survivor in the window
+ * stage with one key call per item and returns the leavers; a shape that is
+ * not an ordered subsequence returns null with the node stage cleared, and
+ * the map path below starts from scratch (it rewrites every window slot of
+ * `temp` / `rows` / `indexes`, so only `tempNodes`' `!== undefined` probe
+ * needs the reset). The stage arrays are scratch — nothing live is touched. */
+function stageRemoval(data, newItems, start, end, newEnd, temp, tempNodes, rows, indexes) {
+  const key = data._key;
+  const oldItems = data._items;
+  const nodes = data._nodes;
+  const removed = [];
+  let i = start;
+  for (let j = start; j <= newEnd; i++, j++) {
+    const nk = key ? key(newItems[j]) : newItems[j];
+    while (i <= end && (key ? key(oldItems[i]) : oldItems[i]) !== nk) removed.push(nodes[i++]);
+    if (i > end) {
+      tempNodes.fill(undefined);
+      return null;
+    }
+    temp[j] = data._mappings[i];
+    tempNodes[j - start] = nodes[i];
+    if (rows) rows[j - start] = data._rows[i];
+    if (indexes) indexes[j - start] = data._indexes[i];
+  }
+  for (; i <= end; i++) removed.push(nodes[i]);
+  return removed;
+}
+/** Land a staged window into the live bookkeeping arrays in place: shift the
+ * suffix by `dif` (a loop walked from the side that never overwrites an
+ * unread slot), take the window from the stage, write survivors' row and
+ * index signals. Its own function so the general path's body stays under
+ * the JIT's optimization budget — the inlined commit measured ~10% slower on
+ * full-window reorders (the small-move note has the same finding). */
+function commitWindow(data, newItems, newLen, start, end, newEnd, tempNodes, rows, indexes) {
+  const nodes = data._nodes;
+  const liveRows = data._rows;
+  const liveIndexes = data._indexes;
+  const oldLen = data._len;
+  const dif = newLen - oldLen;
+  let i, j;
+  if (dif > 0) {
+    // Grow first: a store past the end from the top is a third slower than
+    // filling a pre-sized tail (measured on 1k refs, 2026-10-15).
+    nodes.length = newLen;
+    if (liveRows) liveRows.length = newLen;
+    if (liveIndexes) liveIndexes.length = newLen;
+    for (i = oldLen - 1, j = newLen - 1; i > end; i--, j--) {
+      nodes[j] = nodes[i];
+      if (liveRows) liveRows[j] = liveRows[i];
+      if (liveIndexes) liveIndexes[j] = liveIndexes[i];
+    }
+  } else if (dif < 0) {
+    for (i = end + 1, j = newEnd + 1; i < oldLen; i++, j++) {
+      nodes[j] = nodes[i];
+      if (liveRows) liveRows[j] = liveRows[i];
+      if (liveIndexes) liveIndexes[j] = liveIndexes[i];
+    }
+    nodes.length = newLen;
+    if (liveRows) liveRows.length = newLen;
+    if (liveIndexes) liveIndexes.length = newLen;
+  }
+  for (j = start; j <= newEnd; j++) {
+    nodes[j] = tempNodes[j - start];
+    if (liveRows) setSignal((liveRows[j] = rows[j - start]), newItems[j]);
+    if (liveIndexes) setSignal((liveIndexes[j] = indexes[j - start]), j);
+  }
+  for (j = newEnd + 1; j < newLen; j++) {
+    if (liveRows) setSignal(liveRows[j], newItems[j]);
+    if (liveIndexes && dif !== 0) setSignal(liveIndexes[j], j);
+  }
+}
 function updateKeyedMap() {
   // Untracked reads inside the internal owner resolve via _parentComputed:
   // routed through the node, a store-proxy lookup sees pending writes (not a
@@ -3072,6 +3347,10 @@ function updateKeyedMap() {
   runWithOwner(this._owner, () => {
     let i,
       j,
+      // The stage slot a mapper writes its row/index signal into: `j` on the
+      // create-all path, `j - start` on the general path, whose stage arrays
+      // are sized to the changed WINDOW, not the list.
+      slot,
       rows,
       indexes,
       // Mappers write freshly-created row/index signals into the STAGE
@@ -3079,19 +3358,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];
@@ -3108,7 +3387,7 @@ function updateKeyedMap() {
         this._rows && (this._rows = []);
         this._indexes && (this._indexes = []);
       }
-      if (this._fallback && !this._mappings[0]) {
+      if (this._fallback && !this._mappings.length) {
         // an aborted fallback attempt leaves an owner without a mapping;
         // dispose it before re-creating
         this._nodes[0]?.dispose();
@@ -3122,7 +3401,10 @@ function updateKeyedMap() {
       rows = this._rows && new Array(newLen);
       indexes = this._indexes && new Array(newLen);
       try {
-        for (j = 0; j < newLen; j++) mappings[j] = runWithOwner((nodes[j] = createOwner()), mapper);
+        for (j = 0; j < newLen; j++) {
+          slot = j;
+          mappings[j] = runWithOwner((nodes[j] = createOwner()), mapper);
+        }
       } catch (err) {
         for (i = 0; i <= j; i++) nodes[i]?.dispose();
         throw err;
@@ -3224,81 +3506,89 @@ function updateKeyedMap() {
         if (k <= hi && trySmallMove(this, newItems, newLen, start)) return;
       }
       const dif = newLen - this._len;
+      // WINDOW-SIZED STAGING, IN-PLACE COMMIT (2026-10-15). The strong-abort
+      // contract (#2903) only needs the pass to touch nothing live before
+      // every mapper has succeeded; it never needed four fresh newLen-sized
+      // arrays. Only the changed window [start, newEnd] is staged — the
+      // prefix and suffix are, by construction, the rows that did not move
+      // relative to each other — and at commit the bookkeeping arrays
+      // (`_nodes`, `_rows`, `_indexes`) take the window in place with the
+      // suffix shifted by a plain loop (`copyWithin` is a generic
+      // per-element builtin in V8 — 30× slower than the loop on 1k refs,
+      // measured 2026-10-15). `_mappings` alone is
+      // rebuilt: its fresh identity is the change signal downstream relies
+      // on. A one-row edit on a 500-row list used to allocate ~20 KB of
+      // staging plus a position-sized chain array per commit (uibench's
+      // one-item tree ops at 4–6× Octane, jfb-reorder `removefirst` at
+      // 2.5×); now it stages one slot.
+      const wLen = newEnd - start + 1;
       const temp = new Array(newLen);
-      const tempNodes = new Array(newLen);
-      rows = this._rows ? new Array(newLen) : undefined;
-      indexes = this._indexes ? new Array(newLen) : undefined;
-      // 0) prepare a map of all indices in the changed window of newItems,
-      // scanning backwards so we encounter them in natural order
-      newIndices = new Map();
-      newIndicesNext = new Array(newEnd + 1);
-      for (j = newEnd; j >= start; j--) {
-        item = newItems[j];
-        key = this._key ? this._key(item) : item;
-        i = newIndices.get(key);
-        newIndicesNext[j] = i === undefined ? -1 : i;
-        newIndices.set(key, j);
-      }
-      // 1) step through the old changed window and see if items can be found
-      // in the new set; if so, stage them at their new positions; if not,
-      // queue them for disposal at commit
-      for (i = start; i <= end; i++) {
-        item = this._items[i];
-        key = this._key ? this._key(item) : item;
-        j = newIndices.get(key);
-        if (j !== undefined && j !== -1) {
-          temp[j] = this._mappings[i];
-          tempNodes[j] = this._nodes[i];
-          rows && (rows[j] = this._rows[i]);
-          indexes && (indexes[j] = this._indexes[i]);
-          j = newIndicesNext[j];
+      const tempNodes = new Array(wLen);
+      rows = this._rows ? new Array(wLen) : undefined;
+      indexes = this._indexes ? new Array(wLen) : undefined;
+      // A shrinking pass is tried as a pure removal first (stageRemoval: no
+      // key map, one key call per item); anything else takes the map path.
+      const pure =
+        dif < 0
+          ? stageRemoval(this, newItems, start, end, newEnd, temp, tempNodes, rows, indexes)
+          : null;
+      if (pure !== null) {
+        // (The list-churn census below wants removals AND creations in one
+        // pass; a pure removal has none, so no item ledger is kept here.)
+        if (pure.length !== 0) removed = pure;
+      } else {
+        // 0) prepare a map of all indices in the changed window of newItems,
+        // scanning backwards so we encounter them in natural order
+        newIndices = new Map();
+        newIndicesNext = new Array(wLen);
+        for (j = newEnd; j >= start; j--) {
+          item = newItems[j];
+          key = this._key ? this._key(item) : item;
+          i = newIndices.get(key);
+          newIndicesNext[j - start] = i === undefined ? -1 : i;
           newIndices.set(key, j);
-        } else {
-          (removed ??= []).push(this._nodes[i]);
-          if (true && attrHooks !== null) (removedItems ??= []).push(item);
-        }
-      }
-      // 2) create new rows into the temp arrays; an abort disposes only these
-      try {
-        for (j = start; j <= newEnd; j++) {
-          if (tempNodes[j] !== undefined) continue;
-          (created ??= []).push((tempNodes[j] = createOwner()));
-          if (true && attrHooks !== null) (createdItems ??= []).push(newItems[j]);
-          temp[j] = runWithOwner(tempNodes[j], mapper);
         }
-      } catch (err) {
-        if (created) for (i = 0; i < created.length; i++) created[i].dispose();
-        throw err;
-      }
-      // 3) commit: land the retained prefix and suffix plus the staged window
-      // into the fresh arrays, swap them in (new identity for downstream
-      // change propagation), then dispose exited rows
-      for (i = 0; i < start; i++) {
-        temp[i] = this._mappings[i];
-        tempNodes[i] = this._nodes[i];
-        rows && (rows[i] = this._rows[i]);
-        indexes && (indexes[i] = this._indexes[i]);
-      }
-      for (j = start; j <= newEnd; j++) {
-        if (rows) write(rows[j], newItems[j]);
-        if (indexes) write(indexes[j], j);
-      }
-      for (j = newEnd + 1; j < newLen; j++) {
-        temp[j] = this._mappings[j - dif];
-        tempNodes[j] = this._nodes[j - dif];
-        if (rows) {
-          rows[j] = this._rows[j - dif];
-          write(rows[j], newItems[j]);
+        // 1) step through the old changed window and see if items can be found
+        // in the new set; if so, stage them at their new positions; if not,
+        // queue them for disposal at commit
+        for (i = start; i <= end; i++) {
+          item = this._items[i];
+          key = this._key ? this._key(item) : item;
+          j = newIndices.get(key);
+          if (j !== undefined && j !== -1) {
+            temp[j] = this._mappings[i];
+            tempNodes[j - start] = this._nodes[i];
+            rows && (rows[j - start] = this._rows[i]);
+            indexes && (indexes[j - start] = this._indexes[i]);
+            j = newIndicesNext[j - start];
+            newIndices.set(key, j);
+          } else {
+            (removed ??= []).push(this._nodes[i]);
+            if (true && attrHooks !== null) (removedItems ??= []).push(item);
+          }
         }
-        if (indexes) {
-          indexes[j] = this._indexes[j - dif];
-          if (dif !== 0) write(indexes[j], j);
+        // 2) create new rows into the window stage; an abort disposes only these
+        try {
+          for (j = start; j <= newEnd; j++) {
+            if (tempNodes[j - start] !== undefined) continue;
+            (created ??= []).push((tempNodes[j - start] = createOwner()));
+            if (true && attrHooks !== null) (createdItems ??= []).push(newItems[j]);
+            slot = j - start;
+            temp[j] = runWithOwner(tempNodes[j - start], mapper);
+          }
+        } catch (err) {
+          if (created) for (i = 0; i < created.length; i++) created[i].dispose();
+          throw err;
         }
       }
+      // 3) commit: the retained prefix and suffix land in the fresh mapped
+      // array; the bookkeeping arrays take the staged window IN PLACE (own
+      // function: kept out of this body on purpose, see commitWindow); then
+      // the exited rows dispose
+      for (i = 0; i < start; i++) temp[i] = this._mappings[i];
+      for (j = newEnd + 1; j < newLen; j++) temp[j] = this._mappings[j - dif];
+      commitWindow(this, newItems, newLen, start, end, newEnd, tempNodes, rows, indexes);
       this._mappings = temp;
-      this._nodes = tempNodes;
-      rows && (this._rows = rows);
-      indexes && (this._indexes = indexes);
       this._len = newLen;
       // save a copy of the mapped items for the next update
       this._items = newItems.slice(0);
@@ -3328,7 +3618,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
@@ -3378,7 +3668,7 @@ function updateRepeat() {
         // Reset offset to match the cleared data (#2767, repro 2).
         this._offset = 0;
       }
-      if (this._fallback && !this._mappings[0]) {
+      if (this._fallback && !this._mappings.length) {
         // an aborted fallback attempt leaves an owner without a mapping;
         // dispose it before re-creating
         this._nodes[0]?.dispose();
@@ -3658,11 +3948,16 @@ function noteNode(target, node, key) {
 // dispatches CONFIG_SLOT_NODE nodes here (graph.ts) instead of holding a
 // per-node closure in a per-node NodeExtension. A dropped node is
 // unreachable through the store — a fresh read makes a fresh node.
+// A staged write — or a lane's value (a guess, S4) — is state only the node
+// holds: its release waits for the commit that resolves it. So does a leaf of
+// a held container (#4146): a mainline write it carried is in the held
+// staging too, where it would read as the hold's until the landing.
+const slotKept = node =>
+  node._pendingValue !== NOT_PENDING ||
+  node._config & CONFIG_OVERRIDE ||
+  node._host.k?._config & CONFIG_HELD;
 setSlotUnobserved(node => {
-  // A staged write — or a lane's value (a guess, S4) — is state only the
-  // node holds: defer the release to the commit that resolves it.
-  if (node._pendingValue !== NOT_PENDING || node._config & CONFIG_OVERRIDE)
-    deferredReleases.add(node);
+  if (slotKept(node)) deferredReleases.add(node);
   else releaseSlot(node);
 });
 /** A node born while its container has a staging is born from the two
@@ -3678,9 +3973,13 @@ function bornStaged(target, node, staged, key) {
   if (k === null) return; // a node-less staging holds nothing (`stageOn`)
   // Held by the container's transaction only for a key the HELD staging
   // changed — a mainline layer's change above it stages mainline. (A
-  // container carrying a guess is a lane's: the flush's park decides.)
-  if ((k._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && heldKeyChanged(target, key))
-    holdNode(node, txOf(k));
+  // container carrying a guess is a lane's: the flush's park decides —
+  // unless a correction folded under the guess, D-34: the key is that
+  // correction's hold's.)
+  if (k._config & CONFIG_HELD && heldKeyChanged(target, key)) {
+    const l = txOf(k);
+    if (!(k._config & CONFIG_OVERRIDE) || l.folded) holdNode(node, resolveTx(l._parent ?? l));
+  }
   // A28 (4): a batch written inside a creation-time pass is promoted — its
   // late-materialized leaf with it.
   if (k._config & CONFIG_PROMOTED) notePromotedWrite(node);
@@ -3722,7 +4021,9 @@ function getNode(
     // the hottest store path, and the disabled cost must stay one null
     // check (nodes created before enable() stay generically named).
     if (attrHooks !== null) {
-      created._name = storeLabel(target) + "." + String(key);
+      const root = storeRoot(target);
+      created._name = (storeNames.get(root) ?? "store") + "." + String(key);
+      created._loc = storeLocs.get(root);
       stampNodeOwner(created, target);
     }
     nodes[key] = node;
@@ -3775,7 +4076,7 @@ function getContainerNode(target) {
  * staging: nothing allocates, nothing is swept at the commit (dbmon's tick
  * re-created, queued, swept and dropped ~7000 container nodes). If the
  * flush parks, the seam materializes and holds the node then
- * (`_storePark`) — the one case the staging home exists for. */
+ * (`storeParkHook`) — the one case the staging home exists for. */
 function stageOn(target, pb) {
   if (
     target.k === null &&
@@ -3798,7 +4099,7 @@ function deriveHolds(target) {
   const fw = target.fam?.node;
   return fw != null && !userWrite && (fw._config & CONFIG_HELD) !== 0;
 }
-GlobalQueue._storePark = t => {
+const storePark = t => {
   for (let i = 0; i < foldList.length; i++) {
     const target = foldList[i];
     if (target.k === null && target.pb !== null) holdNode(getContainerNode(target), t);
@@ -3846,11 +4147,16 @@ function stampNodeOwner(created, target) {
   created._owner = storeRootOwner(target) ?? null;
 }
 const storeNames = new WeakMap();
-function nameStore(proxy, name) {
-  if (attrHooks !== null && name) storeNames.set(proxy[$TARGET], name);
-}
-function storeLabel(target) {
-  return storeNames.get(storeRoot(target)) ?? "store";
+// The store's `loc` option, carried onto every property node beside its
+// label (the same gate: nodes created before the engine is installed carry
+// neither).
+const storeLocs = new WeakMap();
+function nameStore(proxy, name, loc) {
+  if (attrHooks !== null) {
+    const target = proxy[$TARGET];
+    if (name) storeNames.set(target, name);
+    if (loc) storeLocs.set(target, loc);
+  }
 }
 // ---------------------------------------------------------------------------
 // clones (CoW privatization)
@@ -3934,7 +4240,8 @@ function overlayRebuilds(t, pb) {
   if (t.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
   if (t.del !== null && t.del.size !== 0) return true;
   const wk = t.wk;
-  if (wk !== null && wk !== WK_ALL && wk.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
+  if (wk !== null && wk !== WK_ALL && wk.u === undefined && wk.size <= OVERLAY_REBUILD_MIN_ADDS)
+    return false;
   const v = t.v;
   let adds = 0;
   for (const key of Reflect.ownKeys(pb))
@@ -4164,11 +4471,7 @@ function drainFolds() {
   }
   if (deferredReleases.size !== 0) {
     for (const node of deferredReleases) {
-      if (
-        node._pendingValue === NOT_PENDING &&
-        !(node._config & CONFIG_OVERRIDE) &&
-        node._subs === null
-      ) {
+      if (node._subs === null && !slotKept(node)) {
         deferredReleases.delete(node);
         releaseSlot(node);
       }
@@ -4197,10 +4500,10 @@ GlobalQueue._slotCovered = n => {
   }
   return n._value;
 };
-GlobalQueue._storeCommit = () => {
+installStoreHooks(storePark, () => {
   drainFolds();
   optHooks?.sweep();
-};
+});
 /** The store half of `affects()` (store/affects.ts) makes its marks' nodes
  * and walks records through these: it never imports the engine. */
 GlobalQueue._storeNode = getNode;
@@ -4248,10 +4551,11 @@ function foldTarget(t, old) {
           const v = t.v;
           const wk = t.wk;
           if (wk !== null && wk !== WK_ALL) {
-            for (const key of wk) {
-              if (hasOwn$1.call(pb, key)) copyOwn(v, pb, key);
-              else delete v[key];
-            }
+            for (let w = wk; w !== undefined; w = w.u)
+              for (const key of w) {
+                if (hasOwn$1.call(pb, key)) copyOwn(v, pb, key);
+                else delete v[key];
+              }
           } else {
             for (const key of Reflect.ownKeys(pb)) {
               const d = Object.getOwnPropertyDescriptor(pb, key);
@@ -4424,7 +4728,10 @@ function notifyWrites(t) {
   // value can change when ANY key is written), or a non-plain prototype
   // (class instances: prototype getters derive from arbitrary fields).
   // Overlay pbs chain to the COMMITTED object (#3044) — plainness is the
-  // committed container's prototype, not the overlay's.
+  // committed container's prototype, not the overlay's. THIS setter's keys
+  // only (D-8, #3743): a key an earlier setter of the batch wrote and this
+  // one did not is no second proposal — its node was told then, and telling
+  // a held node its unchanged value again would join this tick to the hold.
   const wk0 = t.wk;
   const writtenKeys = wk0 === WK_ALL || t.a === true || !plainProto(t.ovl ? t.v : pb) ? null : wk0;
   if (attrHooks !== null) reportReplacedContainers(t, old, pb, writtenKeys);
@@ -5084,6 +5391,63 @@ 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);
+}
+/** Dev: targets (and their keys) already warned about for a write outside
+ * the setter — #4179's once-per-target+key memory. */
+let warnedOutsideWrites;
+/** Dev: set while the runtime itself writes through a proxy it knows the
+ * trap ignores (`registerGraph`'s `_owner` stamp). */
+let internalOutsideWrite = false;
+/** Dev: a write, defineProperty or delete on a store proxy outside its
+ * setter's draft is ignored (the trap returns `true` so strict-mode code
+ * does not throw) — say so once per target+key instead of silently dropping
+ * it (#4179). */
+function warnWriteOutsideSetter(target, key, operation) {
+  if (internalOutsideWrite) return;
+  warnedOutsideWrites ??= new WeakMap();
+  let keys = warnedOutsideWrites.get(target);
+  if (keys === undefined) warnedOutsideWrites.set(target, (keys = new Set()));
+  if (keys.has(key)) return;
+  keys.add(key);
+  const name = String(key);
+  const access =
+    typeof key === "string" && /^[A-Za-z_$][\w$]*$/.test(key)
+      ? `.${key}`
+      : typeof key === "string" && /^\d+$/.test(key)
+        ? `[${key}]`
+        : `[${typeof key === "string" ? JSON.stringify(key) : name}]`;
+  const hint =
+    operation === "deleteProperty"
+      ? `setStore(s => { delete s${access} })`
+      : `setStore(s => { s${access} = value })`;
+  reportDiagnostic(
+    emitDiagnostic({
+      code: "STORE_WRITE_OUTSIDE_SETTER",
+      kind: "write",
+      severity: "warn",
+      message:
+        `[STORE_WRITE_OUTSIDE_SETTER] ${operation === "deleteProperty" ? "Deleting" : "Writing"} store property "${name}" outside its setter was ignored. ` +
+        `Stores are read-only outside the setter's draft: use \`${hint}\`.`,
+      nodeName: name,
+      data: { operation, property: name }
+    })
+  );
+}
 const traps = {
   get(target, key, receiver) {
     // One typeof gates every brand-symbol compare off the hot string path.
@@ -5327,20 +5691,30 @@ const traps = {
   set(target, key, value) {
     const draft = inDraft(target);
     const override = !draft && writeOverride;
-    if (!draft && !override) return true;
+    if (!draft && !override) {
+      warnWriteOutsideSetter(target, key, "set");
+      return true;
+    }
     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)) {
@@ -5369,14 +5743,16 @@ const traps = {
   defineProperty(target, key, desc) {
     const draft = inDraft(target);
     const override = !draft && writeOverride;
-    if (!draft && !override) return true;
+    if (!draft && !override) {
+      warnWriteOutsideSetter(target, key, "defineProperty");
+      return true;
+    }
     if (key === "__proto__") return true;
     if (desc.get || desc.set) target.a = true;
     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);
@@ -5385,12 +5761,27 @@ const traps = {
   deleteProperty(target, key) {
     const draft = inDraft(target);
     const override = !draft && writeOverride;
-    if (!draft && !override) return true;
+    if (!draft && !override) {
+      warnWriteOutsideSetter(target, key, "deleteProperty");
+      return true;
+    }
     const pb = ensurePB(target);
-    pendingNotify.add(target);
-    if (target.wk !== WK_ALL) (target.wk ??= new Set()).add(key);
-    delete pb[key];
-    if (target.ovl && hasOwn$1.call(target.v, key)) (target.del ??= new Set()).add(key);
+    touch(target, key);
+    // The key count (`kc`, the overlay gate and the rebuild cap) follows a
+    // delete the way it follows an add: an own key of the draft leaving — a
+    // clone's key, or an overlay's own add — is one fewer now. An overlay's
+    // override of a committed key is the exception: the committed key's
+    // deletion is recorded in `del` and counted at the rebuild, as before.
+    // Without the decrement the natural "delete the old key, set the new
+    // one" shape drifted the count up by one per write until a three-key
+    // object crossed the overlay threshold and paid a rebuild on every
+    // commit after.
+    const committed = target.ovl && hasOwn$1.call(target.v, key);
+    if (hasOwn$1.call(pb, key)) {
+      delete pb[key];
+      committed || target.kc--;
+    }
+    if (committed) (target.del ??= new Set()).add(key);
     if (override) notifyWrites(target);
     return true;
   }
@@ -5418,7 +5809,7 @@ const ASYNC_STORE_SETTER_MESSAGE =
  * write violation — the user guard (`mapArray`'s pattern: the node-level
  * writes carry `ownedWrite`; the setter asks). */
 function devGuardStoreSetterWrite() {
-  if (context && !(context._config & CONFIG_CHILDREN_FORBIDDEN)) {
+  if (context && !(context._config & CONFIG_CHILDREN_FORBIDDEN) && !disposalDepth) {
     emitDiagnostic({
       code: "REACTIVE_WRITE_IN_OWNED_SCOPE",
       kind: "write",
@@ -5454,6 +5845,7 @@ function devGuardStoreSetterResult(result) {
   }
 }
 function storeSetter(proxy, fn, guard = true) {
+  if (writeHook !== null) writeHook(proxy);
   if (guard) devGuardStoreSetterWrite();
   const target = proxy[$TARGET];
   const prevScopes = writeScopes;
@@ -5521,6 +5913,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);
@@ -5528,14 +5922,17 @@ function createStore$1(initialValue, options) {
   {
     const owner = getOwner();
     // Dev-tier graph registration (owner signal lists, onGraph); the
-    // `_owner` write itself never reaches the proxy, see storeOwners.
+    // `_owner` write itself never reaches the proxy, see storeOwners — an
+    // internal ignored write, not the user's (#4179's warning skips it).
+    internalOutsideWrite = true;
     registerGraph(proxy, owner);
+    internalOutsideWrite = false;
     // Only once the engine is installed, like the node stamping it feeds: a
     // WeakMap.set per fresh store is a growing ephemeron table and,
     // disabled, buys nothing.
     if (attrHooks !== null) {
       storeOwners.set(proxy[$TARGET], owner);
-      nameStore(proxy, options?.name);
+      nameStore(proxy, options?.name, options?.loc);
     }
   }
   const setter = fn => storeSetter(proxy, fn);
@@ -6299,6 +6696,11 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, aroundDraftWri
           // A landing (not the sync pass's own commit): the readers held
           // pending on the derive settle.
           if (!first || !(owner._statusFlags & STATUS_UNINITIALIZED)) settleFamily(fam);
+          // A commit is the derive's change for the readers that observed its
+          // flight (linked by `pullFamily`; a settled pull does not link), as
+          // a memo's landing is for its readers: one that caught the NotReady
+          // (a fallback value, not pending) re-runs too (#4070).
+          insertSubs(owner);
         };
         const sync = handleAsync(owner, result, commit, (error, pending) => {
           // The flight rejected: the leaves' readers learn it from here —
@@ -6340,6 +6742,9 @@ function runProjectionComputed(wrappedStore, fn, key, wrapCommit, aroundDraftWri
   return owner;
 }
 function createProjectionInternal(fn, seed, options) {
+  // Seedless (`fn` takes no draft): the root starts as an empty record. It is
+  // a draft like any seed, never observable before the first landing (A25).
+  seed ||= {};
   const keyOption = options?.key === undefined ? "id" : options.key;
   const fam = {
     map: new WeakMap(),
@@ -6362,9 +6767,13 @@ function createProjectionInternal(fn, seed, options) {
   }
   let nodeOptions;
   if (options?.seedLoadingValue) nodeOptions = { loadingValue: undefined };
-  if (options?.name) {
-    nodeOptions = { ...nodeOptions, name: options.name };
-    nameStore(store, options.name);
+  if (attrHooks !== null)
+    // As createStore: the owner in scope stamps the projection's property
+    // nodes, so attribution places them under it (#4035).
+    storeOwners.set(store[$TARGET], getOwner());
+  if (options?.name || options?.loc) {
+    nodeOptions = { ...nodeOptions, name: options.name, loc: options.loc };
+    nameStore(store, options.name, options.loc);
   }
   const node = computed(() => {
     if (!fam.node) fam.node = getOwner();
@@ -6372,14 +6781,11 @@ function createProjectionInternal(fn, seed, options) {
   }, nodeOptions);
   node._config &= ~CONFIG_AUTO_DISPOSE;
   fam.node = node;
+  // The derive's leaves are not its dependents: a mark's repoll
+  // (affects-marks.ts) reaches their readers through this.
+  node.fam = fam;
   return { store, node };
 }
-/**
- * A derived store: `fn` runs in a computed and writes its draft; readers of
- * the store's keys re-run only when the keys they read change (the
- * firewall). `fn` may be async or an async iterator; the seed is a draft,
- * never an observable value, until the first landing (A25).
- */
 function createProjection(fn, seed, options) {
   return createProjectionInternal(fn, seed, options).store;
 }
@@ -6492,10 +6898,12 @@ function notifyOptimisticWrites(t, pb) {
   if (structural) {
     const rows = isArr ? pb.map(unwrapValue) : shallowKeys(pb);
     // The rows the setter removed from the view it saw, by key: a later
-    // re-base over another action's truth must not bring them back.
+    // re-base over another action's truth must not bring them back. A set
+    // (empty or not) marks a keyed arrangement guess (`fold`).
     let removed = null;
     const keyFn = t.fam.key;
     if (isArr && keyFn !== null && keyFn !== undefined) {
+      removed = new Set();
       const kept = new Set();
       for (let i = 0; i < rows.length; i++) {
         const k = isWrappable(rows[i]) ? keyFn(rows[i]) : undefined;
@@ -6504,7 +6912,7 @@ function notifyOptimisticWrites(t, pb) {
       for (let i = 0; i < old.length; i++) {
         const r = unwrapValue(old[i]);
         const k = isWrappable(r) ? keyFn(r) : undefined;
-        if (k !== undefined && !kept.has(k)) (removed ??= new Set()).add(k);
+        if (k !== undefined && !kept.has(k)) removed.add(k);
       }
     }
     optimisticWrite(getContainerNode(t), new LaneView(rows, base, removed));
@@ -6640,7 +7048,8 @@ function reconcileDraft(draft, incoming, keyFn) {
  * committed length differs, and as the `LaneView`'s base for structural
  * reads. Unkeyed families compose
  * positionally — the guess stands as written (the documented residue). */
-GlobalQueue._laneRebase = (el, truth) => {
+GlobalQueue._laneRebase = (el, truth, older) => {
+  if (!older) return fold(el, truth);
   const t = el._host;
   if (t === undefined || el._key !== $TRACK) return;
   const view = el._x._lane;
@@ -6701,6 +7110,51 @@ GlobalQueue._laneRebase = (el, truth) => {
       laneSet(len, rows.length, lane);
   }
 };
+/** D-34 for a keyed arrangement guess: rows by key, not positions. A
+ * current truth that differs folds into the hold beneath it instead of
+ * voiding the lane: the guess stays the lane's value and the screen's until
+ * the hold commits, where rows match by key, and the graph outside the lane
+ * re-derives from the truth now (`foldedRead`). A confirmation is silent
+ * (A17): only truth readers are told. True: the lane stages the truth
+ * beneath (`laneWrite`). */
+function fold(el, truth) {
+  const k = el._host?.k;
+  const l = txOf(el);
+  // A guess the screen never showed is void at the correction (D-34); a
+  // keyed arrangement guess's view carries its removed-keys set.
+  if (!l._shown || !(k?._config & CONFIG_OVERRIDE) || !k._x._lane?.removed) return false;
+  const guess = el._x._lane;
+  if ((!el._equals || !el._equals(guess, truth)) && !GlobalQueue._echoes(guess, truth)) {
+    l.folded = foldedRead;
+    insertSubs(el);
+  } else GlobalQueue._confirmed?.(l);
+  joinFuture(resolveTx(l._parent ?? l));
+  return true;
+}
+/** A folded lane's guess read by a deriving pass outside the lane, tracked
+ * or not (`untrack` is about dependencies, not about which world a pass
+ * derives from), or by `latest()` (`c` null): the hold's world — the truth
+ * staged beneath the guess, else the value it covered — and the pass joins
+ * the hold. Lane passes and the screen keep the guess: held truth is masked
+ * from lane passes only (#3164). The store's own derive reconciles its
+ * landings against the arrangement the guesses made: it is the author, not
+ * a reader. */
+function foldedRead(c, el) {
+  if (c !== null) {
+    if (
+      !(el._config & CONFIG_GUESS) ||
+      passLane !== null ||
+      c._type === EFFECT_RENDER ||
+      c._config & CONFIG_CHILDREN_FORBIDDEN ||
+      el._host?.fam?.node === c
+    )
+      return NOT_PENDING;
+    const l = txOf(el);
+    joinPassAt(c, resolveTx(l._parent ?? l));
+  }
+  if (el._pendingValue !== NOT_PENDING) return el._pendingValue;
+  return el._config & CONFIG_SLOT_NODE ? GlobalQueue._slotCovered(el) : el._value;
+}
 function sameRow(a, b, keyFn) {
   if (a === b) return true;
   if (!isWrappable(a) || !isWrappable(b)) return false;
@@ -6906,7 +7360,9 @@ function optimisticView(
 function createOptimisticStore(first, second, third) {
   const derived = typeof first === "function";
   const options = derived ? third : second;
-  const initialValue = derived ? second : first;
+  // Seedless derived form: the root starts as an empty record (see
+  // createProjectionInternal).
+  const initialValue = derived ? second || {} : first;
   const keyOption = options?.key === undefined ? "id" : options.key;
   const fam = {
     map: new WeakMap(),
@@ -6922,7 +7378,7 @@ function createOptimisticStore(first, second, third) {
           : row => (isWrappable(row) ? row[keyOption] : undefined)
   };
   const store = wrap(initialValue, null, null, fam);
-  nameStore(store, options?.name);
+  nameStore(store, options?.name, options?.loc);
   if (fam.shallow) {
     store[$TARGET].s = true;
     markRawIngest(initialValue);
@@ -6931,7 +7387,8 @@ function createOptimisticStore(first, second, third) {
     const fn = first;
     let nodeOptions;
     if (options?.seedLoadingValue) nodeOptions = { loadingValue: undefined };
-    if (options?.name) nodeOptions = { ...nodeOptions, name: options.name };
+    if (options?.name || options?.loc)
+      nodeOptions = { ...nodeOptions, name: options.name, loc: options.loc };
     const node = computed(() => {
       if (!fam.node) fam.node = getOwner();
       runProjectionComputed(store, fn, keyOption);
@@ -8000,6 +8457,83 @@ function deep(value) {
   return deep$1(value);
 }
 
+// The mark core: a declared not-final state on a node that reads pending
+// (`isPending` → true) on the node and everything derived from it, without
+// holding anything or entangling a reader. Two declarers share it:
+// `affects()` (affects.ts — a mark scoped to a transaction, with a store
+// half) and `createDeferred` (deferred.ts — a mark whose lifetime is the
+// node's own flight). Split out so the second does not ship the first.
+//
+// Representation: a count on the marked node (`_x._marks`). Coverage of the
+// derivations is pull-derived at probe time — `isPending`'s read walks the
+// probed node's dependencies for a marked one (verdict.ts → `_marked`) — so
+// nothing is stored downstream and a mid-window recompute strands nothing.
+// The push half is the verdict readers' re-derivation when a node's marks
+// start and end (`repoll`): the only notification a mark makes.
+/** Live marks, every declarer — the gate on the probe's walk. */
+let active = 0;
+/** The verdict readers downstream of `node` — through derivations, stopping
+ * at effects — re-derive: the mark's one notification (a probe's answer
+ * changed with no value notifying anyone). Truth readers (`until`, the
+ * `refresh` waiter) too, which a lagging flight parked (deferred.ts) — but
+ * not through a derived store, whose leaves change only once its derive
+ * re-runs: they re-derive at that write. */
+function repoll(node, seen = new Set(), readers = CONFIG_VERDICT | CONFIG_AUTHORITATIVE) {
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    const sub = s._sub;
+    if (seen.has(sub)) continue;
+    seen.add(sub);
+    if (sub._config & readers) enqueueSub(sub);
+    if (!sub._type) repoll(sub, seen, readers);
+    // A derived store's derive: its leaves' readers derive from it too
+    // (store/projection.ts; a live target's property, has and keys nodes).
+    const fam = sub.fam;
+    if (fam)
+      for (const t of fam.live)
+        for (const o of [t.n, t.h, { k: t.k, d: t.dk }])
+          if (o) for (const k of Reflect.ownKeys(o)) o[k] && repoll(o[k], seen, CONFIG_VERDICT);
+  }
+}
+/** A node is covered by a live mark iff it carries one, or derives — through
+ * its current dependencies — from one that does. A store slot derives from
+ * its family's derive (a derived store's leaves are not the derive's
+ * dependents, store/projection.ts), so coverage hops there. A real error
+ * outranks an inherited mark (A24 (c)): coverage does not flow through an
+ * errored node (a direct mark on one still reads pending). Mid-recompute,
+ * only the validated prefix of the dependency list is this pass's. */
+function marked(el, seen) {
+  if (el._x !== null && el._x._marks !== 0) return true;
+  const c = el;
+  if (c._statusFlags & STATUS_ERROR || seen.has(el)) return false;
+  seen.add(el);
+  if (c._config & CONFIG_SLOT_NODE) {
+    const derive = c._host?.fam?.node;
+    return derive != null && marked(derive, seen);
+  }
+  const tail = c._flags & REACTIVE_RECOMPUTING_DEPS ? c._depsTail : undefined;
+  if (tail !== null)
+    for (let d = c._deps ?? null; d !== null; d = d._nextDep) {
+      if (marked(d._dep, seen)) return true;
+      if (d === tail) break;
+    }
+  return false;
+}
+/** One mark on `node`. The declarer repolls once its bookkeeping is done. */
+function mark(node) {
+  ext(node)._marks++;
+  active++;
+}
+/** Drops one mark from `node`: true when it was the last — the node's
+ * verdict readers have re-derived. */
+function unmark(node) {
+  active--;
+  if (--node._x._marks !== 0) return false;
+  repoll(node);
+  return true;
+}
+GlobalQueue._marked = el => active !== 0 && marked(el, new Set());
+GlobalQueue._mark = mark;
+
 /**
  * Store — the store half of `affects()` (plan sec. 29, plan sec. 37; A24 (4), #2882,
  * #2893, #2904).
@@ -8128,7 +8662,7 @@ function releaseMarkScope(carrier) {
   const entry = scopes.get(carrier);
   if (entry === undefined) return;
   scopes.delete(carrier);
-  GlobalQueue._releaseMarks(entry._inherited);
+  releaseMarksHook(entry._inherited);
 }
 
 // `affects()` — the declaration verb of the pending model (A24 (4), ruled
@@ -8144,62 +8678,23 @@ function releaseMarkScope(carrier) {
 // data joins nothing through it. A mark is never a re-ask, so a declared
 // reload's own `refresh()` cannot silence it; a real error outranks it.
 //
-// Representation: a count on the marked node (`_x._marks`), listed with its
-// scope (the transaction's `_marks`, or the ambient list). Coverage of the
-// derivations is pull-derived at probe time — `isPending`'s read walks the
-// probed node's dependencies for a marked one (verdict.ts → `_marked`) — so
-// nothing is stored downstream and a mid-window recompute strands nothing.
-// The push half is the verdict readers' re-derivation at registration and at
-// release (`repoll`): the only notification a mark makes.
+// Representation: the mark core (affects-marks.ts) — a count on the marked
+// node, coverage pull-derived at probe time, readers repolled at registration
+// and release. Here: each mark's scope (the transaction's `_marks`, or the
+// ambient list) and the store half.
 //
 // Installed on `GlobalQueue` when imported: a program that never declares a
 // mark carries none of this.
-/** Live marks, every scope — the gate on the probe's walk. */
-let active = 0;
 /** Marks declared outside a transaction: released at the next seam. */
 const ambient = [];
-/** The verdict readers downstream of `node` — through derivations, stopping
- * at effects — re-derive: the mark's one notification (a probe's answer
- * changed with no value notifying anyone). */
-function repoll(node, seen = new Set()) {
-  for (let s = node._subs; s !== null; s = s._nextSub) {
-    const sub = s._sub;
-    if (seen.has(sub)) continue;
-    seen.add(sub);
-    if (sub._config & CONFIG_VERDICT) enqueueSub(sub);
-    if (!sub._type) repoll(sub, seen);
-  }
-}
-/** A node is covered by a live mark iff it carries one, or derives — through
- * its current dependencies — from one that does. A real error outranks an
- * inherited mark (A24 (c)): coverage does not flow through an errored node
- * (a direct mark on one still reads pending). Mid-recompute, only the
- * validated prefix of the dependency list is this pass's. */
-function marked(el, seen) {
-  if (el._x !== null && el._x._marks !== 0) return true;
-  const c = el;
-  if (c._statusFlags & STATUS_ERROR || seen.has(el)) return false;
-  seen.add(el);
-  const tail = c._flags & REACTIVE_RECOMPUTING_DEPS ? c._depsTail : undefined;
-  if (tail !== null)
-    for (let d = c._deps ?? null; d !== null; d = d._nextDep) {
-      if (marked(d._dep, seen)) return true;
-      if (d === tail) break;
-    }
-  return false;
-}
 /** Releases one scope's marks (a landed transaction's, the ambient list at
  * the seam): a node whose last mark drops re-derives its verdict readers. */
 function release$1(nodes) {
   for (let i = 0; i < nodes.length; i++) {
     const n = nodes[i];
-    active--;
-    if (--n._x._marks === 0) {
-      repoll(n);
-      // A store mark's carrier: its scope (and the marks the nodes born in
-      // its window inherited) goes with it.
-      releaseMarkScope(n);
-    }
+    // A store mark's carrier: its scope (and the marks the nodes born in
+    // its window inherited) goes with the last mark.
+    if (unmark(n)) releaseMarkScope(n);
   }
   nodes.length = 0;
 }
@@ -8215,10 +8710,6 @@ function register(node) {
   }
   repoll(node);
 }
-function mark(node) {
-  ext(node)._marks++;
-  active++;
-}
 function affects(target, key) {
   if (arguments.length > 2)
     invalid(
@@ -8256,10 +8747,7 @@ function invalid(detail) {
   emitDiagnostic({ code: "INVALID_AFFECTS_TARGET", kind: "write", severity: "error", message });
   throw new Error(message);
 }
-GlobalQueue._marked = el => active !== 0 && marked(el, new Set());
-GlobalQueue._mark = mark;
-GlobalQueue._releaseMarks = release$1;
-GlobalQueue._releaseAmbientMarks = parked => {
+installMarkHooks(release$1, parked => {
   if (ambient.length === 0) return;
   // The flush parked: the declaration's window is the frame's — the marks
   // are its transaction's ("nothing async below ⇒ no window").
@@ -8282,7 +8770,7 @@ GlobalQueue._releaseAmbientMarks = parked => {
   }
   ambient.length = kept;
   if (done.length !== 0) release$1(done);
-};
+});
 function inFlight(n) {
   return (
     (n._statusFlags & STATUS_PENDING) !== 0 ||
@@ -8290,6 +8778,174 @@ function inFlight(n) {
   );
 }
 
+// `createDeferred` — an async memo that may lag, but never leads (D-40,
+// docs/create-deferred.md).
+//
+// Once the node has a committed value, its own non-final work is invisible
+// to the graph: its readers keep the committed value and hold nothing, its
+// landings are changes of their own, and only the verdict (`isPending`) and
+// the truth readers (`until`, `refresh`'s waiter) see the flight.
+//
+// Built from parts the engine already has, so core pays nothing for it:
+//
+// - **Read side: the loading window** (`_loading`, async.ts). Every pass of
+//   a node with a committed value opens the window before it asks, so a
+//   flight serves the committed value instead of throwing, and an unready
+//   source parks the node instead of pending it. `CONFIG_REDERIVE` makes a
+//   source going pending a question for the node's pass (which parks) rather
+//   than a status pushed through it to its readers.
+// - **Verdict: a mark** (affects-marks.ts) whose lifetime is the flight —
+//   started when a pass asks a new question (a `refresh()` re-ask is quiet, F-9),
+//   dropped at the landing, the rejection, a sync answer or the node's death.
+// - **Never leads:** a flight that lands while an input it read is held
+//   derived from that hold's world, so it lands into the hold (`holdNode`;
+//   `setSignal` stages it there). An input that changed after the pass
+//   would have superseded the flight, so a held input at the landing is one
+//   the pass read held.
+// - **Truth readers** wait the flight out (`GlobalQueue._lagging`, signals.ts
+//   `watch`): `await refresh(d)` delivers the landing, `until` sees only
+//   settled values.
+/** Deferred nodes with a flight up. */
+const lagging = new Set();
+/** The deferred node with a flight up that `c`'s value derives from, if
+ * any: `c` itself, or one reached through its current dependencies. */
+function lagOf(c, seen) {
+  if (lagging.has(c)) return c;
+  if (seen.has(c)) return;
+  seen.add(c);
+  if (c._config & CONFIG_SLOT_NODE) return lagOf(c._host?.fam?.node ?? c, seen);
+  const tail = c._flags & REACTIVE_RECOMPUTING_DEPS ? c._depsTail : undefined;
+  if (tail !== null)
+    for (let d = c._deps ?? null; d !== null; d = d._nextDep) {
+      const l = lagOf(d._dep, seen);
+      if (l) return l;
+      if (d === tail) break;
+    }
+}
+GlobalQueue._lagging = c => (lagging.size !== 0 ? lagOf(c, new Set()) : undefined);
+/**
+ * Creates an async memo that may lag, but never leads. Before its first
+ * answer it is an ordinary async memo: readers suspend to the nearest
+ * `<Loading>`. After it, a refetch holds nothing: readers keep the last
+ * committed value until the new one lands, and the rest of the screen moves
+ * on without it. `isPending` reports the refetch, on the node and on what
+ * derives from it. Use it for independent widgets (dashboards, feeds,
+ * search results) where the previous answer with a "refreshing" indicator is
+ * better than waiting with everything else.
+ *
+ * - It never shows a value ahead of a held change: a refetch that read a
+ *   held value lands with that hold.
+ * - A rejected refetch errors like any memo; the stale value never masks it.
+ * - `refresh(d)` is a quiet re-ask, and `await refresh(d)` and `until`
+ *   wait for the landing rather than the stale value.
+ * - Combine with `loadingValue` for a node that never suspends at all.
+ *
+ * @example
+ * ```tsx
+ * const rows = createDeferred(() => fetchRows(store.period));
+ *
+ * <section class={{ stale: isPending(() => rows()) }}>
+ *   <For each={rows()}>{row => <Row row={row} />}</For>
+ * </section>
+ * ```
+ */
+function createDeferred(fn, options) {
+  let node;
+  /** The flight in force: a promise, a stream, or the error an unready
+   * source parked the node with. */
+  let flight = null;
+  let marked = false;
+  let answered = false;
+  /** The flight `r` is over. An async answer (`held`) arriving while an
+   * input is held lands into that hold first. */
+  const land = (r, held) => {
+    if (r === null || flight !== r) return;
+    flight = null;
+    lagging.delete(node);
+    if (held)
+      for (let d = node._deps; d !== null; d = d._nextDep)
+        if (d._dep._config & CONFIG_HELD) {
+          holdNode(node, txOf(d._dep));
+          break;
+        }
+    if (marked) {
+      marked = false;
+      unmark(node);
+      schedule();
+    }
+  };
+  const ask = r => {
+    flight = r;
+    lagging.add(node);
+    if (!marked && !(node._flags & REACTIVE_REASK)) {
+      marked = true;
+      mark(node);
+      repoll(node);
+    }
+  };
+  /** Registers the flight and serves the pass's value: the committed one,
+   * or over a held landing the landing itself, which a lagging question
+   * does not replace (D-40) — restaged as the committed value, the hold's
+   * readers would re-derive against the old input. */
+  const serve = r => {
+    const v = handleAsync(node, r);
+    return node._config & CONFIG_HELD && node._pendingValue !== NOT_PENDING
+      ? node._pendingValue
+      : v;
+  };
+  const end = () => node._flags & REACTIVE_DISPOSED && land(flight);
+  return accessor(
+    computed(prev => {
+      node = getOwner();
+      node._config |= CONFIG_REDERIVE;
+      cleanup(end);
+      // Answered: the node has a real committed answer — not a first load,
+      // not a `loadingValue` window still open (both are loading, F-9).
+      // Sticky, and read before this wrapper ever opens the window itself.
+      const open = (answered ||= !(node._statusFlags & STATUS_UNINITIALIZED) && !node._loading);
+      if (open) ((node._loading = true), (node._config |= CONFIG_LAGS));
+      let r;
+      try {
+        r = fn(prev);
+      } catch (e) {
+        // The wrapping form: an unready source parks the node in the window,
+        // and the wait is its flight until the source's settle re-runs it.
+        if (open && e instanceof NotReadyError) ask(e);
+        throw e;
+      }
+      if (open && typeof r === "object" && r !== null) {
+        if (isThenable(r)) {
+          ask(r);
+          const done = () => land(r, true);
+          r.then(done, done);
+          return serve(r);
+        }
+        const iterate = r[Symbol.asyncIterator];
+        if (iterate) {
+          // A stream's flight ends at its first yield (or its end).
+          const it = iterate.call(r);
+          let first = true;
+          const done = () => land(s, true);
+          const s = {
+            // Registered ahead of the engine's own reaction to the same
+            // promise, as for a plain flight: verdict and value in one flush.
+            next: v => {
+              const p = it.next(v);
+              if (first) ((first = false), p.then(done, done));
+              return p;
+            },
+            return: v => it.return?.(v) ?? Promise.resolve({ done: true, value: v })
+          };
+          ask(s);
+          return serve({ [Symbol.asyncIterator]: () => s });
+        }
+      }
+      land(flight);
+      return r;
+    }, options)
+  );
+}
+
 // CARVE 4: `flatten` lived in boundaries.ts but is the general children
 // resolver the renderers (`web`, `universal`, `solid`'s `children()`) walk
 // through — not a boundary feature. Moved verbatim so the boundary carve
@@ -8381,7 +9037,7 @@ function flattenArray(children, results = [], options) {
  * the root holds the frame as for any reader. The tree's own status takes
  * the same route from the output's pass (`read(tree)` throws it).
  *
- * The hold (`blocked`, scheduler.ts) asks `hidden`: a reader behind a
+ * The hold (`blocked`, scheduler.ts) asks `hiddenBy`: a reader behind a
  * fallback — any boundary on its chain whose last pass chose the fallback —
  * is not on screen and holds nothing. An error boundary flipping to its
  * fallback is the same as a loading one resetting: every reader under it
@@ -8416,6 +9072,11 @@ const boundaryOf = node => node._context[BOUNDARY];
 /** Catches what reaches it: an error boundary always; a loading one until it
  * has shown content, or while re-armed. */
 const isCollecting = b => b._type === STATUS_ERROR || !b._initialized || b._armed;
+/** A reader `b` waits on: recorded for its `on`, and `b` visited at the seam. */
+function record(b, node) {
+  b._readers.add(node);
+  collecting.add(b);
+}
 /** The reader goes to the fallback: recorded, and the output re-derives
  * (a no-op while the output's own pass is running — its post-check
  * decides). */
@@ -8432,8 +9093,7 @@ function caught(b, node, error) {
     setSignal(b._error, caught);
     reportClientError(caught, b._owner, node);
   }
-  b._readers.add(node);
-  collecting.add(b);
+  record(b, node);
   if (b._armed) flip(b);
   // Already showing the fallback: one more reader to wait on changes
   // nothing on screen. The fallback is instantiated once per show — a later
@@ -8449,8 +9109,9 @@ function caught(b, node, error) {
 function flip(b) {
   b._initialized = false;
   b._lane = b._armLane;
-  if (b._lane !== null && b._output !== null)
-    GlobalQueue._laneStage(b._output, b._lane, true, false);
+  const o = b._output;
+  if (!b._lane && o._config & CONFIG_HELD && txOf(o) !== flushTransaction) unhold(o);
+  if (b._lane !== null && b._output !== null) laneStageHook(b._output, b._lane, true, false);
 }
 function redraw(b) {
   if (b._output !== null && !(b._output._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
@@ -8458,7 +9119,7 @@ function redraw(b) {
     schedule();
   }
 }
-/** GlobalQueue._catch: status from a frame reader, nearest boundary first.
+/** `catchHook` (scheduler.ts): status from a frame reader, nearest boundary first.
  * A loading boundary on the way records a pending reader whether or not it
  * catches it (its `on` may collect it later). */
 function catchStatus(node, flags, error) {
@@ -8471,7 +9132,7 @@ function catchStatus(node, flags, error) {
     // lands with its run, not a round after). Others still waiting: nothing
     // on screen changes, the fallback stays as it is.
     if (collecting.size !== 0)
-      for (let b = boundaryOf(node); b !== undefined; b = b._parent ?? undefined)
+      for (let b = boundaryOf(node); b; b = b._parent)
         if (
           !(node._statusFlags & unsettled(b)) &&
           b._readers.delete(node) &&
@@ -8482,28 +9143,29 @@ function catchStatus(node, flags, error) {
         }
     return false;
   }
-  for (let b = boundaryOf(node); b !== undefined; b = b._parent ?? undefined) {
+  for (let b = boundaryOf(node); b; b = b._parent) {
     if (!(b._type & flags)) continue;
     if (isCollecting(b)) {
       caught(b, node, error);
-      return true;
+      return b._armed ? CAUGHT_REARMED : true;
     }
-    b._readers.add(node);
-    collecting.add(b);
+    record(b, node);
   }
   return false;
 }
-/** The nearest boundary on `r`'s chain showing its fallback, if any. */
+/** The nearest loading boundary that would catch `node` was re-armed this
+ * flush. */
+function armedOver(node) {
+  for (let b = boundaryOf(node); b; b = b._parent)
+    if (b._type & STATUS_PENDING && isCollecting(b)) return b._armed;
+}
+/** The nearest boundary on `r`'s chain showing its fallback, if any
+ * (`hiddenHook`: `r` is behind a fallback). */
 function hiddenBy(r) {
-  for (let b = boundaryOf(r); b !== undefined; b = b._parent ?? undefined)
-    if (b._fallback) return b;
+  for (let b = boundaryOf(r); b; b = b._parent) if (b._fallback) return b;
   return undefined;
 }
-/** GlobalQueue._hidden: behind a fallback. */
-function hidden(r) {
-  return hiddenBy(r) !== undefined;
-}
-/** GlobalQueue._heldRun: a queued run behind a fallback waits for the reveal
+/** `heldRunHook` (scheduler.ts): a queued run behind a fallback waits for the reveal
  * (maintainer, 2026-10-02: the queue is held, the synchronous first render
  * goes through). A user effect's, which would read a DOM that is not
  * attached ("many depend on reading the DOM, something that can't happen
@@ -8548,7 +9210,10 @@ function prune(b, pass) {
   for (const r of b._readers) {
     if (r._flags & REACTIVE_DISPOSED) b._readers.delete(r);
     else if (!(r._statusFlags & mask)) {
-      if (r !== b._tree && (r._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) {
+      if (
+        (r !== b._tree || b._armed) &&
+        (r._config & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD
+      ) {
         // Landed, held: the content is that transaction's — the output's
         // pass enters it and the reveal lands with the reader's run. The
         // seam, past its park decision, waits for the commit instead. (A
@@ -8578,7 +9243,7 @@ function ready(b) {
       prune(b, false) === 0)
   );
 }
-/** GlobalQueue._boundarySeam, end of the seam: readers that settled, died,
+/** `boundarySeamHook` (scheduler.ts), end of the seam: readers that settled, died,
  * or landed and committed are dropped; a fallback with none left reveals
  * next round. An arm resolves: nothing collected, nothing happened. */
 function boundarySeam() {
@@ -8591,6 +9256,18 @@ function boundarySeam() {
     // A parked frame's boundary (zombie) keeps its state for its revival.
     if (flags & REACTIVE_ZOMBIE) continue;
     prune(b, false);
+    const o = b._output;
+    if (
+      b._armed &&
+      !b._initialized &&
+      o._config & CONFIG_HELD &&
+      [...b._readers].every(
+        r => !(r._statusFlags & STATUS_PENDING) && r._config & CONFIG_HELD && txOf(r) === txOf(o)
+      )
+    ) {
+      b._readers.clear();
+      b._initialized = true;
+    }
     if (b._armed && !b._initialized && !b._ahead) reportOutsideHold(b);
     b._armed = false;
     if (b._readers.size === 0) {
@@ -8617,15 +9294,17 @@ function reportOutsideHold(b) {
           if (outside(s._sub, false)) return true;
       return false;
     }
-    if (hidden(reader)) return false;
-    for (let o = boundaryOf(reader); o !== undefined; o = o._parent ?? undefined)
-      if (o === b) return false;
+    if (hiddenBy(reader)) return false;
+    for (let o = boundaryOf(reader); o; o = o._parent) if (o === b) return false;
     return true;
   };
   for (const r of b._readers) {
     const sources = r._x?._pendingSources;
     if (sources === undefined) continue;
     for (const source of sources) {
+      // Only the flight the change itself started (D-16): an outside reader
+      // of an earlier write's flight holds nothing the change waits on.
+      if (source._time !== clock) continue;
       for (let s = source._subs; s !== null; s = s._nextSub) {
         if (!outside(s._sub, true)) continue;
         const name = source._name;
@@ -8650,15 +9329,6 @@ function reportOutsideHold(b) {
     }
   }
 }
-/** The `on` pass is a verdict's: it probed itself (CONFIG_VERDICT), or it
- * read a memo that did (#3528's `createMemo(() => isPending(m2))`) — its
- * swap is display-ahead either way. */
-function verdictDerived(c) {
-  if (c._config & CONFIG_VERDICT) return true;
-  for (let d = c._deps; d !== null; d = d._nextDep)
-    if (d._dep._config & CONFIG_VERDICT) return true;
-  return false;
-}
 /** `on` changed after the mount: fresh again if anything under it is
  * pending now; collecting for the rest of the flush either way. */
 function arm(b) {
@@ -8682,20 +9352,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;
@@ -8765,7 +9447,7 @@ function createBoundary(type, fn, show, onFn) {
         } catch (e) {
           if (!(e instanceof NotReadyError)) {
             if (!globalQueue.notify(getOwner(), STATUS_ERROR, STATUS_ERROR, e)) {
-              haltReactivity(e);
+              if (true) haltReactivityAt(e, getOwner());
               throw e;
             }
             return;
@@ -8828,8 +9510,7 @@ function createBoundary(type, fn, show, onFn) {
           }
           // Forwarded: a loading boundary showing content keeps it and
           // holds the frame like any reader (recorded for its `on`).
-          b._readers.add(tree);
-          collecting.add(b);
+          record(b, tree);
         }
         // A pending passes an error boundary by (A6); an error, a loading
         // one; a loading boundary showing content forwards its pending.
@@ -8869,8 +9550,7 @@ function createBoundary(type, fn, show, onFn) {
           }
           // Forwarded: a loading boundary showing content keeps it and
           // holds the frame like any reader (recorded for its `on`).
-          b._readers.add(tree);
-          collecting.add(b);
+          record(b, tree);
         }
         // A pending passes an error boundary by (A6).
         throw e;
@@ -9031,12 +9711,17 @@ function createErrorBoundary(fn, fallback) {
 }
 // Installed at module evaluation — present exactly when something imports a
 // boundary. An app without one pays the three null checks and nothing else.
-GlobalQueue._catch = catchStatus;
-GlobalQueue._fresh = node =>
-  node._statusFlags & STATUS_UNINITIALIZED && catchStatus(node, STATUS_PENDING);
-GlobalQueue._hidden = hidden;
-GlobalQueue._boundarySeam = boundarySeam;
-GlobalQueue._heldRun = heldRun;
+installBoundaryHooks(
+  catchStatus,
+  (node, held) =>
+    !held &&
+    (node._statusFlags & STATUS_UNINITIALIZED
+      ? catchStatus(node, STATUS_PENDING)
+      : armedOver(node)),
+  hiddenBy,
+  boundarySeam,
+  heldRun
+);
 
 /**
  * Reveal order — `createRevealOrder` (`<Reveal>`): the order in which a group
@@ -9279,6 +9964,7 @@ export {
   affects,
   configureClientErrors,
   createContext,
+  createDeferred,
   createEffect,
   createErrorBoundary,
   createLoadingBoundary,
@@ -9324,6 +10010,9 @@ export {
   resolvedTable,
   runWithOwner,
   setContext,
+  setReadWatch,
+  setSignalIdentities,
+  signalName,
   snapshot,
   sourceGet,
   sourceHas,
@@ -9332,6 +10021,7 @@ export {
   storeHasFamily,
   storeHasOptimisticFamily,
   storeIsShallow,
+  storeName,
   storePath,
   until,
   untrack,