@solidjs/signals 2.0.0-beta.19 → 2.0.0-beta.21

package/dist/dev.js

@@ -91,6 +91,20 @@ const EFFECT_USER = 2;
 const EFFECT_TRACKED = 3;
 const NOT_PENDING = {};
 const NO_SNAPSHOT = {};
+/**
+ * Stand-in stored in `_overrideValue` for an optimistic write of literal
+ * `undefined` (#2898). The slot doubles as the optimistic-node brand
+ * (`undefined` = not optimistic, `NOT_PENDING` = at rest), so the raw value
+ * would erase the node's optimistic identity: the write turns invisible and
+ * follow-up writes route off the optimistic path and commit permanently.
+ * Same shape as NO_SNAPSHOT. Sites that surface the override VALUE unwrap
+ * via `visibleOverrideValue`; slot identity tests stay raw.
+ */
+const OVERRIDE_UNDEFINED = {};
+/** Unwrap an active override's stored value for surfacing to readers (#2898). */
+function unwrapOverride(v) {
+  return v === OVERRIDE_UNDEFINED ? undefined : v;
+}
 const STORE_SNAPSHOT_PROPS = "sp";
 const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
@@ -147,6 +161,39 @@ function emitDiagnostic(event) {
   for (const capture of diagnosticCaptures) capture.push(entry);
   return entry;
 }
