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

package/dist/prod/core/async.js

@@ -1,4 +1,4 @@
-import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING } from "./constants.js";
+import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE } from "./constants.js";
 
 import { untrack, context, setSignal } from "./core.js";
 
@@ -6,7 +6,7 @@ import "./invariants.js";
 
 import { NotReadyError, StatusError } from "./error.js";
 
-import { unobserved, trimStaleDeps } from "./graph.js";
+import { trimStaleDeps, unobserved } from "./graph.js";
 
 import { enqueueSub } from "./heap.js";
 
@@ -14,7 +14,7 @@ import { resolveTransition, hasActiveOverride, assignOrMergeLane, resolveLane }
 
 import { cleanup } from "./owner.js";
 
-import { globalQueue, GlobalQueue, clock, currentTransition, schedule, flush, queuePendingNode, insertSubs } from "./scheduler.js";
+import { globalQueue, GlobalQueue, schedule, flush, queuePendingNode, insertSubs, clock, currentTransition } from "./scheduler.js";
 
 // The lazily-created Set is the ONE container for pending sources. Its
 // predecessor — a singular slot promoted to a Set on the second source —
@@ -133,9 +133,9 @@ function settlePendingSource(e) {
         if (r.has(u) || !removePendingSource(u, e)) return;
         r.add(u);
         u.Se = clock;
-        const l = u.oe?.values().next().value;
-        if (l) {
-            setPendingError(u, l);
+        const s = u.oe?.values().next().value;
+        if (s) {
+            setPendingError(u, s);
             o !== null && o(u);
         } else {
             u.S &= ~STATUS_PENDING;
@@ -222,8 +222,8 @@ function handleAsync(e, n, t) {
         const u = !!(e.S & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
-        const l = resolveLane(e);
-        if (l) l.Ne.delete(e);
+        const s = resolveLane(e);
+        if (s) s.Ne.delete(e);
         if (t) {
             t(r);
             if (u) clearStatus(e, true);
@@ -249,14 +249,14 @@ function handleAsync(e, n, t) {
                         GlobalQueue._e !== null && GlobalQueue._e(e, r);
             if (!hasActiveOverride(e)) insertSubs(e);
             e.Se = clock;
-        } else if (l) {
+        } else if (s) {
             // Route through lane's effect queue for independent flushing
             const n = e.Pe;
-            const t = e.Ue;
-            const o = e.be;
+            const t = e.be;
+            const o = e.he;
             try {
                 if (!n && u || !o || !o(r, t)) {
-                    e.Ue = r;
+                    e.be = r;
                     e.Se = clock;
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
@@ -300,9 +300,9 @@ function handleAsync(e, n, t) {
         return false;
     };
     if (o) {
-        let t = false, r = false, o, l = true;
+        let t = false, r = false, o, s = true;
         n.then(e => {
-            if (l) {
+            if (s) {
                 u = e;
                 t = true;
             } else {
@@ -310,7 +310,7 @@ function handleAsync(e, n, t) {
                 settleAutodispose();
             }
         }, e => {
-            if (l) {
+            if (s) {
                 o = e;
                 r = true;
             } else {
@@ -318,7 +318,7 @@ function handleAsync(e, n, t) {
                 settleAutodispose();
             }
         });
-        l = false;
+        s = false;
         if (r) {
             // Settle through the same status path an async rejection uses, then
             // unwind the in-progress synchronous read so the errored node isn't
@@ -334,7 +334,7 @@ function handleAsync(e, n, t) {
         const t = n[Symbol.asyncIterator]();
         let r = false;
         let o = false;
-        let l = true;
+        let s = true;
         cleanup(() => {
             if (o) return;
             o = true;
@@ -350,10 +350,25 @@ function handleAsync(e, n, t) {
             if (!settleAutodispose()) iterate();
         };
         const iterate = () => {
-            let s, i, f = false, a = false, c = true;
-            t.next().then(t => {
-                if (c) {
-                    s = t;
+            let l, i, f = false, a = false, c = true;
+            // Protocol tolerance, matching `for await`: `await` unwraps whatever
+            // next() returns — a thenable OR a bare IteratorResult. Real producers
+            // use the bare form as a promise-free fast path when a value is already
+            // buffered (seroval's deserialized streams do), so a bare result is
+            // assimilated as an already-settled step instead of crashing on `.then`.
+                        const S = t.next();
+            const d = isThenable(S) ? S : {
+                then: e => void e(S)
+            };
+            d.then(t => {
+                // The sync stash only serves the INITIAL drain (handleAsync's caller
+                // consumes syncValue / throws NotReady from it). A sync-settled step
+                // after an async gap — seroval buffering values between pulls, a
+                // sync-thenable producer mid-stream — has no caller reading the
+                // stash: it must write through the async path or the value is
+                // silently dropped.
+                if (c && s) {
+                    l = t;
                     f = true;
                     if (t.done) o = true;
                 } else if (e.Te !== n) {
@@ -387,20 +402,20 @@ function handleAsync(e, n, t) {
                 // Match the promise branch, but only rethrow during the initial read.
                 o = true;
                 handleError(i);
-                if (l) throw i;
+                if (s) throw i;
                 return true;
             }
-            if (f && !s.done) {
-                u = s.value;
+            if (f && !l.done) {
+                u = l.value;
                 r = true;
                 return iterate();
             }
-            return f && s.done;
+            return f && l.done;
         };
-        const s = iterate();
+        const l = iterate();
         // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
-                l = false;
-        if (!r && !s) {
+                s = false;
+        if (!r && !l) {
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
         }
@@ -414,12 +429,12 @@ function clearStatus(e, n = false) {
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
-        e.Re = false;
+        e.Ue = false;
     e.S = n ? 0 : e.S & STATUS_UNINITIALIZED;
     if (e._) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e.he || e.pe) GlobalQueue.ce(e);
+        if (e.Re || e.pe) GlobalQueue.ce(e);
     if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
     if (e.i) e.i();
 }
@@ -428,9 +443,9 @@ function notifyStatus(e, n, t, r, o) {
     // Wrap regular errors to track source node
     if (n === STATUS_ERROR && !(t instanceof StatusError) && !(t instanceof NotReadyError)) t = new StatusError(e, t);
     const u = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
-    const l = u === e;
-    const s = n === STATUS_PENDING && e.Ae !== undefined && !l;
-    const i = s && hasActiveOverride(e);
+    const s = u === e;
+    const l = n === STATUS_PENDING && e.Ae !== undefined && !s;
+    const i = l && hasActiveOverride(e);
     if (!r) {
         if (n === STATUS_PENDING && u) {
             addPendingSource(e, u);
@@ -450,7 +465,7 @@ function notifyStatus(e, n, t, r, o) {
         assignOrMergeLane(e, o);
     }
     const f = r || i;
-    const a = r || s ? undefined : o;
+    const a = r || l ? undefined : o;
     if (e.i) {
         if (r && n === STATUS_PENDING) {
             return;

package/dist/prod/core/core.js

@@ -137,7 +137,7 @@ function recompute(e, t = false) {
     e.Ye++;
     e.se = REACTIVE_RECOMPUTING_DEPS;
     e.Se = clock;
-    let r = e.De === NOT_PENDING ? e.Ue : e.De;
+    let r = e.De === NOT_PENDING ? e.be : e.De;
     let c = e.Ve;
     let _ = tracking;
     let f = currentOptimisticLane;
@@ -189,7 +189,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.S !== 0 || e.i !== undefined || e._ || e.Re || e.de || e.oe !== undefined || e.he !== undefined || e.pe !== undefined || e.u !== null) clearStatus(e, t);
+                if (e.S !== 0 || e.i !== undefined || e._ || e.Ue || e.de || e.oe !== undefined || e.Re !== undefined || e.pe !== undefined || e.u !== null) clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths.
                 if (e.Me) GlobalQueue.Ke(e);
     } catch (t) {
@@ -212,10 +212,10 @@ function recompute(e, t = false) {
     }
     if (!e._) {
         trimStaleDeps(e);
-        const s = u ? unwrapOverride(e.Ae) : e.De === NOT_PENDING ? e.Ue : e.De;
+        const s = u ? unwrapOverride(e.Ae) : e.De === NOT_PENDING ? e.be : e.De;
         let a = false;
         try {
-            a = !n && l || !e.be || !e.be(s, r);
+            a = !n && l || !e.he || !e.he(s, r);
         } catch (t) {
             // A throwing user comparator is an error of this node's computation.
             // Route it through the same status path as a compute-phase throw so
@@ -242,7 +242,7 @@ function recompute(e, t = false) {
             // commitPendingNodes) exists to sequence transition reveals, and
             // paying it per effect on the plain path is pure overhead.
             n && (activeTransition !== e.Ie || activeTransition === null) || i) {
-                e.Ue = r;
+                e.be = r;
                 // Lane-propagated correction: upstream data is fresh, correct the
                 // override unconditionally. The direct _value commit is the lane's
                 // own reveal schedule; drop any superseded older hold so its queued
@@ -316,14 +316,14 @@ function computed(e, t) {
     const i = {
         id: inheritId(t, n, context),
         T: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.V ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        be: t?.equals != null ? t.equals : isEqual,
+        he: t?.equals != null ? t.equals : isEqual,
         ut: t?.unobserved,
         Le: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         qe: 0,
         ae: e,
-        Ue: undefined,
+        be: undefined,
         Ve: 0,
         u: null,
         lt: undefined,
@@ -345,7 +345,7 @@ function computed(e, t) {
         Qe: null,
         Te: null,
         Ie: null,
-        Re: false
+        Ue: false
     };
     setupComputedNode(i, t);
     return i;
@@ -361,14 +361,14 @@ function computed(e, t) {
     const s = {
         id: inheritId(l, o, context),
         T: (o ? CONFIG_TRANSPARENT : 0) | (l?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (l?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        be: false,
+        he: false,
         ut: l?.unobserved,
         Le: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         qe: 0,
         ae: e,
-        Ue: undefined,
+        be: undefined,
         Ve: 0,
         u: null,
         lt: undefined,
@@ -390,7 +390,7 @@ function computed(e, t) {
         Qe: null,
         Te: null,
         Ie: null,
-        Re: false,
+        Ue: false,
         Be: false,
         ct: undefined,
         _t: t,
@@ -425,7 +425,7 @@ function setupComputedNode(e, t) {
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
         if (!(e.S & STATUS_PENDING) && !(e.T & CONFIG_NO_SNAPSHOT)) {
-            e.xe = e.Ue === undefined ? NO_SNAPSHOT : e.Ue;
+            e.xe = e.be === undefined ? NO_SNAPSHOT : e.be;
             snapshotSources.add(e);
         }
     }
@@ -433,10 +433,10 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const i = {
-        be: t?.equals != null ? t.equals : isEqual,
+        he: t?.equals != null ? t.equals : isEqual,
         T: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.V ? CONFIG_NO_SNAPSHOT : 0),
         ut: t?.unobserved,
-        Ue: e,
+        be: e,
         o: null,
         st: null,
         Se: clock,
@@ -534,7 +534,7 @@ function isEqual(e, t) {
     let t = context;
     if (t?.Nt) t = t.Tt;
     if (t && tracking) link(e, t);
-    return !t || e.De === NOT_PENDING ? e.Ue : e.De;
+    return !t || e.De === NOT_PENDING ? e.be : e.De;
 }
 
 function read(e) {
@@ -558,7 +558,7 @@ function read(e) {
     }
     if (!n.ae && u === e && e.Ae === undefined && e.xe === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
         if (t && tracking) link(e, t);
-        return !t || e.De === NOT_PENDING ? e.Ue : e.De;
+        return !t || e.De === NOT_PENDING ? e.be : e.De;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
@@ -610,7 +610,7 @@ function read(e) {
         const n = e.xe;
         if (n !== undefined) {
             const i = n === NO_SNAPSHOT ? undefined : n;
-            const u = e.De !== NOT_PENDING ? e.De : e.Ue;
+            const u = e.De !== NOT_PENDING ? e.De : e.be;
             if (u !== i) t.se |= REACTIVE_SNAPSHOT_STALE;
             return i;
         }
@@ -627,13 +627,13 @@ function read(e) {
     // so it re-runs with the new committed view. (Gate details live with the
     // engine — a non-null lane implies it is installed.)
         if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Ot(e, u, t)) {
-        return e.Ue;
+        return e.be;
     }
     // In optimistic lane context, return _value for optimistic/lane-assigned signals
     // and for regular signals in stale mode (render effects). Non-stale readers (user
     // effects) see _pendingValue so that latest() and direct reads stay consistent.
     // (The lane-context clause lives with the engine.)
-        const l = !t || currentOptimisticLane !== null && GlobalQueue.Rt(e, u, t) || e.De === NOT_PENDING || stale && e.Ie && activeTransition !== e.Ie ? e.Ue : e.De;
+        const l = !t || currentOptimisticLane !== null && GlobalQueue.Rt(e, u, t) || e.De === NOT_PENDING || stale && e.Ie && activeTransition !== e.Ie ? e.be : e.De;
     // 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.Pt(e, l);
@@ -650,18 +650,18 @@ function setSignal(e, t) {
     // _overrideValue slot, and every module that creates one installs the
     // engine first.
         if (e.Ae !== undefined && !projectionWriteActive) return GlobalQueue.ht(e, t);
-    const n = e.De === NOT_PENDING ? e.Ue : e.De;
+    const n = e.De === NOT_PENDING ? e.be : e.De;
     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 i = !!(e.S & STATUS_UNINITIALIZED) || !e.be || !e.be(n, t);
+        const i = !!(e.S & STATUS_UNINITIALIZED) || !e.he || !e.he(n, t);
     if (!i) return t;
     if (e.De === NOT_PENDING) queuePendingNode(e);
     e.De = t;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op (companions are
     // only ever created, never removed, and creating one installs the hook).
-        (e.he !== undefined || e.pe !== undefined) && GlobalQueue._e !== null && GlobalQueue._e(e, t);
+        (e.Re !== undefined || e.pe !== undefined) && GlobalQueue._e !== null && GlobalQueue._e(e, t);
     e.Se = clock;
     insertSubs(e);
     schedule();

package/dist/prod/core/effect.js

@@ -62,7 +62,7 @@ function runEffect(t) {
     // same flush must not be hijacked by a later-arriving error status.
         if (t.S & STATUS_ERROR && t.Pe === EFFECT_USER) {
         const E = unwrapStatusError(t._);
-        t.ct = t.Ue;
+        t.ct = t.be;
         t.Be = false;
         try {
             t.ft ? t.ft(E, () => {
@@ -82,7 +82,7 @@ function runEffect(t) {
     t.Et = undefined;
     try {
         E?.();
-        const e = t._t(t.Ue, t.ct);
+        const e = t._t(t.be, t.ct);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
                 t.Et = e;
@@ -94,7 +94,7 @@ function runEffect(t) {
             throw E;
         }
     } finally {
-        t.ct = t.Ue;
+        t.ct = t.be;
         t.Be = false;
     }
 }

package/dist/prod/core/lanes.js

@@ -36,7 +36,7 @@ const activeLanes = new Set;
     // parent-child is a property of the nodes, not of write order — otherwise
     // the owner's write merges the companion's subscribers into this lane and
     // their effects wait on its async instead of flushing immediately.
-        adoptCompanionLane(n.he, e);
+        adoptCompanionLane(n.Re, e);
     adoptCompanionLane(n.pe, e);
     return e;
 }

package/dist/prod/core/optimistic.js

@@ -25,9 +25,9 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
  */
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
     const t = e.Ae !== NOT_PENDING;
-    const i = t ? unwrapOverride(e.Ae) : e.Ue;
+    const i = t ? unwrapOverride(e.Ae) : e.be;
     if (typeof n === "function") n = n(i);
-    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.be || !e.be(i, n);
+    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.he || !e.he(i, n);
     if (!u) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -46,15 +46,15 @@ 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).
         e.Ae = n === undefined ? OVERRIDE_UNDEFINED : n;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op.
-        (e.he !== undefined || e.pe !== undefined) && GlobalQueue._e !== null && GlobalQueue._e(e, n);
+        (e.Re !== undefined || e.pe !== undefined) && GlobalQueue._e !== null && GlobalQueue._e(e, n);
     e.Se = clock;
     insertSubs(e, true);
     schedule();
@@ -89,7 +89,7 @@ function resolveOptimisticNodes(e) {
                 if (!(n.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
         const i = n.Ae;
         n.Ae = NOT_PENDING;
-        if (i !== NOT_PENDING && n.Ue !== unwrapOverride(i)) insertSubs(n, true);
+        if (i !== NOT_PENDING && n.be !== unwrapOverride(i)) insertSubs(n, true);
         n.Ie = null;
         n.sn = null;
     }
@@ -98,9 +98,9 @@ function resolveOptimisticNodes(e) {
     // transition that produced them (A19 — pending is a property of the data).
         for (let t = 0; t < n; t++) {
         const n = e[t];
-        if (n.he || n.pe) GlobalQueue.un(n);
+        if (n.Re || n.pe) GlobalQueue.un(n);
         const i = n.nn;
-        if (i && (i.he === n || i.pe === n)) GlobalQueue.un(i);
+        if (i && (i.Re === n || i.pe === n)) GlobalQueue.un(i);
     }
     e.splice(0, n);
 }
@@ -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/owner.js

@@ -51,7 +51,7 @@ function disposeChildren(e, n = false, t) {
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const n = e;
-        if (n.he || n.pe) GlobalQueue.un(n);
+        if (n.Re || n.pe) GlobalQueue.un(n);
     }
     if (n && e.ae) e.Te = null;
     let l = t ? e.Qe : e.ke;

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) {
@@ -537,14 +543,14 @@ function commitPendingNode(e) {
     const t = e;
     if (!t.ae) {
         if (e.De !== NOT_PENDING) {
-            e.Ue = e.De;
+            e.be = e.De;
             e.De = NOT_PENDING;
         }
-        if (e.he || e.pe) GlobalQueue.un(e);
+        if (e.Re || e.pe) GlobalQueue.un(e);
         return;
     }
     if (e.De !== NOT_PENDING) {
-        e.Ue = e.De;
+        e.be = e.De;
         e.De = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
                 if (e.Pe && e.Pe !== EFFECT_TRACKED) e.Be = true;
@@ -552,7 +558,7 @@ function commitPendingNode(e) {
     t.se &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
     if (t.Qe !== null || t.ye !== null) GlobalQueue.me(t, false, true);
-    if (e.he || e.pe) GlobalQueue.un(e);
+    if (e.Re || e.pe) GlobalQueue.un(e);
 }
 
 function commitPendingNodes() {
@@ -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;
 }