@solidjs/signals 2.0.0-beta.30 → 2.0.0-beta.31

package/dist/dev.js

@@ -916,6 +916,12 @@ class GlobalQueue extends Queue {
       }
       if (batch._affectsNodes.length) activeTransition._affectsNodes.push(...batch._affectsNodes);
       for (const store of batch._optimisticStores) activeTransition._optimisticStores.add(store);
+      // Gated readers recorded against the ambient batch move with it: their
+      // replay-at-commit now happens at the transaction's completion.
+      if (batch._gatedSubs.size) {
+        for (const sub of batch._gatedSubs) activeTransition._gatedSubs.add(sub);
+        batch._gatedSubs.clear();
+      }
       currentBatch = this._batch = activeTransition;
     }
     for (const lane of activeLanes) {
@@ -1003,13 +1009,19 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
     // which installed the engine's hooks.
     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) {
-      for (const sub of completingTransition._gatedSubs) {
+    // so they re-run with the now-committed values visible. The ambient batch
+    // replays too — laneReadsCommitted records readers whose committed-view
+    // read hid a same-tick plain write that just committed above (#2963).
+    if (batch._gatedSubs.size) {
+      for (const sub of batch._gatedSubs) {
         if (sub._flags & REACTIVE_DISPOSED) continue;
         enqueueSub(sub);
       }
-      completingTransition._gatedSubs.clear();
+      batch._gatedSubs.clear();
+      // A completing transition keeps the outer flush loop alive by itself;
+      // the ambient batch needs the re-arm or the replay sits in the heap
+      // until the next unrelated write.
+      schedule();
     }
     // Declared motion ends with the transaction: settle (or plain flush end
     // for ambient marks) releases each registration's refcount. A non-empty
@@ -3503,12 +3515,25 @@ function gatedRead(el, owner, c) {
  * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
  */
 function laneReadsCommitted(el, owner, c) {
-  return (
+  if (
     el._overrideValue !== undefined ||
     !!el._optimisticLane ||
-    (owner === el && stale && c._parentSource !== el) ||
     !!(owner._statusFlags & STATUS_PENDING)
-  );
+  )
+    return true;
+  if (owner === el && stale && c._parentSource !== el) {
+    // The committed view can hide a same-tick ambient write (a lane member —
+    // even just an isPending companion flip — puts the reader "under a lane"
+    // against unrelated plain writes). With no transaction the write commits
+    // at THIS flush's end with no re-delivery, so record the reader for
+    // replay at commit — the same contract gatedRead provides when a
+    // transaction is active (#2963). If a transaction forms mid-flush,
+    // initTransition carries the recording over to it.
+    if (el._pendingValue !== NOT_PENDING && activeTransition === null)
+      globalQueue._batch._gatedSubs.add(c);
+    return true;
+  }
+  return false;
 }
 /**
  * recompute()'s lane posture: resolve the node's own lane (own=true), or adopt

package/dist/node.cjs

@@ -806,6 +806,12 @@ class GlobalQueue extends Queue {
             }
             if (t.G.length) activeTransition.G.push(...t.G);
             for (const e of t.V) activeTransition.V.add(e);
+            // Gated readers recorded against the ambient batch move with it: their
+            // replay-at-commit now happens at the transaction's completion.
+                        if (t.q.size) {
+                for (const e of t.q) activeTransition.q.add(e);
+                t.q.clear();
+            }
             currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
@@ -867,10 +873,10 @@ function commitPendingNode(e) {
         e.We = e.k;
         e.k = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.Fe && e.Fe !== EFFECT_TRACKED) e.xe = true;
+                if (e.Fe && e.Fe !== EFFECT_TRACKED) e.Qe = true;
     }
     t.D &= ~REACTIVE_MANUAL_WRITE;
-    if (!(t.Qe & STATUS_PENDING)) t.Qe &= ~STATUS_UNINITIALIZED;
+    if (!(t.xe & STATUS_PENDING)) t.xe &= ~STATUS_UNINITIALIZED;
     if (t.He !== null || t.Me !== null) GlobalQueue.ee(t, false, true);
     if (e._ || e.R) GlobalQueue.Ee(e);
 }
@@ -899,13 +905,19 @@ function finalizePureQueue(e = null, t = false) {
         // which installed the engine's hooks.
                 if (t.L.length) GlobalQueue.Ie(t.L);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
-        // so they re-run with the now-committed values visible.
-                if (e && e.q.size) {
-            for (const t of e.q) {
-                if (t.D & REACTIVE_DISPOSED) continue;
-                enqueueSub(t);
+        // so they re-run with the now-committed values visible. The ambient batch
+        // replays too — laneReadsCommitted records readers whose committed-view
+        // read hid a same-tick plain write that just committed above (#2963).
+                if (t.q.size) {
+            for (const e of t.q) {
+                if (e.D & REACTIVE_DISPOSED) continue;
+                enqueueSub(e);
             }
-            e.q.clear();
+            t.q.clear();
+            // A completing transition keeps the outer flush loop alive by itself;
+            // the ambient batch needs the re-arm or the replay sits in the heap
+            // until the next unrelated write.
+                        schedule();
         }
         // Declared motion ends with the transaction: settle (or plain flush end
         // for ambient marks) releases each registration's refcount. A non-empty
@@ -1006,7 +1018,7 @@ function reporterBlocksSource(e, t) {
             e = e.t;
         }
     }
-    return !!(e.Qe & STATUS_PENDING && e.me instanceof NotReadyError && e.me.source === t);
+    return !!(e.xe & STATUS_PENDING && e.me instanceof NotReadyError && e.me.source === t);
 }
 
 function transitionComplete(e) {
@@ -1022,7 +1034,7 @@ function transitionComplete(e) {
             }
             r.delete(e);
         }
-        if (!i) e.$.delete(n); else if (n.Qe & STATUS_PENDING && n.me?.source === n) {
+        if (!i) e.$.delete(n); else if (n.xe & STATUS_PENDING && n.me?.source === n) {
             t = false;
             break;
         }
@@ -1061,8 +1073,8 @@ function runInTransition(e, t) {
  */ function enqueueSub(e) {
     if (e.Fe === EFFECT_TRACKED) {
         const t = e;
-        if (!t.xe) {
-            t.xe = true;
+        if (!t.Qe) {
+            t.Qe = true;
             t.Ze.enqueue(EFFECT_USER, t.Xe);
         }
         return;
@@ -1485,7 +1497,7 @@ function unlinkSubs(e) {
             // this same last-one-out check when that observer releases (the
             // untracked-read dispose in core.ts guards on pending identically).
                         const e = t;
-            e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !(e.D & REACTIVE_ZOMBIE) && !(e.Qe & STATUS_PENDING) && unobserved(e);
+            e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !(e.D & REACTIVE_ZOMBIE) && !(e.xe & STATUS_PENDING) && unobserved(e);
         }
     }
     return n;
@@ -1618,7 +1630,7 @@ function forEachDependent(e, t) {
 // callbacks handle their own release (settleAutodispose in handleAsync); this
 // covers derivatively-pending dependents, which have no callbacks of their own.
 function releaseIfSettledUnobserved(e) {
-    e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !e.U && !(e.D & REACTIVE_ZOMBIE) && !(e.Qe & STATUS_PENDING) && unobserved(e);
+    e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !e.U && !(e.D & REACTIVE_ZOMBIE) && !(e.xe & STATUS_PENDING) && unobserved(e);
 }
 
 // Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
@@ -1684,7 +1696,7 @@ function settlePendingSource(e) {
             setPendingError(o, s);
             i !== null && i(o);
         } else {
-            o.Qe &= ~STATUS_PENDING;
+            o.xe &= ~STATUS_PENDING;
             setPendingError(o);
             i !== null && i(o);
             if (o.At) {
@@ -1738,7 +1750,7 @@ function handleAsync(e, t, n) {
     // are the transaction's reveal machinery and always re-enter.
         const settleTransition = () => {
         const t = resolveTransition(e);
-        if (t && e.Qe & STATUS_UNINITIALIZED && !currentTransition(t).$.has(e)) {
+        if (t && e.xe & STATUS_UNINITIALIZED && !currentTransition(t).$.has(e)) {
             // Drop the stale stamp too: the plain settle write (setSignal) and the
             // stash-path restamp both re-enter the transaction through it.
             e.T = null;
@@ -1765,7 +1777,7 @@ function handleAsync(e, t, n) {
         // with the new value, creating a fresh Promise that supersedes this one.
                 if (e.D & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
         settleTransition();
-        const o = !!(e.Qe & STATUS_UNINITIALIZED);
+        const o = !!(e.xe & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
         const s = resolveLane(e);
@@ -1839,7 +1851,7 @@ function handleAsync(e, t, n) {
     // Returns whether the node released, so the iterator branch can stop
     // pulling values instead of pumping an unobserved stream forever (#2935).
         const settleAutodispose = () => {
-        if (e.Ue & CONFIG_AUTO_DISPOSE && !e.U && !(e.Qe & STATUS_PENDING)) {
+        if (e.Ue & CONFIG_AUTO_DISPOSE && !e.U && !(e.xe & STATUS_PENDING)) {
             unobserved(e);
             return true;
         }
@@ -1961,7 +1973,7 @@ function clearStatus(e, t = false) {
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
         e.Nt = false;
-    e.Qe = t ? 0 : e.Qe & STATUS_UNINITIALIZED;
+    e.xe = t ? 0 : e.xe & STATUS_UNINITIALIZED;
     if (e.me) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
@@ -1980,13 +1992,13 @@ function notifyStatus(e, t, n, r, i) {
     if (!r) {
         if (t === STATUS_PENDING && o) {
             addPendingSource(e, o);
-            e.Qe = STATUS_PENDING | e.Qe & STATUS_UNINITIALIZED;
+            e.xe = STATUS_PENDING | e.xe & STATUS_UNINITIALIZED;
             // Preserve the current source on this propagation so render-effect notification
             // can register every distinct pending source with the transition.
                         setPendingError(e, o, n);
         } else {
             clearPendingSources(e);
-            e.Qe = t | (t !== STATUS_ERROR ? e.Qe & STATUS_UNINITIALIZED : 0);
+            e.xe = t | (t !== STATUS_ERROR ? e.xe & STATUS_UNINITIALIZED : 0);
             e.me = n;
         }
         GlobalQueue.ce !== null && GlobalQueue.ce(e);
@@ -2136,11 +2148,11 @@ function recompute(e, t = false) {
     }
     let r = !!(e.D & REACTIVE_OPTIMISTIC_DIRTY);
     const i = e.A !== undefined && e.A !== NOT_PENDING;
-    const o = !!(e.Qe & STATUS_UNINITIALIZED);
+    const o = !!(e.xe & STATUS_UNINITIALIZED);
     // Outgoing error, captured before the compute clears status: if this run
     // recovers to an unchanged value, dependents still holding this object must
     // be swept (settleErroredDependents, #2949).
-        const s = e.Qe & STATUS_ERROR ? e.me : undefined;
+        const s = e.xe & STATUS_ERROR ? e.me : undefined;
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
         const u = (e.D & REACTIVE_REASK) !== 0;
@@ -2202,7 +2214,7 @@ function recompute(e, t = false) {
         // On a status-free node clearStatus is a guaranteed no-op: every branch
         // in its body is gated on one of these fields, and with _statusFlags === 0
         // the flags write (create or not) stores the 0 already there.
-                if (e.Qe !== 0 || e.yt !== undefined || e.me || e.Nt || e.At || e.je !== undefined || e._ !== undefined || e.R !== undefined || e.rt !== null) clearStatus(e, t);
+                if (e.xe !== 0 || e.yt !== undefined || e.me || e.Nt || e.At || e.je !== undefined || e._ !== undefined || e.R !== undefined || e.rt !== null) clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths.
                 if (e.i) GlobalQueue.De(e);
     } catch (t) {
@@ -2242,7 +2254,7 @@ function recompute(e, t = false) {
         // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
         // effect() can call its runner synchronously for the first run.
                 if (n && l) {
-            e.xe = !e.me;
+            e.Qe = !e.me;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
                         if (!t) e.Ze.enqueue(n, e.Ct ??= GlobalQueue.te.bind(null, e));
@@ -2295,13 +2307,13 @@ function recompute(e, t = false) {
                 if (s !== undefined && !l && !e.me) settleErroredDependents(e, s);
     }
     currentOptimisticLane = E;
-    const O = e.k !== NOT_PENDING || e.He !== null || e.Me !== null || (e.Qe & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    const O = e.k !== NOT_PENDING || e.He !== null || e.Me !== null || (e.xe & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
     // Override-covered holds (hasOverride) always queue: their commit belongs
     // to their own transition's schedule (A18 re-rule) and is unobservable
     // under the override (A17). Revert no longer commits anything, so an
     // unqueued covered hold would leak (INV-7) once the revert clears
     // _transition.
-        O && (!t || e.Qe & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
+        O && (!t || e.xe & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
     e.T && n && activeTransition !== e.T && runInTransition(e.T, () => recompute(e));
 }
 
@@ -2351,7 +2363,7 @@ function computed(e, t) {
         ft: null,
         ot: null,
         D: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-        Qe: STATUS_UNINITIALIZED,
+        xe: STATUS_UNINITIALIZED,
         H: clock,
         k: NOT_PENDING,
         Me: null,
@@ -2396,7 +2408,7 @@ function computed(e, t) {
         ft: null,
         ot: null,
         D: REACTIVE_LAZY,
-        Qe: STATUS_UNINITIALIZED,
+        xe: STATUS_UNINITIALIZED,
         H: clock,
         k: NOT_PENDING,
         Me: null,
@@ -2404,7 +2416,7 @@ function computed(e, t) {
         lt: null,
         T: null,
         Nt: false,
-        xe: false,
+        Qe: false,
         bt: undefined,
         Dt: t,
         wt: n,
@@ -2437,7 +2449,7 @@ function setupComputedNode(e, t) {
     if (GlobalQueue.ue !== null) GlobalQueue.ue(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
-        if (!(e.Qe & STATUS_PENDING) && !(e.Ue & CONFIG_NO_SNAPSHOT)) {
+        if (!(e.xe & STATUS_PENDING) && !(e.Ue & CONFIG_NO_SNAPSHOT)) {
             e.Le = e.We === undefined ? NO_SNAPSHOT : e.We;
             snapshotSources.add(e);
         }
@@ -2458,7 +2470,7 @@ function signal(e, t, n = null) {
         k: NOT_PENDING
     };
     n && (n.rt = r);
-    if (snapshotCaptureActive && !(r.Ue & CONFIG_NO_SNAPSHOT) && !((n?.Qe ?? 0) & STATUS_PENDING)) {
+    if (snapshotCaptureActive && !(r.Ue & CONFIG_NO_SNAPSHOT) && !((n?.xe ?? 0) & STATUS_PENDING)) {
         r.Le = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources.add(r);
     }
@@ -2589,7 +2601,7 @@ function read(e) {
             }
         }
     }
-    if (i.Qe & STATUS_PENDING) {
+    if (i.xe & STATUS_PENDING) {
         if (t && !(stale && i.T && activeTransition !== i.T)) {
             // Per-lane suspension lives with the engine (a non-null lane implies it
             // is installed): under a lane, only same-lane pending async without an
@@ -2598,10 +2610,10 @@ function read(e) {
                 if (!tracking && e !== t) link(e, t);
                 throw i.me;
             }
-        } else if (t && i !== e && i.Qe & STATUS_UNINITIALIZED) {
+        } else if (t && i !== e && i.xe & STATUS_UNINITIALIZED) {
             if (!tracking && e !== t) link(e, t);
             throw i.me;
-        } else if (!t && i.Qe & STATUS_UNINITIALIZED) {
+        } else if (!t && i.xe & STATUS_UNINITIALIZED) {
             throw i.me;
         }
     }
@@ -2609,7 +2621,7 @@ function read(e) {
     // firewall-backed reads follow the same rules (memo parity, #2897 ruling):
     // an errored derive throws for every late reader instead of silently
     // serving node values (the seed, or last-good data after a failed refetch).
-        if (i.ke && i.Qe & STATUS_ERROR) {
+        if (i.ke && i.xe & STATUS_ERROR) {
         // Only a genuine reactive re-read may retry an errored async source:
         // - tracking: owned/tracked scope only (never events / `untrack` / effect side-effect phase)
         // - !pendingCheckActive: an `isPending` probe observes the error, never refetches
@@ -2650,7 +2662,7 @@ function read(e) {
     // Record that this isPending() probe observed the fresh pending value, so
     // the probe doesn't pair "pending" with the new value (#2831).
         if (pendingCheckActive) GlobalQueue.Te(e, o);
-    if (!t && i === e && typeof n.ke === "function" && e.Ue & CONFIG_AUTO_DISPOSE && !(i.Qe & STATUS_PENDING) && !e.U) {
+    if (!t && i === e && typeof n.ke === "function" && e.Ue & CONFIG_AUTO_DISPOSE && !(i.xe & STATUS_PENDING) && !e.U) {
         unobserved(e);
     }
     return o;
@@ -2667,7 +2679,7 @@ function setSignal(e, t) {
     if (typeof t === "function") t = t(n);
     // Uninitialized check first: the first commit has no previous value, so the
     // user comparator must not run against `undefined` (matches recompute).
-        const r = !!(e.Qe & STATUS_UNINITIALIZED) || !e.ht || !e.ht(n, t);
+        const r = !!(e.xe & STATUS_UNINITIALIZED) || !e.ht || !e.ht(n, t);
     if (!r) return t;
     if (e.k === NOT_PENDING) queuePendingNode(e);
     e.k = t;
@@ -2960,7 +2972,7 @@ function isUndefined(e) {
     const n = e.A !== NOT_PENDING;
     const r = n ? unwrapOverride(e.A) : e.We;
     if (typeof t === "function") t = t(r);
-    const i = !!(e.Qe & STATUS_UNINITIALIZED) || !e.ht || !e.ht(r, t);
+    const i = !!(e.xe & STATUS_UNINITIALIZED) || !e.ht || !e.ht(r, t);
     if (!i) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -3001,7 +3013,7 @@ function isUndefined(e) {
  */ function transitionBlocked(e) {
     for (let t = 0; t < e.L.length; t++) {
         const n = e.L[t];
-        if (hasActiveOverride(n) && "Qe" in n && n.Qe & STATUS_PENDING && n.me instanceof NotReadyError) {
+        if (hasActiveOverride(n) && "xe" in n && n.xe & STATUS_PENDING && n.me instanceof NotReadyError) {
             return true;
         }
     }
@@ -3019,7 +3031,7 @@ function resolveOptimisticNodes(e) {
         // Revert is a pure drop: there is no revert target to commit —
         // override-covered authoritative values hold in _pendingValue and
         // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
-                if (!(t.Qe & STATUS_PENDING)) t.Qe &= ~STATUS_UNINITIALIZED;
+                if (!(t.xe & STATUS_PENDING)) t.xe &= ~STATUS_UNINITIALIZED;
         const r = t.A;
         t.A = NOT_PENDING;
         if (r !== NOT_PENDING && t.We !== unwrapOverride(r)) insertSubs(t, true);
@@ -3097,7 +3109,19 @@ function cleanupCompletedLanes(e) {
  * read()'s value selection under a lane: return the committed `_value` for
  * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
  */ function laneReadsCommitted(e, t, n) {
-    return e.A !== undefined || !!e.i || t === e && stale && n.t !== e || !!(t.Qe & STATUS_PENDING);
+    if (e.A !== undefined || !!e.i || !!(t.xe & STATUS_PENDING)) return true;
+    if (t === e && stale && n.t !== e) {
+        // The committed view can hide a same-tick ambient write (a lane member —
+        // even just an isPending companion flip — puts the reader "under a lane"
+        // against unrelated plain writes). With no transaction the write commits
+        // at THIS flush's end with no re-delivery, so record the reader for
+        // replay at commit — the same contract gatedRead provides when a
+        // transaction is active (#2963). If a transaction forms mid-flush,
+        // initTransition carries the recording over to it.
+        if (e.k !== NOT_PENDING && activeTransition === null) globalQueue.m.q.add(n);
+        return true;
+    }
+    return false;
 }
 
 /**
@@ -3223,7 +3247,7 @@ function collectPendingSources(e) {
     // not flow through it — matching the rails' behavior, where propagation
     // stopped at errored nodes. A DIRECT mark on an errored node still reads
     // pending (the count check above), also matching.
-        if (e.Qe & STATUS_ERROR) return false;
+        if (e.xe & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
     const n = e.Be;
@@ -3256,7 +3280,7 @@ function quietPending(e) {
 }
 
 function newQuestionInFlight(e) {
-    return !!(e.Qe & STATUS_PENDING) && !(e.Qe & STATUS_UNINITIALIZED) && !quietPending(e);
+    return !!(e.xe & STATUS_PENDING) && !(e.xe & STATUS_UNINITIALIZED) && !quietPending(e);
 }
 
 function computePendingState(e) {
@@ -3273,9 +3297,9 @@ function computePendingState(e) {
         return newQuestionInFlight(n);
     }
     if (n && e.k !== NOT_PENDING && !hasActiveOverride(e)) {
-        return !!(n.D & REACTIVE_MANUAL_WRITE) || !n.lt && !(n.Qe & STATUS_PENDING) || !!(n.Qe & STATUS_PENDING) && quietPending(n);
+        return !!(n.D & REACTIVE_MANUAL_WRITE) || !n.lt && !(n.xe & STATUS_PENDING) || !!(n.xe & STATUS_PENDING) && quietPending(n);
     }
-    if (e.k !== NOT_PENDING && !(t.Qe & STATUS_UNINITIALIZED)) {
+    if (e.k !== NOT_PENDING && !(t.xe & STATUS_UNINITIALIZED)) {
         if (hasActiveOverride(e)) return !e.ht || !e.ht(e.k, unwrapOverride(e.A));
         return true;
     }
@@ -3385,12 +3409,12 @@ function getLatestValueComputed(e) {
         }
         i = read(t);
     } catch (t) {
-        if (t instanceof NotReadyError && (!context || !(e.Qe & STATUS_UNINITIALIZED))) return r;
+        if (t instanceof NotReadyError && (!context || !(e.xe & STATUS_UNINITIALIZED))) return r;
         throw t;
     } finally {
         setLatestReadActive(n);
     }
-    if (t.Qe & STATUS_PENDING) return r;
+    if (t.xe & STATUS_PENDING) return r;
     if (stale && currentOptimisticLane && t.i) {
         const e = findLane(t.i);
         const n = findLane(currentOptimisticLane);
@@ -3409,7 +3433,7 @@ function getLatestValueComputed(e) {
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, r) {
     setPendingCheckActive(false);
     if (typeof e.ke === "function") prepareComputed(e, true);
-    const i = n.Qe;
+    const i = n.xe;
     if (t && i & STATUS_PENDING && i & STATUS_UNINITIALIZED) {
         if (tracking && e !== t) link(e, t);
         setPendingCheckActive(true);
@@ -3425,7 +3449,7 @@ function recordFreshRead(e, t) {
 }
 
 function applyReask(e, t) {
-    const n = !!(e.Qe & STATUS_PENDING);
+    const n = !!(e.xe & STATUS_PENDING);
     const r = t && !(n && !e.Nt);
     const i = n && e.Nt !== r;
     e.Nt = r;
@@ -3468,7 +3492,7 @@ function isPending(e) {
     } catch (e) {
         collectPending();
         if (e instanceof NotReadyError) {
-            const t = !!(e.source?.Qe & STATUS_UNINITIALIZED);
+            const t = !!(e.source?.xe & STATUS_UNINITIALIZED);
             if (r.found && !t) return true;
             if (context && t) throw e;
         }
@@ -3515,7 +3539,7 @@ GlobalQueue.Re = witnessAffects;
 
 function notifyEffectStatus(e, t) {
     // Use passed values if provided, otherwise read from node
-    const n = e !== undefined ? e : this.Qe;
+    const n = e !== undefined ? e : this.xe;
     const r = t !== undefined ? t : this.me;
     if (n & STATUS_ERROR) {
         this.Ze.notify(this, STATUS_PENDING, 0);
@@ -3529,8 +3553,8 @@ function notifyEffectStatus(e, t) {
             // phase takes the success arm instead. Blocked forwards (explicit
             // `status` arg without node-state writes) don't queue: the status
             // re-propagates unblocked at commit.
-            if (this.Qe & STATUS_ERROR) {
-                this.xe = true;
+            if (this.xe & STATUS_ERROR) {
+                this.Qe = true;
                 this.Ze.enqueue(this.Fe, this.Ct ??= runEffect.bind(null, this));
             }
             return;
@@ -3545,7 +3569,7 @@ function notifyEffectStatus(e, t) {
 }
 
 function runEffect(e) {
-    if (!e.xe || e.D & REACTIVE_DISPOSED) return;
+    if (!e.Qe || e.D & REACTIVE_DISPOSED) 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
@@ -3556,10 +3580,10 @@ function runEffect(e) {
     // Render effects bypass: their errors route to boundaries synchronously in
     // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
     // same flush must not be hijacked by a later-arriving error status.
-        if (e.Qe & STATUS_ERROR && e.Fe === EFFECT_USER) {
+        if (e.xe & STATUS_ERROR && e.Fe === EFFECT_USER) {
         const t = unwrapStatusError(e.me);
         e.bt = e.We;
-        e.xe = false;
+        e.Qe = false;
         try {
             e.wt ? e.wt(t, () => {
                 const t = e.Et;
@@ -3584,14 +3608,14 @@ function runEffect(e) {
                 e.Et = n;
     } catch (t) {
         e.me = new StatusError(e, t);
-        e.Qe |= STATUS_ERROR;
+        e.xe |= STATUS_ERROR;
         if (!e.Ze.notify(e, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(t);
             throw t;
         }
     } finally {
         e.bt = e.We;
-        e.xe = false;
+        e.Qe = false;
     }
 }
 
@@ -3603,9 +3627,9 @@ GlobalQueue.te = runEffect;
  * Uses stale reads.
  */ function trackedEffect(e, t) {
     const run = () => {
-        if (!n.xe || n.D & REACTIVE_DISPOSED) return;
+        if (!n.Qe || n.D & REACTIVE_DISPOSED) return;
         try {
-            n.xe = false;
+            n.Qe = false;
             recompute(n);
         } finally {}
     };
@@ -3621,10 +3645,10 @@ GlobalQueue.te = runEffect;
     });
     n.Et = undefined;
     n.Ue = n.Ue & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    n.xe = true;
+    n.Qe = true;
     n.Fe = EFFECT_TRACKED;
     n.yt = (e, t) => {
-        const r = e !== undefined ? e : n.Qe;
+        const r = e !== undefined ? e : n.xe;
         if (r & STATUS_ERROR) {
             n.Ze.notify(n, STATUS_PENDING, 0);
             const e = t !== undefined ? t : n.me;
@@ -5629,7 +5653,7 @@ function prepareStoreWrite(e, t, n) {
     }
     const r = e[STORE_VALUE];
     const i = r[n];
-    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.Qe ?? 0) & STATUS_PENDING)) {
+    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.xe ?? 0) & STATUS_PENDING)) {
         if (!e[STORE_SNAPSHOT_PROPS]) {
             e[STORE_SNAPSHOT_PROPS] = Object.create(null);
             snapshotSources?.add(e);
@@ -5752,7 +5776,7 @@ let Writing = null;
  */ function throwIfUnreadable(e) {
     const t = e[STORE_FIREWALL];
     if (!t) return;
-    const n = t.Qe;
+    const n = t.xe;
     if (n & STATUS_ERROR || n & STATUS_UNINITIALIZED && n & STATUS_PENDING) throw t.me ?? new NotReadyError(t);
 }
 
@@ -6218,7 +6242,7 @@ function createOptimisticStore(e, t, n) {
                 const e = GlobalQueue.Ae;
         GlobalQueue.Ae = t => {
             for (const e of t.V) {
-                if ((e[$TARGET]?.[STORE_FIREWALL]?.Qe ?? 0) & STATUS_PENDING) return true;
+                if ((e[$TARGET]?.[STORE_FIREWALL]?.xe ?? 0) & STATUS_PENDING) return true;
             }
             return e(t);
         };
@@ -6815,8 +6839,8 @@ function mapArray(e, t, n) {
         kt: [],
         Wt: [],
         Ft: r,
-        xt: r || n?.keyed === false ? [] : undefined,
-        Qt: i && n?.keyed !== false ? [] : undefined,
+        Qt: r || n?.keyed === false ? [] : undefined,
+        xt: i && n?.keyed !== false ? [] : undefined,
         Ht: n?.keyed === false,
         Mt: n?.fallback
     };
@@ -6849,14 +6873,14 @@ function updateKeyedMap() {
         let n, r, i, o, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        s = this.xt ? this.Ht ? () => {
+        s = this.Qt ? this.Ht ? () => {
             i[r] = signal(e[r], pureOptions);
             return this.Ut(accessor(i[r]), r);
         } : () => {
             i[r] = signal(e[r], pureOptions);
             o && (o[r] = signal(r, pureOptions));
             return this.Ut(accessor(i[r]), o ? accessor(o[r]) : undefined);
-        } : this.Qt ? () => {
+        } : this.xt ? () => {
             const t = e[r];
             o[r] = signal(r, pureOptions);
             return this.Ut(t, accessor(o[r]));
@@ -6872,8 +6896,8 @@ function updateKeyedMap() {
                 this.Vt = [];
                 this.kt = [];
                 this.Lt = 0;
-                this.xt && (this.xt = []);
                 this.Qt && (this.Qt = []);
+                this.xt && (this.xt = []);
             }
             if (this.Mt && !this.kt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
@@ -6886,8 +6910,8 @@ function updateKeyedMap() {
          else if (this.Lt === 0) {
             const u = new Array(t);
             const l = new Array(t);
-            i = this.xt && new Array(t);
-            o = this.Qt && new Array(t);
+            i = this.Qt && new Array(t);
+            o = this.xt && new Array(t);
             try {
                 for (r = 0; r < t; r++) u[r] = runWithOwner(l[r] = createOwner(), s);
             } catch (e) {
@@ -6899,19 +6923,19 @@ function updateKeyedMap() {
  // previous fallback
                         this.kt = u;
             this.Wt = l;
-            i && (this.xt = i);
-            o && (this.Qt = o);
+            i && (this.Qt = i);
+            o && (this.xt = o);
             this.Vt = e.slice(0);
             this.Lt = t;
         } else {
             let u, l, a, c, f, E, d, S, T;
             // skip common prefix
-                        for (u = 0, l = Math.min(this.Lt, t); u < l && (this.Vt[u] === e[u] || this.xt && compare(this.Ft, this.Vt[u], e[u])); u++) {
-                if (this.xt) setSignal(this.xt[u], e[u]);
+                        for (u = 0, l = Math.min(this.Lt, t); u < l && (this.Vt[u] === e[u] || this.Qt && compare(this.Ft, this.Vt[u], e[u])); u++) {
+                if (this.Qt) setSignal(this.Qt[u], e[u]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (l = this.Lt - 1, a = t - 1; l >= u && a >= u && (this.Vt[l] === e[a] || this.xt && compare(this.Ft, this.Vt[l], e[a])); l--, 
+                        for (l = this.Lt - 1, a = t - 1; l >= u && a >= u && (this.Vt[l] === e[a] || this.Qt && compare(this.Ft, this.Vt[l], e[a])); l--, 
             a--) ;
             // no structural change (every position matched in place at equal
             // length — the common post-reconcile shape): keep the same mapped
@@ -6923,8 +6947,8 @@ function updateKeyedMap() {
             const O = t - this.Lt;
             const _ = new Array(t);
             const R = new Array(t);
-            i = this.xt ? new Array(t) : undefined;
-            o = this.Qt ? new Array(t) : undefined;
+            i = this.Qt ? new Array(t) : undefined;
+            o = this.xt ? new Array(t) : undefined;
             // 0) prepare a map of all indices in the changed window of newItems,
             // scanning backwards so we encounter them in natural order
                         E = new Map;
@@ -6946,8 +6970,8 @@ function updateKeyedMap() {
                 if (r !== undefined && r !== -1) {
                     _[r] = this.kt[n];
                     R[r] = this.Wt[n];
-                    i && (i[r] = this.xt[n]);
-                    o && (o[r] = this.Qt[n]);
+                    i && (i[r] = this.Qt[n]);
+                    o && (o[r] = this.xt[n]);
                     r = d[r];
                     E.set(f, r);
                 } else (S ??= []).push(this.Wt[n]);
@@ -6969,8 +6993,8 @@ function updateKeyedMap() {
                         for (n = 0; n < u; n++) {
                 _[n] = this.kt[n];
                 R[n] = this.Wt[n];
-                i && (i[n] = this.xt[n]);
-                o && (o[n] = this.Qt[n]);
+                i && (i[n] = this.Qt[n]);
+                o && (o[n] = this.xt[n]);
             }
             for (r = u; r <= a; r++) {
                 if (i) setSignal(i[r], e[r]);
@@ -6980,18 +7004,18 @@ function updateKeyedMap() {
                 _[r] = this.kt[r - O];
                 R[r] = this.Wt[r - O];
                 if (i) {
-                    i[r] = this.xt[r - O];
+                    i[r] = this.Qt[r - O];
                     setSignal(i[r], e[r]);
                 }
                 if (o) {
-                    o[r] = this.Qt[r - O];
+                    o[r] = this.xt[r - O];
                     if (O !== 0) setSignal(o[r], r);
                 }
             }
             this.kt = _;
             this.Wt = R;
-            i && (this.xt = i);
-            o && (this.Qt = o);
+            i && (this.Qt = i);
+            o && (this.xt = o);
             this.Lt = t;
             // save a copy of the mapped items for the next update
                         this.Vt = e.slice(0);
@@ -7106,12 +7130,12 @@ function boundaryComputed(e, t) {
     });
     n.yt = (e, t) => {
         // Use passed values if provided, otherwise read from node
-        const r = e !== undefined ? e : n.Qe;
+        const r = e !== undefined ? e : n.xe;
         const i = t !== undefined ? t : n.me;
         // Notify both status dimensions like a render effect does; the queue chain
         // consumes this boundary's own type and forwards the remainder upward until
         // a boundary that handles it is found.
-                n.Qe &= ~n.Yt;
+                n.xe &= ~n.Yt;
         const o = n.Ze.notify(n, STATUS_PENDING | STATUS_ERROR, r, i);
         // The queue is the only propagation channel: a foreign status must not stay
         // reader-visible on the tree, or reads re-throw it across the boundary and
@@ -7119,8 +7143,8 @@ function boundaryComputed(e, t) {
         // untouched, so the tree still recomputes when the foreign source settles.
                 const s = r & ~n.Yt & (STATUS_PENDING | STATUS_ERROR);
         if (s) {
-            n.Qe &= ~s;
-            if (n.me === i && !(n.Qe & (STATUS_PENDING | STATUS_ERROR))) n.me = undefined;
+            n.xe &= ~s;
+            if (n.me === i && !(n.xe & (STATUS_PENDING | STATUS_ERROR))) n.me = undefined;
         }
         // An ERROR the chain could not deliver to any boundary is uncaught. The
         // scrub above already removed it from reader-visible state, so without
@@ -7388,11 +7412,11 @@ class CollectionQueue extends Queue {
             // mark's lifetime (the visual channel): the marked node carries no
             // status of its own, so the count is the liveness test. The release
             // sweep (finalizePureQueue after mark release) re-runs this check.
-            if (e.D & REACTIVE_DISPOSED || !e.W && !(e.Qe & this.Tn) && !(this.Tn & STATUS_ERROR && e.Qe & STATUS_PENDING)) this.Bt.delete(e);
+            if (e.D & REACTIVE_DISPOSED || !e.W && !(e.xe & this.Tn) && !(this.Tn & STATUS_ERROR && e.xe & STATUS_PENDING)) this.Bt.delete(e);
         }
         if (!this.Bt.size) {
             if (this.Tn & STATUS_PENDING && this.Zt && !this.rn && this.On) {
-                this.Zt = !!(this.On.Qe & this.Tn);
+                this.Zt = !!(this.On.xe & this.Tn);
             } else {
                 this.Zt = false;
             }
@@ -7428,7 +7452,7 @@ function createCollectionBoundary(e, t, n, r) {
         } catch (e) {
             if (e instanceof NotReadyError) t = true; else throw e;
         }
-        o.Zt = t || !!(s.Qe & e) || s.me instanceof NotReadyError;
+        o.Zt = t || !!(s.xe & e) || s.me instanceof NotReadyError;
     });
     const u = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (u) {

package/dist/prod/core/optimistic.js

@@ -46,8 +46,8 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     // joint root). resolveTransition prefers this over the lane's _transition,
     // which a shared subscriber can merge across transactions (#2912).
         e.sn = activeTransition;
-    const o = getOrCreateLane(e);
-    e.Me = o;
+    const r = getOrCreateLane(e);
+    e.Me = r;
     // 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).
@@ -164,7 +164,19 @@ function cleanupCompletedLanes(e) {
  * read()'s value selection under a lane: return the committed `_value` for
  * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
  */ function laneReadsCommitted(e, n, t) {
-    return e.Ae !== undefined || !!e.Me || n === e && stale && t.nn !== e || !!(n.S & STATUS_PENDING);
+    if (e.Ae !== undefined || !!e.Me || !!(n.S & STATUS_PENDING)) return true;
+    if (n === e && stale && t.nn !== e) {
+        // The committed view can hide a same-tick ambient write (a lane member —
+        // even just an isPending companion flip — puts the reader "under a lane"
+        // against unrelated plain writes). With no transaction the write commits
+        // at THIS flush's end with no re-delivery, so record the reader for
+        // replay at commit — the same contract gatedRead provides when a
+        // transaction is active (#2963). If a transaction forms mid-flush,
+        // initTransition carries the recording over to it.
+        if (e.De !== NOT_PENDING && activeTransition === null) globalQueue.m.ln.add(t);
+        return true;
+    }
+    return false;
 }
 
 /**
@@ -218,8 +230,8 @@ function trackOptimisticStore(e) {
     if (GlobalQueue.ht !== null) return;
     GlobalQueue.ht = optimisticWrite;
     GlobalQueue.En = resolveOptimisticNodes;
-    GlobalQueue.dn = transitionBlocked;
-    GlobalQueue.Tn = cleanupCompletedLanes;
+    GlobalQueue.Tn = transitionBlocked;
+    GlobalQueue.dn = cleanupCompletedLanes;
     GlobalQueue.In = runLaneEffects;
     GlobalQueue.Ot = gatedRead;
     GlobalQueue.Ct = laneSuspends;

package/dist/prod/core/scheduler.js

@@ -330,8 +330,8 @@ class GlobalQueue extends Queue {
     // once the gate holds.
     static ht=null;
     static En=null;
-    static dn=null;
     static Tn=null;
+    static dn=null;
     static In=null;
     static Ot=null;
     static Ct=null;
@@ -486,6 +486,12 @@ class GlobalQueue extends Queue {
             }
             if (t.A.length) activeTransition.A.push(...t.A);
             for (const e of t.cn) activeTransition.cn.add(e);
+            // Gated readers recorded against the ambient batch move with it: their
+            // replay-at-commit now happens at the transaction's completion.
+                        if (t.ln.size) {
+                for (const e of t.ln) activeTransition.ln.add(e);
+                t.ln.clear();
+            }
             currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
@@ -579,13 +585,19 @@ function finalizePureQueue(e = null, t = false) {
         // which installed the engine's hooks.
                 if (t.je.length) GlobalQueue.En(t.je);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
-        // so they re-run with the now-committed values visible.
-                if (e && e.ln.size) {
-            for (const t of e.ln) {
-                if (t.se & REACTIVE_DISPOSED) continue;
-                enqueueSub(t);
+        // so they re-run with the now-committed values visible. The ambient batch
+        // replays too — laneReadsCommitted records readers whose committed-view
+        // read hid a same-tick plain write that just committed above (#2963).
+                if (t.ln.size) {
+            for (const e of t.ln) {
+                if (e.se & REACTIVE_DISPOSED) continue;
+                enqueueSub(e);
             }
-            e.ln.clear();
+            t.ln.clear();
+            // A completing transition keeps the outer flush loop alive by itself;
+            // the ambient batch needs the re-arm or the replay sits in the heap
+            // until the next unrelated write.
+                        schedule();
         }
         // Declared motion ends with the transaction: settle (or plain flush end
         // for ambient marks) releases each registration's refcount. A non-empty
@@ -604,7 +616,7 @@ function finalizePureQueue(e = null, t = false) {
                 if (t.cn.size) GlobalQueue.Dt(t.cn, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.Tn(e);
+                if (activeLanes.size) GlobalQueue.dn(e);
     }
 }
 
@@ -710,7 +722,7 @@ function transitionComplete(e) {
     // Override blockage lives with the engine (absent hook = "no optimistic
     // blockage"); the hook's loops over _optimisticNodes/_optimisticStores are
     // no-ops when the transition holds neither, so no pre-check is needed.
-        if (t && GlobalQueue.dn?.(e)) t = false;
+        if (t && GlobalQueue.Tn?.(e)) t = false;
     t && (e.fn = true);
     return t;
 }

package/dist/prod/store/optimistic.js

@@ -33,8 +33,8 @@ function createOptimisticStore(e, t, r) {
         // clobbering instead of composing). Optimistic state clears when truth
         // lands or its transaction ends — never mid-refetch. Wrapped here (engine
         // is already installed above) so store-free apps never carry the check.
-                const e = GlobalQueue.dn;
-        GlobalQueue.dn = t => {
+                const e = GlobalQueue.Tn;
+        GlobalQueue.Tn = t => {
             for (const e of t.cn) {
                 if ((e[$TARGET]?.[STORE_FIREWALL]?.S ?? 0) & STATUS_PENDING) return true;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-beta.30",
+  "version": "2.0.0-beta.31",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",