+/**
+ * Shared strict-read diagnostics for core read() and the store proxy traps.
+ * Single source for the message text — the #2897 safeguard parity between
+ * memos and stores is exactly these firing identically from both paths.
+ */
+function throwPendingUntrackedRead(strictReadLabel, fields) {
+  const message =
+    `[PENDING_ASYNC_UNTRACKED_READ] Reading a pending async value directly in ${strictReadLabel}. ` +
+    `Async values must be read within a tracking scope (JSX, a memo, or an effect's compute function).`;
+  emitDiagnostic({
+    code: "PENDING_ASYNC_UNTRACKED_READ",
+    kind: "async",
+    severity: "error",
+    message,
+    ...fields,
+    data: { strictRead: strictReadLabel }
+  });
+  throw new Error(message);
+}
+function warnStrictReadUntracked(strictReadLabel, fields) {
+  const message =
+    `[STRICT_READ_UNTRACKED] Reactive value read directly in ${strictReadLabel} will not update. ` +
+    `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
+  emitDiagnostic({
+    code: "STRICT_READ_UNTRACKED",
+    kind: "strict-read",
+    severity: "warn",
+    message,
+    data: { strictRead: strictReadLabel },
+    ...fields
+  });
+  console.warn(message);
+}
 function registerGraph(value, owner) {
   value._owner = owner;
   if (owner) {
@@ -320,6 +367,16 @@ function resolveLane(el) {
   return undefined;
 }
 function resolveTransition(el) {
+  // An active override answers with its owner, not its lane: lanes are
+  // scheduling affinity and a shared subscriber merges them across
+  // transactions (#2912) — the merged root's _transition would hand this
+  // node's override to whichever action wrote last through the shared
+  // reader. Chase merge chains; a dead owner settled through another path.
+  if (hasActiveOverride(el) && el._overrideOwner) {
+    const owner = (el._overrideOwner = currentTransition(el._overrideOwner));
+    if (owner._done !== true) return owner;
+    el._overrideOwner = null;
+  }
   return resolveLane(el)?._transition ?? el._transition;
 }
 /**
@@ -391,13 +448,14 @@ function registerTransientStoreNode(node) {
   transientStoreNodes.add(node);
 }
 function canUseSimpleSyncFlush(queue) {
+  const batch = queue._batch;
   return (
     transitions.size === 0 &&
     activeLanes.size === 0 &&
     queue._children.length === 0 &&
-    queue._optimisticNodes.length === 0 &&
-    queue._affectsNodes.length === 0 &&
-    queue._optimisticStores.size === 0 &&
+    batch._optimisticNodes.length === 0 &&
+    batch._affectsNodes.length === 0 &&
+    batch._optimisticStores.size === 0 &&
     transientStoreNodes.size === 0
   );
 }
@@ -438,20 +496,43 @@ function setProjectionWriteActive(value) {
 function setTrackedQueueCallback(value) {
   inTrackedQueueCallback = value;
 }
+/**
+ * Ambient work IS a transaction: the global queue always carries one
+ * current-transaction-shaped batch (`globalQueue._batch`). With no transition
+ * active, registrations (pending commits, optimistic nodes, affects marks,
+ * optimistic stores) land in a plain ambient batch that the plain flush
+ * finalizes; when a transition initializes it adopts the ambient batch's
+ * contents and `_batch` becomes the transition itself, so later registrations
+ * land there directly — no per-field aliasing.
+ */
+function createBatch() {
+  return {
+    _time: clock,
+    _pendingNodes: [],
+    _asyncReporters: createAsyncReporters(),
+    _optimisticNodes: [],
+    _affectsNodes: [],
+    _optimisticStores: new Set(),
+    _actions: [],
+    _queueStash: { _queues: [[], []], _children: [] },
+    _done: false,
+    _gatedSubs: new Set()
+  };
+}
 function mergeTransitionState(target, outgoing) {
   outgoing._done = target;
   target._actions.push(...outgoing._actions);
   for (const lane of activeLanes) if (lane._transition === outgoing) lane._transition = target;
   if (outgoing._optimisticNodes.length) {
-    // Move (don't copy): the global queue may still alias the outgoing
-    // array, and the adoption pass in initTransition would re-push its
+    // Move (don't copy): the global queue's batch may still be the outgoing
+    // transition, and the adoption pass in initTransition would re-push its
     // contents into the target — duplicating every entry.
     target._optimisticNodes.push(...outgoing._optimisticNodes);
     outgoing._optimisticNodes.length = 0;
   }
   if (outgoing._affectsNodes.length) {
-    // Move (don't copy): the global queue may still alias the outgoing
-    // array, and the adoption pass in initTransition would re-push its
+    // Move (don't copy): the global queue's batch may still be the outgoing
+    // transition, and the adoption pass in initTransition would re-push its
     // contents into the target — double-releasing every mark.
     target._affectsNodes.push(...outgoing._affectsNodes);
     outgoing._affectsNodes.length = 0;
@@ -576,11 +657,9 @@ class Queue {
 }
 class GlobalQueue extends Queue {
   _running = false;
-  _pendingNode = null;
-  _pendingNodes = [];
-  _optimisticNodes = [];
-  _affectsNodes = [];
-  _optimisticStores = new Set();
+  // The current transaction-shaped batch: a plain ambient batch while no
+  // transition is active, the active transition itself after initTransition.
+  _batch = createBatch();
   static _update;
   static _dispose;
   static _runEffect;
@@ -651,11 +730,13 @@ class GlobalQueue extends Queue {
         if (!isComplete) {
           const stashedTransition = activeTransition;
           runHeap(zombieQueue, GlobalQueue._update);
-          this._pendingNode = null;
-          this._pendingNodes = [];
-          this._optimisticNodes = [];
-          this._affectsNodes = [];
-          this._optimisticStores = new Set();
+          // Detach: the stashed transition keeps its batch; ambient work that
+          // follows lands in a fresh one. If the batch is already a separate
+          // ambient one — action done() restored activeTransition without
+          // adopting the batch, and an ordinary write landed there before
+          // the scheduled flush (#2916) — keep it: replacing it would strand
+          // its queued pending nodes with held _pendingValues forever.
+          if (this._batch === stashedTransition) currentBatch = this._batch = createBatch();
           // Run lane effects immediately (before stashing) - lanes with no pending async
           if (activeLanes.size) {
             GlobalQueue._runLaneEffects(EFFECT_RENDER);
@@ -663,7 +744,10 @@ class GlobalQueue extends Queue {
           }
           this.stashQueues(stashedTransition._queueStash);
           clock++;
-          scheduled = dirtyQueue._max >= dirtyQueue._min;
+          // A kept ambient batch may hold pending nodes (#2916): stay
+          // scheduled so the outer drain loop commits them via the plain
+          // flush path instead of leaving them until the next natural flush.
+          scheduled = dirtyQueue._max >= dirtyQueue._min || this._batch._pendingNodes.length > 0;
           reassignPendingTransition(stashedTransition._pendingNodes);
           activeTransition = null;
           // The stash pass (committed-view rerun of plain optimistic signals)
@@ -680,14 +764,26 @@ class GlobalQueue extends Queue {
           }
           return;
         }
-        this._pendingNodes !== activeTransition._pendingNodes &&
-          this._pendingNodes.push(...activeTransition._pendingNodes);
-        this.restoreQueues(activeTransition._queueStash);
-        transitions.delete(activeTransition);
         const completingTransition = activeTransition;
+        const batch = this._batch;
+        batch !== completingTransition &&
+          batch._pendingNodes.push(...completingTransition._pendingNodes);
+        this.restoreQueues(completingTransition._queueStash);
+        transitions.delete(completingTransition);
         activeTransition = null;
-        reassignPendingTransition(this._pendingNodes);
+        reassignPendingTransition(batch._pendingNodes);
         finalizePureQueue(completingTransition);
+        if (batch === completingTransition) {
+          // Drop the dead Transition wrapper but keep its (drained) containers
+          // as the ambient batch — late registrations during finalization live
+          // there and must survive to the next flush.
+          const fresh = createBatch();
+          fresh._pendingNodes = batch._pendingNodes;
+          fresh._optimisticNodes = batch._optimisticNodes;
+          fresh._affectsNodes = batch._affectsNodes;
+          fresh._optimisticStores = batch._optimisticStores;
+          currentBatch = this._batch = fresh;
+        }
       } else {
         if (canUseSimpleSyncFlush(this)) {
           commitPendingNodes();
@@ -710,12 +806,12 @@ class GlobalQueue extends Queue {
       this.run(EFFECT_USER);
       if (true) {
         devCheckActiveOverrides(n => {
-          if (this._optimisticNodes.includes(n)) return true;
+          if (this._batch._optimisticNodes.includes(n)) return true;
           if (activeTransition?._optimisticNodes.includes(n)) return true;
           for (const t of transitions) if (t._optimisticNodes.includes(n)) return true;
           return false;
         });
-        devCensusCompanions(n => n === this._pendingNode || this._pendingNodes.includes(n));
+        devCensusCompanions(n => this._batch._pendingNodes.includes(n));
       }
       if (
         true &&
@@ -725,7 +821,7 @@ class GlobalQueue extends Queue {
         activeLanes.size === 0
       ) {
         // Fully drained: no transition-scoped state may survive this point.
-        devCheckQuiescent(n => n === this._pendingNode || this._pendingNodes.includes(n));
+        devCheckQuiescent(n => this._batch._pendingNodes.includes(n));
       }
       if (true) DEV$1.hooks.onUpdate?.();
     } finally {
@@ -756,18 +852,7 @@ class GlobalQueue extends Queue {
     if (transition && transition === activeTransition) return;
     if (!transition && activeTransition && activeTransition._time === clock) return;
     if (!activeTransition) {
-      activeTransition = transition ?? {
-        _time: clock,
-        _pendingNodes: [],
-        _asyncReporters: createAsyncReporters(),
-        _optimisticNodes: [],
-        _affectsNodes: [],
-        _optimisticStores: new Set(),
-        _actions: [],
-        _queueStash: { _queues: [[], []], _children: [] },
-        _done: false,
-        _gatedSubs: new Set()
-      };
+      activeTransition = transition ?? createBatch();
     } else if (transition) {
       const outgoing = activeTransition;
       mergeTransitionState(transition, outgoing);
@@ -776,60 +861,36 @@ class GlobalQueue extends Queue {
     }
     transitions.add(activeTransition);
     activeTransition._time = clock;
-    if (this._pendingNode !== null) {
-      this._pendingNode._transition = activeTransition;
-      activeTransition._pendingNodes.push(this._pendingNode);
-      this._pendingNode = null;
-    }
-    if (this._pendingNodes !== activeTransition._pendingNodes) {
-      for (let i = 0; i < this._pendingNodes.length; i++) {
-        const node = this._pendingNodes[i];
+    const batch = this._batch;
+    if (batch !== activeTransition) {
+      // Adopt the ambient batch into the transaction, then make the
+      // transaction the batch so later registrations land there directly.
+      // Pending and optimistic nodes are re-stamped as the transaction's;
+      // marks don't hijack the node's _transition — a mark on a plain signal
+      // must not entangle unrelated writes to it; the same rule holds one hop
+      // downstream: propagation never queues pended subscribers as pending
+      // nodes, see propagateAffectsMark, #2893.
+      for (let i = 0; i < batch._pendingNodes.length; i++) {
+        const node = batch._pendingNodes[i];
         node._transition = activeTransition;
         activeTransition._pendingNodes.push(node);
       }
-      this._pendingNodes = activeTransition._pendingNodes;
-    }
-    if (this._optimisticNodes !== activeTransition._optimisticNodes) {
-      for (let i = 0; i < this._optimisticNodes.length; i++) {
-        const node = this._optimisticNodes[i];
+      for (let i = 0; i < batch._optimisticNodes.length; i++) {
+        const node = batch._optimisticNodes[i];
         node._transition = activeTransition;
         activeTransition._optimisticNodes.push(node);
       }
-      this._optimisticNodes = activeTransition._optimisticNodes;
-    }
-    if (this._affectsNodes !== activeTransition._affectsNodes) {
-      // Adopt ambient marks into the transaction (marks don't hijack the
-      // node's _transition — a mark on a plain signal must not entangle
-      // unrelated writes to it; the same rule holds one hop downstream:
-      // propagation never queues pended subscribers as pending nodes, see
-      // propagateAffectsMark, #2893). After adoption the queue aliases the
-      // transition's array, so later registrations land there directly.
-      activeTransition._affectsNodes.push(...this._affectsNodes);
-      this._affectsNodes = activeTransition._affectsNodes;
+      if (batch._affectsNodes.length) activeTransition._affectsNodes.push(...batch._affectsNodes);
+      for (const store of batch._optimisticStores) activeTransition._optimisticStores.add(store);
+      currentBatch = this._batch = activeTransition;
     }
     for (const lane of activeLanes) {
       if (!lane._transition) lane._transition = activeTransition;
     }
-    if (this._optimisticStores !== activeTransition._optimisticStores) {
-      for (const store of this._optimisticStores) activeTransition._optimisticStores.add(store);
-      this._optimisticStores = activeTransition._optimisticStores;
-    }
   }
 }
 function queuePendingNode(node) {
-  if (activeTransition) {
-    globalQueue._pendingNodes.push(node);
-    return;
-  }
-  if (globalQueue._pendingNode === null && globalQueue._pendingNodes.length === 0) {
-    globalQueue._pendingNode = node;
-    return;
-  }
-  if (globalQueue._pendingNode !== null) {
-    globalQueue._pendingNodes.push(globalQueue._pendingNode);
-    globalQueue._pendingNode = null;
-  }
-  globalQueue._pendingNodes.push(node);
+  currentBatch._pendingNodes.push(node);
 }
 // Sticky: flips true on the first refresh() ever (the only setter of
 // REACTIVE_REASK) so the hot notification loop skips the per-subscriber flag
@@ -886,11 +947,7 @@ function commitPendingNode(n) {
   if (n._pendingSignal || n._latestValueComputed) GlobalQueue._snapCompanions(n);
 }
 function commitPendingNodes() {
-  if (globalQueue._pendingNode !== null) {
-    commitPendingNode(globalQueue._pendingNode);
-    globalQueue._pendingNode = null;
-  }
-  const pendingNodes = globalQueue._pendingNodes;
+  const pendingNodes = currentBatch._pendingNodes;
   for (let i = 0; i < pendingNodes.length; i++) {
     commitPendingNode(pendingNodes[i]);
   }
@@ -906,12 +963,11 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
   if (ranHeap) runHeap(dirtyQueue, GlobalQueue._update);
   if (resolvePending) {
     if (ranHeap) commitPendingNodes();
+    // The settling batch: the completing transaction's, or the ambient one.
+    const batch = completingTransition ?? globalQueue._batch;
     // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
     // which installed the engine's hooks.
-    const optimisticNodes = completingTransition
-      ? completingTransition._optimisticNodes
-      : globalQueue._optimisticNodes;
-    if (optimisticNodes.length) GlobalQueue._resolveOptimistic(optimisticNodes);
+    if (batch._optimisticNodes.length) GlobalQueue._resolveOptimistic(batch._optimisticNodes);
     // Replay entanglement: subs recorded by the read-time gate get rescheduled
     // so they re-run with the now-committed values visible.
     if (completingTransition && completingTransition._gatedSubs.size) {
@@ -924,17 +980,13 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
     // Declared motion ends with the transaction: settle (or plain flush end
     // for ambient marks) releases each registration's refcount. A non-empty
     // batch means registerAffectsMark ran, which installed the hook.
-    const affectsNodes = completingTransition
-      ? completingTransition._affectsNodes
-      : globalQueue._affectsNodes;
-    if (affectsNodes.length) GlobalQueue._releaseAffectsMarks(affectsNodes);
-    const optimisticStores = completingTransition
-      ? completingTransition._optimisticStores
-      : globalQueue._optimisticStores;
+    if (batch._affectsNodes.length) GlobalQueue._releaseAffectsMarks(batch._affectsNodes);
     // A non-empty set means trackOptimisticStore ran, which installed the
     // hook; the hook iterates, clears, and schedules (keeping the loop out of
-    // core lets esbuild shake it — rollup already folds the null guard).
-    if (optimisticStores.size) GlobalQueue._clearOptimisticStores(optimisticStores);
+    // core lets esbuild shake it — rollup already folds the null guard). The
+    // completing transition scopes the clear to its own layer keys (#2899).
+    if (batch._optimisticStores.size)
+      GlobalQueue._clearOptimisticStores(batch._optimisticStores, completingTransition);
     sweepTransientStoreNodes();
     // Lanes only enter activeLanes through the engine's getOrCreateLane.
     if (activeLanes.size) GlobalQueue._cleanupLanes(completingTransition);
@@ -968,6 +1020,12 @@ function reassignPendingTransition(pendingNodes) {
   }
 }
 const globalQueue = new GlobalQueue();
+// Hot-path mirror of `globalQueue._batch`: `queuePendingNode` runs once per
+// staged write and `commitPendingNodes` once per flush, and the extra
+// property hop through `_batch` was a measured instruction-count regression
+// (CodSpeed update1to1, PR #2905). The field stays authoritative for
+// cross-module readers; every `_batch` assignment updates both.
+let currentBatch = globalQueue._batch;
 function flush(fn) {
   if (fn) {
     syncDepth++;
@@ -1005,7 +1063,7 @@ function runQueue$1(queue, type) {
 }
 function reporterBlocksSource(reporter, source) {
   if (reporter._flags & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-  if (reporter._pendingSource === source || reporter._pendingSources?.has(source)) return true;
+  if (reporter._pendingSources?.has(source)) return true;
   for (let dep = reporter._deps; dep; dep = dep._nextDep) {
     let current = dep._dep;
     while (current) {
@@ -1105,7 +1163,15 @@ function insertIntoHeap(n, heap) {
   if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
   if (flags & REACTIVE_CHECK) {
     n._flags = (flags & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
-  } else n._flags = flags | REACTIVE_IN_HEAP;
+  } else {
+    n._flags = flags | REACTIVE_IN_HEAP;
+    // An unmarked node entering a marked heap invalidates the markHeap memo:
+    // `_marked` is only reset by runHeap, so a write between two mid-tick
+    // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
+    // this node unmarked and every downstream pull stale until the next
+    // flush (#2922: the second `latest()` returned the first write's value).
+    if (heap._marked && !(flags & REACTIVE_DIRTY)) heap._marked = false;
+  }
   if (!(flags & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(n, heap);
 }
 function insertIntoHeapHeight(n, heap) {
@@ -1585,38 +1651,22 @@ function link(dep, sub, pendingObserver = false) {
   else dep._subs = newLink;
 }
 
+// The lazily-created Set is the ONE container for pending sources. Its
+// predecessor — a singular slot promoted to a Set on the second source —
+// created dual state whose migration invariant was easy to break: a third
+// overlapping source landed beside the Set and removePendingSource refused
+// to clear it, stranding the Set members' pending forever (#2893).
 function addPendingSource(el, source) {
-  if (el._pendingSource === source || el._pendingSources?.has(source)) return false;
-  // Once the Set exists it is THE container — the singular slot stays empty
-  // from migration until removePendingSource collapses back to one entry.
-  // Landing a third source in the singular slot instead created dual state
-  // that removePendingSource refused to clear, stranding the Set members'
-  // pending forever (#2893).
-  if (el._pendingSources) el._pendingSources.add(source);
-  else if (!el._pendingSource) el._pendingSource = source;
-  else {
-    el._pendingSources = new Set([el._pendingSource, source]);
-    el._pendingSource = undefined;
-  }
+  if (el._pendingSources?.has(source)) return false;
+  (el._pendingSources ??= new Set()).add(source);
   return true;
 }
 function removePendingSource(el, source) {
-  if (el._pendingSource) {
-    if (el._pendingSource !== source) return false;
-    el._pendingSource = undefined;
-    return true;
-  }
   if (!el._pendingSources?.delete(source)) return false;
-  if (el._pendingSources.size === 1) {
-    el._pendingSource = el._pendingSources.values().next().value;
-    el._pendingSources = undefined;
-  } else if (el._pendingSources.size === 0) {
-    el._pendingSources = undefined;
-  }
+  if (el._pendingSources.size === 0) el._pendingSources = undefined;
   return true;
 }
 function clearPendingSources(el) {
-  el._pendingSource = undefined;
   el._pendingSources?.clear();
   el._pendingSources = undefined;
 }
@@ -1660,7 +1710,7 @@ function settlePendingSource(
     if (visited.has(node) || !removePendingSource(node, source)) return;
     visited.add(node);
     node._time = clock;
-    const remaining = node._pendingSource ?? node._pendingSources?.values().next().value;
+    const remaining = node._pendingSources?.values().next().value;
     if (remaining) {
       setPendingError(node, remaining);
       updateCompanions !== null && updateCompanions(node);
@@ -1908,7 +1958,7 @@ function handleAsync(el, result, setter) {
   return syncValue;
 }
 function clearStatus(el, clearUninitialized = false) {
-  if (el._pendingSource || el._pendingSources) clearPendingSources(el);
+  if (el._pendingSources) clearPendingSources(el);
   if (el._blocked) el._blocked = false;
   // The pending window is over; its quiet classification dies with it.
   // (Unconditional: _reask is baked into the node literals, so this is a
@@ -1985,12 +2035,8 @@ function notifyStatus(el, status, error, blockStatus, lane) {
   forEachDependent(el, (sub, link) => {
     sub._time = clock;
     if (
-      (status === STATUS_PENDING &&
-        pendingSource &&
-        sub._pendingSource !== pendingSource &&
-        !sub._pendingSources?.has(pendingSource)) ||
-      (status !== STATUS_PENDING &&
-        (sub._error !== error || sub._pendingSource || sub._pendingSources))
+      (status === STATUS_PENDING && pendingSource && !sub._pendingSources?.has(pendingSource)) ||
+      (status !== STATUS_PENDING && (sub._error !== error || sub._pendingSources))
     ) {
       // A pending-observer link is the subscription an `isPending` read created.
       // It exists so the observer re-runs when the source settles, but it must
@@ -2209,7 +2255,7 @@ function recompute(el, create = false) {
   if (!el._error) {
     trimStaleDeps(el);
     const compareValue = hasOverride
-      ? el._overrideValue
+      ? unwrapOverride(el._overrideValue)
       : el._pendingValue === NOT_PENDING
         ? el._value
         : el._pendingValue;
@@ -2246,7 +2292,7 @@ function recompute(el, create = false) {
         // own reveal schedule; drop any superseded older hold so its queued
         // commit can't clobber the fresh value.
         if (hasOverride && isOptimisticDirty) {
-          el._overrideValue = value;
+          el._overrideValue = value === undefined ? OVERRIDE_UNDEFINED : value;
           el._pendingValue = NOT_PENDING;
         }
       } else {
@@ -2614,22 +2660,12 @@ function read(el) {
     }
     return !c || el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   }
-  if (strictRead && owner._statusFlags & STATUS_PENDING) {
-    const message =
-      `[PENDING_ASYNC_UNTRACKED_READ] Reading a pending async value directly in ${strictRead}. ` +
-      `Async values must be read within a tracking scope (JSX, a memo, or an effect's compute function).`;
-    emitDiagnostic({
-      code: "PENDING_ASYNC_UNTRACKED_READ",
-      kind: "async",
-      severity: "error",
-      message,
+  if (strictRead && owner._statusFlags & STATUS_PENDING)
+    throwPendingUntrackedRead(strictRead, {
       ownerId: c?.id,
       ownerName: c?._name,
-      nodeName: owner?._name,
-      data: { strictRead }
+      nodeName: owner?._name
     });
-    throw new Error(message);
-  }
   if (c && tracking) {
     link(el, c, pendingCheckActive);
     // Mark inheritance through derivation (see the fast path above), and its
@@ -2715,27 +2751,17 @@ function read(el) {
       return snapshot;
     }
   }
-  if (strictRead) {
-    const message =
-      `[STRICT_READ_UNTRACKED] Reactive value read directly in ${strictRead} will not update. ` +
-      `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
-    emitDiagnostic({
-      code: "STRICT_READ_UNTRACKED",
-      kind: "strict-read",
-      severity: "warn",
-      message,
+  if (strictRead)
+    warnStrictReadUntracked(strictRead, {
       ownerId: c?.id,
       ownerName: c?._name,
-      nodeName: owner?._name,
-      data: { strictRead }
+      nodeName: owner?._name
     });
-    console.warn(message);
-  }
   if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING) {
     // An active override means the engine is installed (A17: the override IS
     // the value for every reader — that check itself stays right here).
     if (c && stale && GlobalQueue._readStashed(el)) return el._value;
-    return el._overrideValue;
+    return unwrapOverride(el._overrideValue);
   }
   // Entanglement gate: a reader recomputing under an optimistic lane that reads
   // a pending mid-transition write sees the committed value. Projection-store
@@ -3131,7 +3157,7 @@ let stashedOptimisticReads = null;
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */
 function optimisticWrite(el, v) {
   const hasOverride = el._overrideValue !== NOT_PENDING;
-  const currentValue = hasOverride ? el._overrideValue : el._value;
+  const currentValue = hasOverride ? unwrapOverride(el._overrideValue) : el._value;
   if (typeof v === "function") v = v(currentValue);
   const valueChanged =
     !!(el._statusFlags & STATUS_UNINITIALIZED) || !el._equals || !el._equals(currentValue, v);
@@ -3148,10 +3174,17 @@ function optimisticWrite(el, v) {
   // No revert target is stashed: while the override is active every reader
   // sees it (A17), so authoritative arrivals commit silently into _value and
   // reverting is just dropping the override — _value is already correct.
-  else globalQueue._optimisticNodes.push(el);
+  else globalQueue._batch._optimisticNodes.push(el);
+  // Stamp ownership on the node (post-merge, so entangled writers share the
+  // joint root). resolveTransition prefers this over the lane's _transition,
+  // which a shared subscriber can merge across transactions (#2912).
+  el._overrideOwner = activeTransition;
   const lane = getOrCreateLane(el);
   el._optimisticLane = lane;
-  el._overrideValue = v;
+  // Literal undefined must not land raw: the slot doubles as the optimistic
+  // brand, and erasing it makes the write invisible and routes follow-up
+  // writes off the optimistic path into permanent commits (#2898).
+  el._overrideValue = v === undefined ? OVERRIDE_UNDEFINED : v;
   GlobalQueue._syncCompanions !== null && GlobalQueue._syncCompanions(el, v);
   el._time = clock;
   insertSubs(el, true);
@@ -3223,8 +3256,10 @@ function resolveOptimisticNodes(nodes) {
     if (!(node._statusFlags & STATUS_PENDING)) node._statusFlags &= ~STATUS_UNINITIALIZED;
     const prevOverride = node._overrideValue;
     node._overrideValue = NOT_PENDING;
-    if (prevOverride !== NOT_PENDING && node._value !== prevOverride) insertSubs(node, true);
+    if (prevOverride !== NOT_PENDING && node._value !== unwrapOverride(prevOverride))
+      insertSubs(node, true);
     node._transition = null;
+    node._overrideOwner = null;
   }
   // Settlement checkpoint (#2838): companions caught in this batch (or owned
   // by a node in it) re-derive from committed state, so verdicts survive the
@@ -3349,8 +3384,8 @@ function laneAsyncSettled(el) {
   }
 }
 function trackOptimisticStore(store) {
-  // After initTransition, globalQueue._optimisticStores IS activeTransition._optimisticStores (same reference)
-  globalQueue._optimisticStores.add(store);
+  // After initTransition, globalQueue._batch IS activeTransition (same reference)
+  globalQueue._batch._optimisticStores.add(store);
   schedule();
 }
 /**
@@ -3420,7 +3455,6 @@ function quietPending(el) {
     for (const source of el._pendingSources) if (!source._reask) return false;
     return true;
   }
-  if (el._pendingSource) return el._pendingSource._reask;
   return el._reask;
 }
 function newQuestionInFlight(comp) {
@@ -3450,7 +3484,7 @@ function computePendingState(el) {
   }
   if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) {
     if (hasActiveOverride(el))
-      return !el._equals || !el._equals(el._pendingValue, el._overrideValue);
+      return !el._equals || !el._equals(el._pendingValue, unwrapOverride(el._overrideValue));
     return true;
   }
   return newQuestionInFlight(comp);
@@ -3534,10 +3568,23 @@ function latestRead(el) {
   setLatestReadActive(false);
   const visibleValue =
     el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING
-      ? el._overrideValue
+      ? unwrapOverride(el._overrideValue)
       : el._value;
   let value;
   try {
+    // An untracked latest() read has no reading context, so read() never
+    // performs its mid-tick pull — a plain write queued between two latest()
+    // calls left a still-subscribed shadow at its previous speculative value
+    // until the flush (#2922). Mirror the tracked-read pull here: mark the
+    // queued staleness through the graph, then bring the shadow up to date.
+    const queue = queueFor(pendingComputed);
+    if (
+      pendingComputed._height >= queue._min &&
+      !(pendingComputed._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))
+    ) {
+      markHeap(queue);
+      prepareComputed(pendingComputed, true);
+    }
     value = read(pendingComputed);
   } catch (e) {
     if (e instanceof NotReadyError && (!context || !(el._statusFlags & STATUS_UNINITIALIZED)))
@@ -3554,6 +3601,16 @@ function latestRead(el) {
       return visibleValue;
     }
   }
+  // A shadow recomputed by the pull above (not at creation) holds its fresh
+  // speculative value in _pendingValue; a contextless read() only surfaces
+  // _value. Overrides stay authoritative (A17), and stale readers keep the
+  // other transition's committed view, matching read()'s own selection.
+  if (
+    pendingComputed._pendingValue !== NOT_PENDING &&
+    !hasActiveOverride(pendingComputed) &&
+    !(stale && pendingComputed._transition && activeTransition !== pendingComputed._transition)
+  )
+    return pendingComputed._pendingValue;
   return value;
 }
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */
@@ -3863,15 +3920,43 @@ function restoreTransition(transition, fn) {
   return result;
 }
 /**
+ * The primitive for mutations: imperative async workflows whose *writes span
+ * an async gap* — optimistic write, server round-trip, reconciling write —
+ * where intermediate state must not leak and failure must revert cleanly
+ * (pair with `createOptimistic` / `createOptimisticStore`).
+ *
+ * Navigation-shaped updates do not need an action. A plain setter call is
+ * enough: reads pull the async, and downstream async computeds hold their
+ * previous values per-node until the new ones are ready (`isPending` /
+ * `latest` expose the in-flight state). Reach for `action` only when writes
+ * happen *after* async work, not merely upstream of it.
+ *
+ * Framework-level actions (router form actions, server actions) are
+ * specializations of this primitive: they are actions in exactly this sense —
+ * the same transactional semantics — with form binding, serialization, and
+ * submission tracking layered on top. The shared name is deliberate.
+ *
  * Wraps a generator function so each invocation runs as a single transaction
  * (a "transition") that batches every signal/store write between yields. The
  * surrounding UI sees one atomic update per yielded step; nothing is committed
  * until the action either completes or the next `yield` resolves.
  *
- * Yield promises (or any awaitable) inside the generator — the action waits
- * for each before continuing, but the writes you made beforehand are already
- * visible (or held by `<Loading>` if optimistic). Yield bare values for
- * synchronous batched steps.
+ * `yield` is the transaction-safe suspension point: the action waits for a
+ * yielded promise and re-enters the transaction before running the code after
+ * it. A plain `await` does NOT — the runtime has no hook into an async
+ * generator's internal await continuations, so writes to fresh signals
+ * between an `await` and the next `yield` escape the transaction and commit
+ * immediately. `await` is still the ergonomic choice for typed results; just
+ * put a bare `yield` before any writes that follow it:
+ *
+ * ```ts
+ * const saved = await api.createTodo(text); // typed result
+ * yield; // re-enter the transaction before writing
+ * setTodos(t => { ... });
+ * ```
+ *
+ * (For the same reason, don't call `flush()` inside an action body — it
+ * drains the transaction mid-step.)
  *
  * Each call returns a `Promise` that resolves with the generator's return
  * value, or rejects if it throws. Pair with `createOptimistic` /
@@ -3882,10 +3967,11 @@ function restoreTransition(transition, fn) {
  * ```ts
  * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
  *
- * const addTodo = action(function* (text: string) {
+ * const addTodo = action(async function* (text: string) {
  *   const tempId = crypto.randomUUID();
  *   setTodos(t => { t.push({ id: tempId, text, pending: true }); }); // optimistic
- *   const saved = yield api.createTodo(text); // network round-trip
+ *   const saved = await api.createTodo(text); // network round-trip, typed
+ *   yield; // re-enter the transaction
  *   setTodos(t => {
  *     const i = t.findIndex(x => x.id === tempId);
  *     if (i >= 0) t[i] = saved;
@@ -3948,11 +4034,33 @@ function action(genFn) {
       };
       const run = r => {
         if (r.done) return done(r.value);
-        if (isThenable(r.value))
-          return void r.value.then(
-            v => restoreTransition(ctx, () => step(v)),
-            e => restoreTransition(ctx, () => step(e, true))
-          );
+        // Thenable assimilation can itself throw synchronously (a `then`
+        // getter, or a `then()` method that throws — #2918). Match `await`
+        // semantics: the failure is thrown back into the generator at the
+        // yield point (catchable there); if uncaught, step()'s guard settles
+        // the action so its iterator never leaks in the transition. The
+        // settled flag implements A+ 2.3.3.3.4.1: a throw after the thenable
+        // already called a callback is ignored.
+        let settled = false;
+        try {
+          if (isThenable(r.value))
+            return void r.value.then(
+              v => {
+                if (settled) return;
+                settled = true;
+                restoreTransition(ctx, () => step(v));
+              },
+              e => {
+                if (settled) return;
+                settled = true;
+                restoreTransition(ctx, () => step(e, true));
+              }
+            );
+        } catch (e) {
+          if (settled) return;
+          settled = true;
+          return void restoreTransition(ctx, () => step(e, true));
+        }
         restoreTransition(ctx, () => step(r.value));
       };
       step();
@@ -4428,6 +4536,8 @@ function addEnumSymbols(o, syms, keys) {
   }
 }
 function getAllKeys(value, override, next) {
+  // Symbols are merged explicitly below; keep the common string-key path on
+  // Object.keys() and avoid reflecting the base symbols twice.
   const keys = getKeys(value, override);
   const nextKeys = Object.keys(next);
   // `value` can be a wrapped store (store-in-store) whose ownKeys trap tracks;
@@ -4510,6 +4620,43 @@ function applyArrayItem(next, previous, target, node, keyFn) {
     applyState(next, wrapped, keyFn);
   } else node && setSignal(node, wrapValue(next, target));
 }
+/**
+ * The captured-proxy half of the object diff (#2902): descend into keyed-
+ * matching children that have NO node at this level but shelter subscribers
+ * somewhere below (their target's sticky `STORE_DESC` flag, bubbled up by
+ * `getNode`). Without this, a proxy captured through untracked reads — a
+ * `<For>` row handed to a child component — detaches from the diff the
+ * moment no intermediate level happens to be tracked, and its live
+ * subscribers go permanently stale. Never-subscribed branches have no flag
+ * and stay pruned exactly as before; keys the main loop already visited
+ * (node present) are skipped. Callers gate on the parent's own flag and on
+ * `$TRACK` absence (an enumeration-tracked record already diffs every key).
+ */
+function applyDescendants(previous, next, target, nodes, keyFn, override, optOverride) {
+  const lookup = target[STORE_LOOKUP] || storeLookup;
+  const keys = (override ? getKeys(previous, override) : Object.keys(previous)).concat(
+    getStoreSymbols(previous, override)
+  );
+  for (let i = 0, len = keys.length; i < len; i++) {
+    const key = keys[i];
+    if (nodes?.[key]) continue; // main loop already diffed this slot
+    const previousValue = unwrap(
+      override ? getOverrideValue(previous, override, key, optOverride) : previous[key]
+    );
+    if (!isWrappable(previousValue)) continue;
+    const childTarget = (lookup.get(previousValue) ?? storeLookup.get(previousValue))?.[$TARGET];
+    if (!childTarget?.[STORE_DESC]) continue;
+    const nextValue = unwrap(next[key]);
+    if (
+      previousValue === nextValue ||
+      !isWrappable(nextValue) ||
+      Array.isArray(previousValue) !== Array.isArray(nextValue) ||
+      (keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
+    )
+      continue;
+    applyState(nextValue, wrap(previousValue, target), keyFn);
+  }
+}
 // Dispatcher: every applyState call (including recursion) checks for the
 // presence of override / optimistic-override slots once and routes to the
 // appropriate body. The fast body never calls `getOverrideValue` and never
@@ -4619,8 +4766,9 @@ function applyStateFast(next, target, keyFn) {
   }
   // values
   let nodes = target[STORE_NODE];
+  let tracked;
   if (nodes) {
-    const tracked = nodes[$TRACK];
+    tracked = nodes[$TRACK];
     const keys = tracked ? getAllKeys(previous, undefined, next) : nodeKeys(nodes);
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
@@ -4640,6 +4788,7 @@ function applyStateFast(next, target, keyFn) {
       } else applyState(nextValue, wrap(previousValue, target), keyFn);
     }
   }
+  if (!tracked && target[STORE_DESC]) applyDescendants(previous, next, target, nodes, keyFn);
   // has
   if ((nodes = target[STORE_HAS])) {
     const keys = nodeKeys(nodes);
@@ -4753,8 +4902,9 @@ function applyStateSlow(next, target, keyFn) {
     return;
   }
   // values
+  let tracked;
   if (nodes) {
-    const tracked = nodes[$TRACK];
+    tracked = nodes[$TRACK];
     const keys = tracked ? getAllKeys(previous, override, next) : nodeKeys(nodes);
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
@@ -4774,6 +4924,8 @@ function applyStateSlow(next, target, keyFn) {
       } else applyState(nextValue, wrap(previousValue, target), keyFn);
     }
   }
+  if (!tracked && target[STORE_DESC])
+    applyDescendants(previous, next, target, nodes, keyFn, override, optOverride);
   // has
   if ((nodes = target[STORE_HAS])) {
     const keys = nodeKeys(nodes);
@@ -5005,7 +5157,10 @@ const STORE_VALUE = "v",
   STORE_WRAP = "w",
   STORE_LOOKUP = "l",
   STORE_FIREWALL = "f",
-  STORE_OPTIMISTIC = "p";
+  STORE_OPTIMISTIC = "p",
+  STORE_OPTIMISTIC_OWNERS = "t",
+  STORE_PARENT = "u",
+  STORE_DESC = "d";
 const STORE_SELF_PENDING = Symbol("STORE_SELF_PENDING");
 function createStoreProxy(value, traps = storeTraps, extend) {
   let newTarget;
@@ -5028,9 +5183,17 @@ const storeLookup = new WeakMap();
 // Lets reconcile enumerate symbols only for records that need it (#2851).
 const symbolKeyedRecords = new WeakSet();
 function wrap(value, target) {
-  if (target?.[STORE_WRAP]) return target[STORE_WRAP](value, target);
+  if (target?.[STORE_WRAP]) {
+    const p = target[STORE_WRAP](value, target);
+    const t = p[$TARGET];
+    if (t && !t[STORE_PARENT] && t !== target) t[STORE_PARENT] = target;
+    return p;
+  }
   let p = value[$PROXY] || storeLookup.get(value);
-  if (!p) storeLookup.set(value, (p = createStoreProxy(value)));
+  if (!p) {
+    storeLookup.set(value, (p = createStoreProxy(value)));
+    if (target) p[$TARGET][STORE_PARENT] = target;
+  }
   return p;
 }
 function isWrappable(obj) {
@@ -5058,7 +5221,7 @@ function unwrapStoreValue(value, map, lookup) {
   const result = isArray ? [] : Object.create(Object.getPrototypeOf(source));
   map.set(value, result);
   lookup = target[STORE_LOOKUP] ?? storeLookup;
-  for (const key of getKeys(source, override)) {
+  for (const key of getStoreKeys(source, override)) {
     if (isArray && key === "length") continue;
     const next = key in override ? override[key] : source[key];
     if (next !== $DELETED) result[key] = unwrapStoreValue(next, map, lookup);
@@ -5073,6 +5236,21 @@ function isPrototypePollutionKey$1(property) {
 function ownEnumerableKeys(o) {
   return Reflect.ownKeys(o).filter(k => Object.prototype.propertyIsEnumerable.call(o, k));
 }
+function ownEnumerableSymbols(o) {
+  const symbols = Object.getOwnPropertySymbols(o);
+  const result = [];
+  for (let i = 0, len = symbols.length; i < len; i++) {
+    const symbol = symbols[i];
+    if (Object.prototype.propertyIsEnumerable.call(o, symbol)) result.push(symbol);
+  }
+  return result;
+}
+// Plain-object variant that keeps Object.keys() as the fast path and only pays
+// descriptor checks for symbols. Do not use this on store proxies: splitting
+// strings/symbols would invoke their ownKeys trap twice.
+function ownEnumerableKeysPlain(o) {
+  return Object.keys(o).concat(ownEnumerableSymbols(o));
+}
 /**
  * Single chokepoint for the store's layered value resolution: returns the
  * override layer (optimistic first, then regular) that shadows `property`, or
@@ -5093,7 +5271,7 @@ function getOverlayLayer(target, property) {
  */
 function visibleNodeValue(node) {
   return node._overrideValue !== undefined && node._overrideValue !== NOT_PENDING
-    ? node._overrideValue
+    ? unwrapOverride(node._overrideValue)
     : node._pendingValue !== NOT_PENDING
       ? node._pendingValue
       : node._value;
@@ -5161,22 +5339,37 @@ function getNode(target, nodes, property, value, equals = isEqual, snapshotProps
   }
   if (typeof property === "symbol" && property !== $TRACK && property !== $AFFECTS)
     symbolKeyedRecords.add(nodes);
-  // A node born inside a live keyless mark's identity scope inherits the mark
+  // A node born inside a live mark's identity scope inherits the mark
   // (the declaration walk could only cover nodes that existed then). The
   // record's own $AFFECTS carrier is the mark's channel, never a member.
-  if (property !== $AFFECTS && affectsScopes.size) inheritAffectsMarks(s, target[STORE_VALUE]);
+  if (property !== $AFFECTS && affectsScopes.size)
+    inheritAffectsMarks(s, target[STORE_VALUE], property);
+  // Node presence bubbles up the wrap chain (sticky), so reconcile can see
+  // "subscribers live somewhere below" through node-less intermediate
+  // records — the captured-proxy diff gate (#2902). Amortized O(1): stops at
+  // the first already-flagged ancestor.
+  let t = target;
+  while (t && !t[STORE_DESC]) {
+    t[STORE_DESC] = true;
+    t = t[STORE_PARENT];
+  }
   return (nodes[property] = s);
 }
 /**
- * Scope inheritance for late-created nodes: every live keyless mark whose
- * identity scope contains the owning record's raw gets counted on the new
- * node. Inherited marks live exactly as long as the scope's carrier — the
- * release hook below drops them with the entry.
+ * Scope inheritance for late-created nodes: every live mark whose identity
+ * scope contains the owning record's raw — and, for keyed marks, whose key
+ * is this property — gets counted on the new node. Inherited marks live
+ * exactly as long as the scope's carrier — the release hook below drops
+ * them with the entry.
  */
-function inheritAffectsMarks(node, raw) {
+function inheritAffectsMarks(node, raw, property) {
   // A live scope exists, so affects.ts already installed the mark engine.
   for (const [carrier, entry] of affectsScopes) {
-    if (carrier._affectsCount && entry.scope.has(raw)) {
+    if (
+      carrier._affectsCount &&
+      entry.scope.has(raw) &&
+      (entry.key === undefined || entry.key === property)
+    ) {
       GlobalQueue._markAffects(node);
       entry.inherited.push(node);
     }
@@ -5214,7 +5407,10 @@ function walkAffectsScope(
     collectRecordNodes(target[STORE_NODE], found);
     collectRecordNodes(target[STORE_HAS], found);
     override = mergedOverlay(target);
-    lookup = target[STORE_LOOKUP] ?? lookup;
+    // Carry the effective lookup into untouched descendants. Default stores
+    // use the global lookup just like snapshotImpl; without it, nested raw
+    // objects fall back to string-only enumeration and symbol branches vanish.
+    lookup = target[STORE_LOOKUP] ?? lookup ?? storeLookup;
   }
   if (Array.isArray(raw)) {
     const len = override?.length ?? raw.length;
@@ -5222,8 +5418,18 @@ function walkAffectsScope(
       const v = override && i in override ? override[i] : raw[i];
       if (v !== $DELETED) walkAffectsScope(v, entry, found, lookup, visited);
     }
+    // Arrays can also carry symbol metadata. Enumerate symbols separately to
+    // avoid scanning large index lists twice. Outside a store tree, retain the
+    // existing index-only walk.
+    const symbols = target || lookup ? getStoreSymbols(raw, override) : [];
+    for (let i = 0, l = symbols.length; i < l; i++) {
+      const key = symbols[i];
+      const desc = getPropertyDescriptor(raw, override, key);
+      if (!desc || desc.get) continue;
+      walkAffectsScope(desc.value, entry, found, lookup, visited);
+    }
   } else {
-    const keys = getKeys(raw, override);
+    const keys = target || lookup ? getStoreKeys(raw, override) : getKeys(raw, override);
     for (let i = 0, l = keys.length; i < l; i++) {
       const desc = getPropertyDescriptor(raw, override, keys[i]);
       if (!desc || desc.get) continue;
@@ -5252,7 +5458,7 @@ function collectRecordNodes(nodes, found) {
  *
  * @internal
  */
-function witnessAffectsMark(target) {
+function witnessAffectsMark(target, property) {
   // Callers guard on `pendingCheckActive`, which only flips inside
   // isPending() — the verdict layer is loaded and its hook installed.
   const own = target[STORE_NODE]?.[$AFFECTS];
@@ -5260,7 +5466,12 @@ function witnessAffectsMark(target) {
   if (affectsScopes.size) {
     const raw = target[STORE_VALUE];
     for (const [carrier, entry] of affectsScopes) {
-      if (carrier !== own && carrier._affectsCount && entry.scope.has(raw))
+      if (
+        carrier !== own &&
+        carrier._affectsCount &&
+        entry.scope.has(raw) &&
+        (entry.key === undefined || entry.key === property)
+      )
         GlobalQueue._witnessAffects(carrier);
     }
   }
@@ -5278,26 +5489,42 @@ function witnessAffectsMark(target) {
  */
 function getStoreAffectsNodes(target, key) {
   const nodes = getNodes(target, STORE_NODE);
+  GlobalQueue._releaseAffectsScope ||= node => {
+    const entry = affectsScopes.get(node);
+    if (!entry) return;
+    affectsScopes.delete(node);
+    for (let i = 0; i < entry.inherited.length; i++)
+      GlobalQueue._releaseAffectsMark(entry.inherited[i]);
+  };
   if (key === undefined) {
     const carrier = getNode(target, nodes, $AFFECTS, undefined, false);
-    GlobalQueue._releaseAffectsScope ||= node => {
-      const entry = affectsScopes.get(node);
-      if (!entry) return;
-      affectsScopes.delete(node);
-      for (let i = 0; i < entry.inherited.length; i++)
-        GlobalQueue._releaseAffectsMark(entry.inherited[i]);
-    };
     let entry = affectsScopes.get(carrier);
     if (!entry) affectsScopes.set(carrier, (entry = { scope: new Set(), inherited: [] }));
     const result = [carrier];
     walkAffectsScope(target[$PROXY], entry, result, target[STORE_LOOKUP], new Set());
     return result;
   }
-  if (nodes[key]) return [nodes[key]];
-  const layer = getOverlayLayer(target, key);
-  const raw = layer ? layer[key] : target[STORE_VALUE][key];
-  const prev = raw === $DELETED ? undefined : raw;
-  return [upsertStoreNode(target, nodes, key, prev, target[STORE_SNAPSHOT_PROPS])];
+  let node = nodes[key];
+  if (!node) {
+    const layer = getOverlayLayer(target, key);
+    const raw = layer ? layer[key] : target[STORE_VALUE][key];
+    node = upsertStoreNode(
+      target,
+      nodes,
+      key,
+      raw === $DELETED ? undefined : raw,
+      target[STORE_SNAPSHOT_PROPS]
+    );
+  }
+  // Keyed marks resolve by identity too (#2904): another store family's
+  // proxy can share this record's raw (a derived store swaps its backing to
+  // the source's raw when its projection lands), and reads through it never
+  // touch this target's node map. Scope is exactly the owning record's raw,
+  // narrowed to this key for witness and birth inheritance.
+  let entry = affectsScopes.get(node);
+  if (!entry) affectsScopes.set(node, (entry = { scope: new Set(), inherited: [], key }));
+  entry.scope.add(target[STORE_VALUE]);
+  return [node];
 }
 function trackSelf(target, symbol = $TRACK) {
   if (!getObserver()) return;
@@ -5336,17 +5563,44 @@ function mergedOverlay(target) {
   const opt = target[STORE_OPTIMISTIC_OVERRIDE];
   return override && opt ? { ...override, ...opt } : (opt ?? override);
 }
-function getKeys(source, override, enumerable = true) {
+function getKeysImpl(source, override, enumerable, symbols) {
   // Plain objects can't trigger proxy traps — only pay for the untrack
   // closure when the source is itself a wrapped store (store-in-store).
   const baseKeys = source[$TARGET]
-    ? untrack(() => (enumerable ? Object.keys(source) : Reflect.ownKeys(source)))
+    ? untrack(() =>
+        enumerable
+          ? symbols
+            ? ownEnumerableKeys(source)
+            : Object.keys(source)
+          : Reflect.ownKeys(source)
+      )
     : enumerable
-      ? Object.keys(source)
+      ? symbols
+        ? ownEnumerableKeysPlain(source)
+        : Object.keys(source)
       : Reflect.ownKeys(source);
-  if (!override) return baseKeys;
+  return override ? mergeOverrideKeys(baseKeys, override) : baseKeys;
+}
+function getKeys(source, override, enumerable = true) {
+  return getKeysImpl(source, override, enumerable, false);
+}
+function getStoreKeys(source, override) {
+  return getKeysImpl(source, override, true, true);
+}
+function getStoreSymbols(source, override) {
+  const symbols = source[$TARGET]
+    ? untrack(() => ownEnumerableSymbols(source))
+    : ownEnumerableSymbols(source);
+  return override ? mergeOverrideKeys(symbols, override, true) : symbols;
+}
+// Shared override-layer merge for key enumeration: adds live override keys,
+// drops $DELETED ones. `symbolsOnly` scopes the override scan for the
+// array-metadata passes.
+function mergeOverrideKeys(baseKeys, override, symbolsOnly) {
   const keys = new Set(baseKeys);
-  const overrides = Reflect.ownKeys(override);
+  const overrides = symbolsOnly
+    ? Object.getOwnPropertySymbols(override)
+    : Reflect.ownKeys(override);
   for (const key of overrides) {
     if (override[key] !== $DELETED) keys.add(key);
     else keys.delete(key);
@@ -5412,6 +5666,19 @@ function armOptimisticStoreWrite(target, store) {
     GlobalQueue._trackOptimisticStore(store);
   }
 }
+/**
+ * Records which transition owns an optimistic layer entry (#2899), so a
+ * settling action only consumes its own keys — the layer is store-wide, but
+ * concurrent actions writing disjoint keys must revert independently, exactly
+ * like optimistic signal nodes do via the transition's _optimisticNodes.
+ * `activeTransition` is the write's transaction (action() opens it before the
+ * body runs); null marks an ambient write that clears at plain flush end.
+ * Same-key writes across actions keep last-write-wins layer semantics.
+ */
+function stampOptimisticOwner(target, overrideKey, property) {
+  if (overrideKey === STORE_OPTIMISTIC_OVERRIDE)
+    (target[STORE_OPTIMISTIC_OWNERS] ??= Object.create(null))[property] = activeTransition;
+}
 function upsertStoreNode(target, nodes, property, prev, snapshotProps) {
   if (nodes[property]) return nodes[property];
   const initial = isWrappable(prev) ? wrap(prev, target) : prev;
@@ -5456,12 +5723,26 @@ function notifyStoreProperty(target, property, mode, value, prev, prevHas) {
   notifySelf(target);
 }
 let Writing = null;
+/**
+ * A derived store's seed is a draft for the derive function, never an
+ * observable value (#2897): until the firewall first resolves there is
+ * nothing to read, so every consumer path throws NotReady — tracked reads
+ * through their node (core read()), and the untracked fall-throughs in the
+ * traps through this guard. Returning the seed leaked it; returning
+ * `undefined` would break non-nullable types. Callers exempt the firewall
+ * itself (the derive function works its own draft while uninitialized).
+ */
+function throwIfUninitialized(target) {
+  const firewall = target[STORE_FIREWALL];
+  if (firewall && firewall._statusFlags & STATUS_UNINITIALIZED)
+    throw firewall._error ?? new NotReadyError(firewall);
+}
 const storeTraps = {
   get(target, property, receiver) {
     if (property === $TARGET) return target;
     if (property === $PROXY) return receiver;
     if (property === $REFRESH) return target[STORE_FIREWALL];
-    if (pendingCheckActive) witnessAffectsMark(target);
+    if (pendingCheckActive) witnessAffectsMark(target, property);
     if (property === $TRACK) {
       trackSelf(target);
       return receiver;
@@ -5542,24 +5823,26 @@ const storeTraps = {
       }
     }
     if (strictRead && typeof property === "string") {
-      const message =
-        `[STRICT_READ_UNTRACKED] Reactive value read directly in ${strictRead} will not update. ` +
-        `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
-      emitDiagnostic({
-        code: "STRICT_READ_UNTRACKED",
-        kind: "strict-read",
-        severity: "warn",
-        message,
-        nodeName: String(property),
-        data: { strictRead, property: String(property), source: "store" }
+      // Safeguard parity with core read() (#2897): untracked store reads skip
+      // node creation (and with it read()'s PENDING_ASYNC_UNTRACKED_READ
+      // check), so a derived store's in-flight firewall must be consulted
+      // here — otherwise a component-body read of a refetching store silently
+      // returns a value the reader can never observe updating.
+      if ((target[STORE_FIREWALL]?._statusFlags ?? 0) & STATUS_PENDING)
+        throwPendingUntrackedRead(strictRead, { nodeName: property });
+      warnStrictReadUntracked(strictRead, {
+        nodeName: property,
+        data: { strictRead, property, source: "store" }
       });
-      console.warn(message);
     }
+    // Untracked fall-through (tracked reads already threw via their node in
+    // read(); the dev strictRead error above wins first for memo parity).
+    if (!selfRead) throwIfUninitialized(target);
     return isWrappable(value) ? wrap(value, target) : value;
   },
   has(target, property) {
     if (property === $PROXY || property === $TRACK || property === "__proto__") return true;
-    if (pendingCheckActive) witnessAffectsMark(target);
+    if (pendingCheckActive) witnessAffectsMark(target, property);
     const hasLayer = getOverlayLayer(target, property);
     const has = hasLayer ? hasLayer[property] !== $DELETED : property in target[STORE_VALUE];
     if (writeOnly(target[$PROXY]) || getObserver() === target[STORE_FIREWALL]) return has;
@@ -5574,6 +5857,7 @@ const storeTraps = {
     if (getObserver()) {
       return read(getNode(target, nodes, property, has));
     }
+    throwIfUninitialized(target);
     return has;
   },
   set(target, property, rawValue) {
@@ -5603,12 +5887,18 @@ const storeTraps = {
         const nextLength = isArrayIndexWrite && nextIndex > len ? nextIndex : undefined;
         if (prev === value && nextLength === undefined) return true;
         armOptimisticStoreWrite(target, store);
-        if (value !== undefined && value === base && nextLength === undefined)
+        if (value !== undefined && value === base && nextLength === undefined) {
           delete target[overrideKey]?.[property];
-        else {
+          if (overrideKey === STORE_OPTIMISTIC_OVERRIDE)
+            delete target[STORE_OPTIMISTIC_OWNERS]?.[property];
+        } else {
           const override = target[overrideKey] || (target[overrideKey] = Object.create(null));
           override[property] = value;
-          if (nextLength !== undefined) override.length = nextLength;
+          stampOptimisticOwner(target, overrideKey, property);
+          if (nextLength !== undefined) {
+            override.length = nextLength;
+            stampOptimisticOwner(target, overrideKey, "length");
+          }
         }
         notifyStoreProperty(target, property, "set", value, prev, prevHas);
         // Shrinking an array's length must remove the truncated indices, otherwise
@@ -5627,6 +5917,7 @@ const storeTraps = {
             const prevIndex = i in override ? override[i] : state[i];
             if (!(i in override) && !(i in state)) continue;
             override[i] = $DELETED;
+            stampOptimisticOwner(target, overrideKey, i);
             notifyStoreProperty(target, i, "delete", undefined, prevIndex, true);
           }
         }
@@ -5670,6 +5961,7 @@ const storeTraps = {
           property,
           normalizedDescriptor
         );
+        stampOptimisticOwner(target, overrideKey, property);
         notifyStoreProperty(target, property, "invalidate");
         if (true) {
           const next =
@@ -5699,9 +5991,12 @@ const storeTraps = {
         ) {
           armOptimisticStoreWrite(target, target[$PROXY]);
           (target[overrideKey] || (target[overrideKey] = Object.create(null)))[property] = $DELETED;
+          stampOptimisticOwner(target, overrideKey, property);
         } else if (target[overrideKey] && property in target[overrideKey]) {
           armOptimisticStoreWrite(target, target[$PROXY]);
           delete target[overrideKey][property];
+          if (overrideKey === STORE_OPTIMISTIC_OVERRIDE)
+            delete target[STORE_OPTIMISTIC_OWNERS]?.[property];
         } else return true;
         notifyStoreProperty(target, property, "delete", undefined, prev, true);
       });
@@ -5710,7 +6005,15 @@ const storeTraps = {
   },
   ownKeys(target) {
     if (pendingCheckActive) witnessAffectsMark(target);
-    if (getObserver() !== target[STORE_FIREWALL]) trackSelf(target);
+    if (getObserver() !== target[STORE_FIREWALL]) {
+      trackSelf(target);
+      // trackSelf no-ops untracked, so enumeration of an unresolved derived
+      // store would otherwise leak the seed's structure (#2897). The write
+      // path is exempt (like the get/has traps' writeOnly early returns):
+      // the first landing's reconcile enumerates the store while
+      // STATUS_UNINITIALIZED is still set — it IS the initialization.
+      if (!getObserver() && !writeOnly(target[$PROXY])) throwIfUninitialized(target);
+    }
     // Merge optimistic override with regular override for key enumeration
     let keys = getKeys(target[STORE_VALUE], target[STORE_OVERRIDE], false);
     if (target[STORE_OPTIMISTIC_OVERRIDE]) {
@@ -5852,7 +6155,7 @@ function propagateAffectsMark(node) {
   const sentinel = getAffectsSentinel(node);
   const error = new NotReadyError(sentinel);
   forEachDependent(node, sub => {
-    if (sub._pendingSource !== sentinel && !sub._pendingSources?.has(sentinel)) {
+    if (!sub._pendingSources?.has(sentinel)) {
       notifyStatus(sub, STATUS_PENDING, error);
     }
   });
@@ -5895,7 +6198,7 @@ function markAffects(node) {
 /**
  * Registers one `affects()` mark on a node: counts it, records the
  * registration with the current transaction (after initTransition the queue's
- * array aliases the active transition's, mirroring `_optimisticNodes`), and
+ * batch IS the active transition, mirroring `_optimisticNodes`), and
  * propagates STATUS_PENDING downstream on the status rails so everything
  * DERIVED from the marked data reads pending too. Propagation runs on every
  * registration (not just the first): subscribers gained since an earlier
@@ -5903,7 +6206,7 @@ function markAffects(node) {
  */
 function registerAffectsMark(node) {
   markAffects(node);
-  globalQueue._affectsNodes.push(node);
+  globalQueue._batch._affectsNodes.push(node);
   propagateAffectsMark(node);
   schedule();
 }
@@ -5946,7 +6249,7 @@ function onlyMarkPending(el) {
     for (const s of sources) if (!s._affectsFor) return false;
     return true;
   }
-  return !!el._pendingSource?._affectsFor;
+  return false;
 }
 /**
  * Collect the still-live marked nodes behind a pended owner's sentinel
@@ -5960,11 +6263,7 @@ function onlyMarkPending(el) {
  * `GlobalQueue._collectMarkSources`, gated on `activeAffectsMarks`.
  */
 function collectMarkSources(el, into) {
-  const single = el._pendingSource;
-  if (single) {
-    const marked = single._affectsFor;
-    if (marked && marked._affectsCount) into.push(marked);
-  } else if (el._pendingSources) {
+  if (el._pendingSources) {
     for (const s of el._pendingSources) {
       const marked = s._affectsFor;
       if (marked && marked._affectsCount) into.push(marked);
@@ -6051,54 +6350,90 @@ function createOptimisticStore(first, second, options) {
 }
 // Clear the optimistic overrides of a settling batch of stores and notify
 // signals. Owns the whole batch (iterate + clear + reschedule) so the
-// scheduler's flush tail carries only a size-guarded hook call.
-function clearOptimisticStores(stores) {
+// scheduler's flush tail carries only a size-guarded hook call. The
+// completing transition scopes each clear to its own layer keys (#2899).
+function clearOptimisticStores(stores, completing) {
   for (const store of stores) {
     const target = store[$TARGET];
-    if (target?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(target);
+    if (target?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(target, completing);
   }
   stores.clear();
   schedule();
 }
-function clearOptimisticOverride(target) {
+/**
+ * Consume optimistic layer entries and reset their backing nodes to base.
+ * With `completing` (settle path, #2899) only entries the settling
+ * transaction owns are consumed — the layer is store-wide but concurrent
+ * actions revert independently, so keys stamped by a still-in-flight
+ * transition survive (node-level overrides already have this granularity via
+ * _optimisticNodes; this is the layer's half). `null` consumes ambient
+ * (transaction-less) entries at plain flush end. Omitted (projection landing:
+ * fresh authoritative data) consumes everything — the correction supersedes
+ * every tentative layer.
+ */
+function clearOptimisticOverride(target, completing) {
   const override = target[STORE_OPTIMISTIC_OVERRIDE];
   if (!override) return;
   const nodes = target[STORE_NODE];
-  delete target[STORE_OPTIMISTIC_OVERRIDE];
-  // Notify signals for all overridden properties
+  const owners = target[STORE_OPTIMISTIC_OWNERS];
+  const scoped = completing !== undefined;
+  let cleared = false;
+  let remaining = false;
   // Use projectionWriteActive to bypass optimistic signal behavior (no lane creation)
   // This ensures reversion effects go to regular queues, not lane queues
   const wasProjectionWriteActive = projectionWriteActive;
   setProjectionWriteActive(true);
   try {
-    if (nodes) {
-      for (const key of Reflect.ownKeys(override)) {
-        if (nodes[key]) {
-          const node = nodes[key];
-          // Clear lane association so effects go to regular queue
-          node._optimisticLane = undefined;
-          // Re-read from base — the optimistic layer was deleted above, so the
-          // overlay resolves to STORE_OVERRIDE or STORE_VALUE.
-          const layer = getOverlayLayer(target, key);
-          const baseValue = layer ? layer[key] : target[STORE_VALUE][key];
-          const value = baseValue === $DELETED ? undefined : baseValue;
-          const next = isWrappable(value) ? wrap(value, target) : value;
-          const prev = visibleNodeValue(node);
-          node._overrideValue = NOT_PENDING;
-          node._pendingValue = NOT_PENDING;
-          node._value = next;
-          if (!node._equals || !node._equals(prev, next)) {
-            insertSubs(node, true);
-            schedule();
+    for (const key of Reflect.ownKeys(override)) {
+      if (scoped) {
+        let owner = owners?.[key] ?? null;
+        // Resolve merge chains (entangled actions settle as one); path-compress
+        // so later keys skip the walk. A dead owner (`_done === true`) settled
+        // through some other path — never strand its entry. A null owner is an
+        // ambient write: its batch belongs to whichever transaction adopted it
+        // (initTransition mid-batch) or to the plain flush, so it clears on
+        // whichever clear call reaches this store first.
+        if (owner) {
+          if (typeof owner._done === "object") owner = owners[key] = currentTransition(owner);
+          if (owner !== completing && owner._done !== true) {
+            remaining = true;
+            continue;
           }
         }
       }
-      // Notify $TRACK
-      if (nodes[$TRACK]) {
-        nodes[$TRACK]._optimisticLane = undefined;
-        notifySelf(target);
+      delete override[key];
+      if (owners) delete owners[key];
+      cleared = true;
+      const node = nodes?.[key];
+      if (node) {
+        // Clear lane association so effects go to regular queue
+        node._optimisticLane = undefined;
+        // Re-read from base — this key left the optimistic layer above, so the
+        // overlay resolves to STORE_OVERRIDE or STORE_VALUE.
+        const layer = getOverlayLayer(target, key);
+        const baseValue = layer ? layer[key] : target[STORE_VALUE][key];
+        const value = baseValue === $DELETED ? undefined : baseValue;
+        const next = isWrappable(value) ? wrap(value, target) : value;
+        const prev = visibleNodeValue(node);
+        node._overrideValue = NOT_PENDING;
+        node._overrideOwner = null;
+        node._pendingValue = NOT_PENDING;
+        node._value = next;
+        if (!node._equals || !node._equals(prev, next)) {
+          insertSubs(node, true);
+          schedule();
+        }
       }
     }
+    if (!remaining) {
+      delete target[STORE_OPTIMISTIC_OVERRIDE];
+      delete target[STORE_OPTIMISTIC_OWNERS];
+    }
+    // Notify $TRACK
+    if (cleared && nodes?.[$TRACK]) {
+      nodes[$TRACK]._optimisticLane = undefined;
+      notifySelf(target);
+    }
   } finally {
     setProjectionWriteActive(wasProjectionWriteActive);
   }
@@ -6309,6 +6644,21 @@ function snapshotImpl(item, track, map, lookup) {
         result[i] = unwrapped;
       }
     }
+    // Enumerate array symbols separately to avoid scanning indices twice.
+    // Spread copies omit symbols, so assign them after the numeric walk.
+    const symbols = lookup ? getStoreSymbols(item, override) : [];
+    for (let i = 0, l = symbols.length; i < l; i++) {
+      const prop = symbols[i];
+      const desc = getPropertyDescriptor(item, override, prop);
+      if (!desc || desc.get) continue;
+      v = override && prop in override ? override[prop] : item[prop];
+      if (track && isWrappable(v)) wrap(v, target);
+      unwrapped = snapshotImpl(v, track, map, lookup);
+      if (unwrapped !== v || result) {
+        if (!result) map.set(item, (result = Object.assign([...item], item)));
+        result[prop] = unwrapped;
+      }
+    }
     // Deleted trailing slots are skipped above, so restore length to preserve
     // holes instead of truncating the copy (#2846) — mirrors unwrapStoreValue.
     if (result) result.length = len;
@@ -6316,7 +6666,9 @@ function snapshotImpl(item, track, map, lookup) {
     // Specialized walk for the common no-overlay case (from #2756): the own
     // descriptor gives the value directly, so each property is read once with
     // no overlay membership checks.
-    const keys = getKeys(item, undefined);
+    // A lookup means this object belongs to an immutable store backing tree,
+    // even if that nested value has not needed its own proxy yet.
+    const keys = lookup ? getStoreKeys(item, undefined) : getKeys(item, undefined);
     for (let i = 0, l = keys.length; i < l; i++) {
       const prop = keys[i];
       const desc = Object.getOwnPropertyDescriptor(item, prop);
@@ -6332,7 +6684,9 @@ function snapshotImpl(item, track, map, lookup) {
       }
     }
   } else {
-    const keys = getKeys(item, override);
+    // An override only exists on a store record, and the target branch above
+    // always set `lookup` alongside it — so this branch is always store-keyed.
+    const keys = getStoreKeys(item, override);
     for (let i = 0, l = keys.length; i < l; i++) {
       let prop = keys[i];
       const desc = getPropertyDescriptor(item, override, prop);
@@ -6599,6 +6953,15 @@ function mapArray(list, map, options) {
   return accessor(node);
 }
 const pureOptions = { ownedWrite: true };
+// Exception safety (#2903): a map callback can throw NotReadyError mid-pass
+// (async read), and the computed re-runs the whole pass after settle. Every
+// pass therefore STAGES its work — new rows are created into temp arrays and
+// removals are deferred — and commits to `this` only after every mapper
+// succeeded. An aborted pass disposes just the owners it created and leaves
+// `_items`/`_mappings`/`_nodes`/`_rows`/`_indexes`/`_len` exactly as they
+// were, so the retry diffs against uncorrupted state. Consequence of the
+// strong-abort ordering: removed rows now dispose AFTER the pass's new rows
+// are created (you cannot destroy state before knowing the pass will land).
 function updateKeyedMap() {
   const newItems = this._list() || [],
     newLen = newItems.length;
@@ -6606,25 +6969,26 @@ function updateKeyedMap() {
   runWithOwner(this._owner, () => {
     let i,
       j,
+      rows,
+      indexes,
+      // Mappers write freshly-created row/index signals into the STAGE
+      // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
       mapper = this._rows
         ? this._byIndex
           ? () => {
-              this._rows[j] = signal(newItems[j], pureOptions);
-              return this._map(accessor(this._rows[j]), j);
+              rows[j] = signal(newItems[j], pureOptions);
+              return this._map(accessor(rows[j]), j);
             }
           : () => {
-              this._rows[j] = signal(newItems[j], pureOptions);
-              this._indexes && (this._indexes[j] = signal(j, pureOptions));
-              return this._map(
-                accessor(this._rows[j]),
-                this._indexes ? accessor(this._indexes[j]) : undefined
-              );
+              rows[j] = signal(newItems[j], pureOptions);
+              indexes && (indexes[j] = signal(j, pureOptions));
+              return this._map(accessor(rows[j]), indexes ? accessor(indexes[j]) : undefined);
             }
         : this._indexes
           ? () => {
               const item = newItems[j];
-              this._indexes[j] = signal(j, pureOptions);
-              return this._map(item, accessor(this._indexes[j]));
+              indexes[j] = signal(j, pureOptions);
+              return this._map(item, accessor(indexes[j]));
             }
           : () => {
               const item = newItems[j];
@@ -6642,19 +7006,31 @@ function updateKeyedMap() {
         this._indexes && (this._indexes = []);
       }
       if (this._fallback && !this._mappings[0]) {
-        // create fallback
+        // an aborted fallback attempt leaves an owner without a mapping;
+        // dispose it before re-creating
+        this._nodes[0]?.dispose();
         this._mappings[0] = runWithOwner((this._nodes[0] = createOwner()), this._fallback);
       }
     }
     // fast path for new create
     else if (this._len === 0) {
-      // dispose previous fallback
-      if (this._nodes[0]) this._nodes[0].dispose();
-      this._mappings = new Array(newLen);
-      for (j = 0; j < newLen; j++) {
-        this._items[j] = newItems[j];
-        this._mappings[j] = runWithOwner((this._nodes[j] = createOwner()), mapper);
+      const mappings = new Array(newLen);
+      const nodes = new Array(newLen);
+      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);
+      } catch (err) {
+        for (i = 0; i <= j; i++) nodes[i]?.dispose();
+        throw err;
       }
+      // commit
+      if (this._nodes[0]) this._nodes[0].dispose(); // previous fallback
+      this._mappings = mappings;
+      this._nodes = nodes;
+      rows && (this._rows = rows);
+      indexes && (this._indexes = indexes);
+      this._items = newItems.slice(0);
       this._len = newLen;
     } else {
       let start,
@@ -6664,10 +7040,12 @@ function updateKeyedMap() {
         key,
         newIndices,
         newIndicesNext,
+        removed,
+        created,
         temp = new Array(newLen),
-        tempNodes = new Array(newLen),
-        tempRows = this._rows ? new Array(newLen) : undefined,
-        tempIndexes = this._indexes ? new Array(newLen) : undefined;
+        tempNodes = new Array(newLen);
+      rows = this._rows ? new Array(newLen) : undefined;
+      indexes = this._indexes ? new Array(newLen) : undefined;
       // skip common prefix
       for (
         start = 0, end = Math.min(this._len, newLen);
@@ -6689,8 +7067,8 @@ function updateKeyedMap() {
       ) {
         temp[newEnd] = this._mappings[end];
         tempNodes[newEnd] = this._nodes[end];
-        tempRows && (tempRows[newEnd] = this._rows[end]);
-        tempIndexes && (tempIndexes[newEnd] = this._indexes[end]);
+        rows && (rows[newEnd] = this._rows[end]);
+        indexes && (indexes[newEnd] = this._indexes[end]);
       }
       // 0) prepare a map of all indices in newItems, scanning backwards so we encounter them in natural order
       newIndices = new Map();
@@ -6702,7 +7080,7 @@ function updateKeyedMap() {
         newIndicesNext[j] = i === undefined ? -1 : i;
         newIndices.set(key, j);
       }
-      // 1) step through all old items and see if they can be found in the new set; if so, save them in a temp array and mark them moved; if not, exit them
+      // 1) step through all old items and see if they can be found in the new set; if so, save them in a temp array and mark them moved; 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;
@@ -6710,32 +7088,40 @@ function updateKeyedMap() {
         if (j !== undefined && j !== -1) {
           temp[j] = this._mappings[i];
           tempNodes[j] = this._nodes[i];
-          tempRows && (tempRows[j] = this._rows[i]);
-          tempIndexes && (tempIndexes[j] = this._indexes[i]);
+          rows && (rows[j] = this._rows[i]);
+          indexes && (indexes[j] = this._indexes[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
-        } else this._nodes[i].dispose();
+        } else (removed ??= []).push(this._nodes[i]);
       }
-      // 2) set all the new values, pulling from the temp array if copied, otherwise entering the new value
+      // 2) create new rows into the temp arrays; an abort disposes only these
+      try {
+        for (j = start; j < newLen; j++) {
+          if (j in temp) continue;
+          (created ??= []).push((tempNodes[j] = createOwner()));
+          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 positions, then dispose exited rows
       for (j = start; j < newLen; j++) {
-        if (j in temp) {
-          this._mappings[j] = temp[j];
-          this._nodes[j] = tempNodes[j];
-          if (tempRows) {
-            this._rows[j] = tempRows[j];
-            setSignal(this._rows[j], newItems[j]);
-          }
-          if (tempIndexes) {
-            this._indexes[j] = tempIndexes[j];
-            setSignal(this._indexes[j], j);
-          }
-        } else {
-          this._mappings[j] = runWithOwner((this._nodes[j] = createOwner()), mapper);
+        this._mappings[j] = temp[j];
+        this._nodes[j] = tempNodes[j];
+        if (rows) {
+          this._rows[j] = rows[j];
+          setSignal(this._rows[j], newItems[j]);
+        }
+        if (indexes) {
+          this._indexes[j] = indexes[j];
+          setSignal(this._indexes[j], j);
         }
       }
-      // 3) in case the new set is shorter than the old, set the length of the mapped array
+      if (removed) for (i = 0; i < removed.length; i++) removed[i].dispose();
+      // 4) in case the new set is shorter than the old, set the length of the mapped array
       this._mappings = this._mappings.slice(0, (this._len = newLen));
-      // 4) save a copy of the mapped items for the next update
+      // 5) save a copy of the mapped items for the next update
       this._items = newItems.slice(0);
     }
   });
@@ -6767,22 +7153,32 @@ function repeat(count, map, options) {
         }
       }
     : map;
-  const node = computed(
-    updateRepeat.bind({
-      _owner: createOwner(),
-      _len: 0,
-      _offset: 0,
-      _count: count,
-      _map: wrappedMap,
-      _nodes: [],
-      _mappings: [],
-      _from: options?.from,
-      _fallback: options?.fallback
-    })
-  );
+  const data = {
+    _owner: createOwner(),
+    _len: 0,
+    _offset: 0,
+    _count: count,
+    _map: wrappedMap,
+    _nodes: [],
+    _mappings: [],
+    _from: options?.from,
+    _fallback: options?.fallback
+  };
+  const node = computed(updateRepeat.bind(data));
+  // Same as mapArray: untracked reads inside the internal owner resolve via
+  // _parentComputed, so async reads in row callbacks register with the node
+  // (pending tracking + post-settle retry) instead of vanishing.
+  data._owner._parentComputed = node;
   node._config &= ~CONFIG_AUTO_DISPOSE;
   return accessor(node);
 }
+// Same staged-commit discipline as `updateKeyedMap` (#2903): the retained
+// window overlap is copied into fresh arrays, missing indexes are created
+// into them, and `this` is only touched — including disposal of rows leaving
+// the window — after every `_map` call succeeded. A NotReadyError mid-pass
+// disposes only the owners this pass created and leaves prior state intact
+// for the post-settle retry. The overlap math also subsumes the previous
+// disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
   const newLen = this._count();
   const from = this._from?.() || 0;
@@ -6793,67 +7189,46 @@ function updateRepeat() {
         this._nodes = [];
         this._mappings = [];
         this._len = 0;
-        // Reset offset to match the cleared data. Without this, a subsequent
-        // nonzero render with a smaller `from` would enter the end-clear loop
-        // with `prevTo = stale_offset + 0` > `to` and dispose `_nodes[-1]`
-        // (#2767, repro 2).
+        // Reset offset to match the cleared data (#2767, repro 2).
         this._offset = 0;
       }
       if (this._fallback && !this._mappings[0]) {
-        // create fallback
+        // an aborted fallback attempt leaves an owner without a mapping;
+        // dispose it before re-creating
+        this._nodes[0]?.dispose();
         this._mappings[0] = runWithOwner((this._nodes[0] = createOwner()), this._fallback);
       }
       return;
     }
     const to = from + newLen;
     const prevTo = this._offset + this._len;
-    // remove fallback
-    if (this._len === 0 && this._nodes[0]) this._nodes[0].dispose();
-    // Disjoint windows have no rows to retain; replace them wholesale.
-    if (from >= prevTo || to <= this._offset) {
-      for (let i = 0; i < this._len; i++) this._nodes[i].dispose();
-      this._nodes = new Array(newLen);
-      this._mappings = new Array(newLen);
-      for (let i = 0; i < newLen; i++)
-        this._mappings[i] = runWithOwner((this._nodes[i] = createOwner()), () =>
-          this._map(from + i)
-        );
-      this._offset = from;
-      this._len = newLen;
-      return;
+    // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
+    // windows are disjoint or when coming from empty/fallback.
+    const keepStart = Math.max(from, this._offset);
+    const keepEnd = Math.min(to, prevTo);
+    const mappings = new Array(newLen);
+    const nodes = new Array(newLen);
+    for (let i = keepStart; i < keepEnd; i++) {
+      nodes[i - from] = this._nodes[i - this._offset];
+      mappings[i - from] = this._mappings[i - this._offset];
     }
-    // clear the end
-    for (let i = to; i < prevTo; i++) this._nodes[i - this._offset].dispose();
-    if (this._offset < from) {
-      // clear beginning — `_nodes` is local-indexed, so the rows leaving the
-      // front sit at local positions 0..(from - _offset), clamped to old len.
-      const removed = from - this._offset;
-      for (let i = 0; i < removed && i < this._len; i++) this._nodes[i].dispose();
-      // shift indexes
-      this._nodes.splice(0, removed);
-      this._mappings.splice(0, removed);
-    } else if (this._offset > from) {
-      // shift indexes
-      let i = prevTo - this._offset - 1;
-      let difference = this._offset - from;
-      this._nodes.length = this._mappings.length = newLen;
-      while (i >= difference) {
-        this._nodes[i] = this._nodes[i - difference];
-        this._mappings[i] = this._mappings[i - difference];
-        i--;
-      }
-      for (let i = 0; i < difference; i++) {
-        this._mappings[i] = runWithOwner((this._nodes[i] = createOwner()), () =>
-          this._map(i + from)
-        );
+    try {
+      for (let i = from; i < to; i++) {
+        if (i >= keepStart && i < keepEnd) continue;
+        mappings[i - from] = runWithOwner((nodes[i - from] = createOwner()), () => this._map(i));
       }
-    }
-    for (let i = prevTo; i < to; i++) {
-      this._mappings[i - from] = runWithOwner((this._nodes[i - from] = createOwner()), () =>
-        this._map(i)
-      );
-    }
-    this._mappings = this._mappings.slice(0, newLen);
+    } catch (err) {
+      for (let i = from; i < to; i++)
+        if ((i < keepStart || i >= keepEnd) && nodes[i - from]) nodes[i - from].dispose();
+      throw err;
+    }
+    // commit: dispose the previous fallback or the rows leaving the window
+    if (this._len === 0) this._nodes[0]?.dispose();
+    else
+      for (let i = this._offset; i < prevTo; i++)
+        if (i < from || i >= to) this._nodes[i - this._offset].dispose();
+    this._mappings = mappings;
+    this._nodes = nodes;
     this._offset = from;
     this._len = newLen;
   });