@solidjs/signals 2.0.0-rc.3 → 2.0.0-rc.5

package/dist/prod/core/scheduler.js

@@ -1,4 +1,4 @@
-import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, NOT_PENDING, CONFIG_HAS_COMPANIONS, EFFECT_TRACKED, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED } from "./constants.js";
+import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_DISPOSED, CONFIG_HELD_TRUTH, REACTIVE_ZOMBIE, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_HAS_COMPANIONS, EFFECT_TRACKED, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED, CONFIG_AUTHORITATIVE_READ } from "./constants.js";
 
 import { currentOptimisticLane } from "./core.js";
 
@@ -6,11 +6,13 @@ import { DEV } from "./dev.js";
 
 import { NotReadyError } from "./error.js";
 
+import { sweepDormant } from "./graph.js";
+
 import { runHeap, deleteFromHeap, enqueueSub } from "./heap.js";
 
-import { activeLanes, assignOrMergeLane, findLane } from "./lanes.js";
+import { activeLanes, assignOrMergeLane, findLane, hasActiveOverride } from "./lanes.js";
 
-export { getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane } from "./lanes.js";
+export { getOrCreateLane, mergeLanes, resolveLane } from "./lanes.js";
 
 import { devCheckFlushStart, devCheckActiveOverrides, devCensusCompanions, devCheckQuiescent } from "./invariants.js";
 
@@ -19,14 +21,14 @@ const transitions = new Set;
 const dirtyQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    xe: 0,
+    Qe: 0,
     EE: 0
 };
 
 const zombieQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    xe: 0,
+    Qe: 0,
     EE: 0
 };
 
@@ -60,8 +62,8 @@ let projectionWriteActive = false;
 const transientStoreNodes = new Set;
 
 function canUseSimpleSyncFlush(e) {
-    const t = e.k;
-    return transitions.size === 0 && activeLanes.size === 0 && e.Qt.length === 0 && t.Ke.length === 0 && t.m.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
+    const t = e.m;
+    return transitions.size === 0 && activeLanes.size === 0 && e.Qt.length === 0 && t.ze.length === 0 && t.A.length === 0 && t.En.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
@@ -72,13 +74,13 @@ function sweepTransientStoreNodes() {
             continue;
         }
         if (e.Pe !== NOT_PENDING) continue;
-        if (e.o?.De !== undefined && e.o?.De !== NOT_PENDING) continue;
+        if (e.o?.Oe !== undefined && e.o?.Oe !== NOT_PENDING) continue;
         // A live affects() mark keeps the node addressable: sweeping it would
         // detach the refcount from the slot (a fresh probe would upsert a new,
         // unmarked node for the same property).
                 if (e.o?.t) continue;
         transientStoreNodes.delete(e);
-        e.o?.ft?.();
+        e.o?.Et?.();
     }
 }
 
@@ -106,46 +108,162 @@ function setProjectionWriteActive(e) {
  */ function createBatch() {
     return {
         Te: clock,
-        yt: [],
-        Ne: new Map,
-        Ke: [],
-        m: [],
-        cn: new Set,
-        oe: [],
-        bt: {
-            Lt: [ [], [] ],
+        Lt: [],
+        _e: new Map,
+        ze: [],
+        A: [],
+        En: new Set,
+        ue: [],
+        Bt: {
+            Mt: [ [], [] ],
             Qt: []
         },
-        an: false,
-        ln: new Set
+        sn: false,
+        cn: new Set
     };
 }
 
 function mergeTransitionState(e, t) {
-    t.an = e;
-    e.oe.push(...t.oe);
-    for (const i of activeLanes) if (i._e === t) i._e = e;
-    if (t.Ke.length) {
+    t.sn = e;
+    e.ue.push(...t.ue);
+    for (const i of activeLanes) if (i.Ae === t) i.Ae = e;
+    if (t.ze.length) {
         // 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.
-        e.Ke.push(...t.Ke);
-        t.Ke.length = 0;
+        e.ze.push(...t.ze);
+        t.ze.length = 0;
     }
-    if (t.m.length) {
+    if (t.A.length) {
         // 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.
-        e.m.push(...t.m);
-        t.m.length = 0;
+        e.A.push(...t.A);
+        t.A.length = 0;
     }
-    for (const i of t.cn) e.cn.add(i);
-    for (const [i, n] of t.Ne) {
-        let t = e.Ne.get(i);
-        if (!t) e.Ne.set(i, t = new Set);
+    for (const i of t.En) e.En.add(i);
+    // Patch-channel stash (store/next/patch.ts): entries held for the outgoing
+    // transition must ride the merge like every other per-transition
+    // collection — releaseBatch only reads the COMMITTING transition's stash,
+    // so a stranded sidecar would silently drop its patches. Move (don't
+    // copy), same aliasing rule as the collections above. The field is an
+    // expando so this module stays free of patch imports (pay-for-use).
+        const i = t.wt;
+    if (i !== undefined) {
+        t.wt = undefined;
+        let n = e.wt;
+        if (n !== undefined) n.push(...i); else n = e.wt = i;
+        // Retarget the entries' coalescing stamps to the surviving stash
+        // (opaque backref contract with store/next/patch.ts): without this a
+        // post-merge emission misses the stamp and pushes a SECOND entry —
+        // the record's patch applies twice at commit (re-audit 5, P1-2).
+                for (let e = 0; e < i.length; e++) {
+            const t = i[e].pc;
+            if (t !== undefined && t.qe === i[e]) t.qa = n;
+        }
+    }
+    for (const [i, n] of t._e) {
+        let t = e._e.get(i);
+        if (!t) e._e.set(i, t = new Set);
         for (const e of n) t.add(e);
     }
-    for (const i of t.ln) e.ln.add(i);
+    for (const i of t.cn) e.cn.add(i);
+}
+
+/**
+ * Flip-entanglement (#3164 follow-up): `until()` is a declaration of
+ * relatedness — the predicate names the condition that confirms the awaiting
+ * transaction. When the predicate settles truthy, every live foreign
+ * transition whose staged write it read IS the confirming event by the
+ * user's own definition, so it merges into the awaiting transaction and
+ * reveals at the joint settle — the cross-primitive twin of the family fold
+ * (a landing on an optimism-carrying family joins the retaining
+ * transaction). Non-flipping updates never pass through here: falsy
+ * evaluations don't entangle, so unrelated traffic on the watched sources
+ * reveals freely on its own schedule.
+ *
+ * Runs inside the predicate's compute (pure phase) — the confirming
+ * transition's stamps are still live and its commit decision hasn't run, so
+ * the merge lands before any reveal. Only the tree-shaken graphs that call
+ * `until()` retain this.
+ */ function entangleConfirmingTransitions(e, t) {
+    t = currentTransition(t);
+    if (t.sn === true) return;
+    // The confirming evidence is a dep whose value is STAGED (pending,
+    // uncommitted) at flip evaluation — committed deps are public already and
+    // carry nothing to entangle. A staged dep lives in one of two carriers: a
+    // stamped transition, or the queue's current batch (ambient registrations
+    // don't stamp; "ambient work IS a transaction" — the batch is the
+    // carrier). The entangle STEALS the carrier's staged cargo — its pending
+    // nodes move (re-stamped) into the awaiting transaction and reveal at its
+    // settle — but never the carrier itself: its async reporters, actions,
+    // and stashes are its own future (a live stream's flight must not chain
+    // the awaiting transaction to landings that haven't happened; a merged
+    // reporter deadlocked exactly that way).
+        let i = false;
+    for (let n = e.ut; n !== null; n = n.lt) {
+        const s = n.ot;
+        if (s.Pe !== NOT_PENDING) {
+            const e = s.Ae;
+            const n = e != null ? currentTransition(e) : null;
+            // Skip the awaiting transaction's own cargo (t === target: a
+            // fold-staged landing or a write the action itself issued — hold and
+            // reveal already correct) and dead carriers. Ambient-batch staging
+            // (t === null) must leave the batch NOW — it commits at this flush's
+            // end, which would reveal the confirmation under the live optimism
+            // it just confirmed.
+                        const r = n === null ? currentBatch.Lt : n !== t && n.sn !== true ? n.Lt : null;
+            if (r !== null) i = stealEntangledCargo(r, t) || i;
+        }
+        if (n === e.je) break;
+    }
+    // The steal never activates the awaiting transaction: the predicate can
+    // flip inside another transaction's finalize heap, and adopting the queue
+    // batch there hands the stolen cargo to that finalize's commit sweep — a
+    // premature reveal at a foreign settle. Subscribers that computed against
+    // the pre-steal world were re-dirtied by the steal itself, so this
+    // flush's applies paint the masked (mid-hold) view; the cargo commits at
+    // the awaiting transaction's own settle.
+}
+
+/** Move a confirming carrier's staged nodes into the awaiting transaction:
+ * re-stamp and arm the held-truth mask (override-covered nodes skip it —
+ * the override already hides their staged value per A17, and is usually
+ * the very optimism this confirmation settles); the mask's commit
+ * registers the settle-side post-revert wake. The carrier's array is
+ * emptied so its own commit point commits none of the stolen cargo.
+ *
+ * EFFECT subs of stolen nodes re-run: any that recomputed against the
+ * staging BEFORE the steal (the carrier's landing notified them as a plain
+ * write) hold a private torn result — override composed with confirming
+ * truth — that the next paint gate (stash-point lane run, a foreign
+ * flush's completion drain) would show. Re-running them under the mask
+ * re-derives the mid-hold view in this same heap pass. PURE computeds are
+ * deliberately NOT re-run: a torn staged value of theirs is itself stolen
+ * cargo — masked at read, so ordinary readers already serve their
+ * committed value — while re-running them would re-derive the OLD world
+ * and re-stage it over the held truth. The reveal re-notifies
+ * (commitPendingNodes), which is when they re-derive for real. */ function stealEntangledCargo(e, t) {
+    if (e === t.Lt || e.length === 0) return false;
+    for (let i = 0; i < e.length; i++) {
+        const n = e[i];
+        n.Ae = t;
+        t.Lt.push(n);
+        // Override-covered nodes stay silent AND unmasked: the override is the
+        // display (A17 — its staging never notified, its revert will), so their
+        // subs saw nothing and re-running one would break the silence with a
+        // duplicate fire of an unchanged view.
+                if (!hasActiveOverride(n)) {
+            n.T |= CONFIG_HELD_TRUTH;
+            for (let e = n.u; e !== null; e = e.ae) {
+                const t = e.ce;
+                if (t.he && !(t.T & CONFIG_AUTHORITATIVE_READ)) enqueueSub(t);
+            }
+        }
+    }
+    e.length = 0;
+    transitions.add(t);
+    return true;
 }
 
 function schedule() {
@@ -155,7 +273,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.sn && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.fn && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -189,30 +307,30 @@ function notifyHalted() {
 let queueRunToken = 0;
 
 class Queue {
-    ve=null;
-    Lt=[ [], [] ];
+    ke=null;
+    Mt=[ [], [] ];
     Qt=[];
-    Mt=0;
+    jt=0;
     created=clock;
     addChild(e) {
         this.Qt.push(e);
-        e.ve = this;
+        e.ke = this;
     }
     removeChild(e) {
         const t = this.Qt.indexOf(e);
         if (t >= 0) {
             this.Qt.splice(t, 1);
-            e.ve = null;
+            e.ke = null;
         }
     }
     notify(e, t, i, n) {
-        if (this.ve) return this.ve.notify(e, t, i, n);
+        if (this.ke) return this.ke.notify(e, t, i, n);
         return false;
     }
     run(e) {
-        if (this.Lt[e - 1].length) {
-            const t = this.Lt[e - 1];
-            this.Lt[e - 1] = [];
+        if (this.Mt[e - 1].length) {
+            const t = this.Mt[e - 1];
+            this.Mt[e - 1] = [];
             runQueue(t, e);
         }
         // Effects run here can dispose owners, and disposal removes queues from
@@ -226,8 +344,8 @@ class Queue {
         const i = ++queueRunToken;
         for (let n = 0; n < t.length; ) {
             const s = t[n];
-            if (s.Mt !== i) {
-                s.Mt = i;
+            if (s.jt !== i) {
+                s.jt = i;
                 s.run?.(e);
                 if (t[n] !== s) {
                     n = 0;
@@ -242,23 +360,23 @@ class Queue {
             // Route to lane's effect queue if we're in an optimistic recomputation
             if (currentOptimisticLane) {
                 const i = findLane(currentOptimisticLane);
-                i.en[e - 1].push(t);
+                i.tn[e - 1].push(t);
             } else {
-                this.Lt[e - 1].push(t);
+                this.Mt[e - 1].push(t);
             }
         }
         schedule();
     }
     stashQueues(e) {
-        e.Lt[0].push(...this.Lt[0]);
-        e.Lt[1].push(...this.Lt[1]);
-        this.Lt = [ [], [] ];
+        e.Mt[0].push(...this.Mt[0]);
+        e.Mt[1].push(...this.Mt[1]);
+        this.Mt = [ [], [] ];
         for (let t = 0; t < this.Qt.length; t++) {
             let i = this.Qt[t];
             let n = e.Qt[t];
             if (!n) {
                 n = {
-                    Lt: [ [], [] ],
+                    Mt: [ [], [] ],
                     Qt: []
                 };
                 e.Qt[t] = n;
@@ -267,8 +385,8 @@ class Queue {
         }
     }
     restoreQueues(e) {
-        this.Lt[0].push(...e.Lt[0]);
-        this.Lt[1].push(...e.Lt[1]);
+        this.Mt[0].push(...e.Mt[0]);
+        this.Mt[1].push(...e.Mt[1]);
         for (let t = 0; t < e.Qt.length; t++) {
             const i = e.Qt[t];
             let n = this.Qt[t];
@@ -278,48 +396,48 @@ class Queue {
 }
 
 class GlobalQueue extends Queue {
-    sn=false;
+    fn=false;
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
-    k=createBatch();
-    static Ce;
+    m=createBatch();
     static Fe;
-    static tt;
-    static Vt=null;
+    static He;
+    static it;
+    static qt=null;
     // Store-side hook: drops a keyless affects() mark's identity scope when the
     // carrier node's last registration releases (wired by store.ts, mirroring
     // _clearOptimisticStore).
-    static G=null;
+    static p=null;
     // affects()-side hooks (wired by affects.ts, mirroring _update): the mark
     // engine — count/register/release — lives with the feature. Every call site
     // is gated by state only that module creates, so `!` invocations are safe
     // once the gate holds.
+    static G=null;
     static M=null;
-    static h=null;
-    static j=null;
+    static N=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static Rt=null;
-    static Gt=null;
+    static Pt=null;
+    static ht=null;
     // Verdict-layer hooks (wired by verdict.ts when isPending()/latest() are
     // imported; null in apps that never use them). Call sites either guard for
     // null or sit behind state only the verdict layer can create (`!` is safe
     // there: `_pendingSignal`/`_latestValueComputed` are only ever assigned by
     // verdict.ts, and `pendingCheckActive`/`latestReadActive` only flip inside
     // isPending()/latest()).
-    static Oe=null;
+    static Re=null;
     static de=null;
-    static ye=null;
+    static me=null;
     static un=null;
-    static Pt=null;
-    static Dt=null;
+    static gt=null;
     static Ht=null;
-    static Je=null;
-    static p=null;
-    static Bt=null;
+    static kt=null;
+    static et=null;
+    static k=null;
+    static Wt=null;
     // Re-asks probes whose verdict was provisionally suppressed by a fresh read
     // of a held value, once the transaction gains an async blocker (#3028).
-    static wt=null;
+    static zt=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -327,40 +445,56 @@ class GlobalQueue extends Queue {
     // `_overrideValue` slot, a lane in `activeLanes`, an `_optimisticNodes`
     // entry, or a non-null `currentOptimisticLane`, so `!` invocations are safe
     // once the gate holds.
-    static vt=null;
-    static fn=null;
-    static En=null;
+    static xt=null;
     static Tn=null;
     static dn=null;
-    static Ft=null;
-    static ht=null;
-    static gt=null;
-    static je=null;
-    static $e=null;
-    static ze=null;
     static In=null;
+    static Nn=null;
+    /** Patch-channel optimistic drain (next/patch.ts): optimistic emissions
+     * apply at lane-effect timing — visible in flight, unlike the regular
+     * effect queues an action stashes. Injected; null when unused. */
+    static ln=null;
+    static vt=null;
+    static Vt=null;
+    static bt=null;
+    static Be=null;
+    static $e=null;
+    /** Authoritative-view reader wakeup (until()): installed at first until() call.
+     * Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which only until()'s
+     * carve-out read can set, so `!` invocations are safe once the gate holds. */
+    static Ue=null;
+    static Xe=null;
+    static _n=null;
     flush() {
-        if (this.sn) return;
+        if (this.fn) return;
         // Fast drain: nothing in flight but plain pending commits — no dirty
         // computeds, no queued effects, no child queues, no transitions/lanes/
         // optimistic state. Commit and go; anything a commit hook schedules
         // (companion snaps, store folds notifying subs) re-arms `scheduled`
         // below and the outer drain loop takes the full spine next round.
-                if (activeTransition === null && dirtyQueue.EE < dirtyQueue.xe && this.Lt[0].length === 0 && this.Lt[1].length === 0 && this.Qt.length === 0 && canUseSimpleSyncFlush(this)) {
-            this.sn = true;
+                if (activeTransition === null && dirtyQueue.EE < dirtyQueue.Qe && this.Mt[0].length === 0 && this.Mt[1].length === 0 && this.Qt.length === 0 && canUseSimpleSyncFlush(this)) {
+            this.fn = true;
             try {
+                // Sweep first: unobserved() pulls swept nodes out of the dirty heap,
+                // so a dormant memo dirtied in the same tick is reclaimed instead of
+                // recomputed (matching the old inline dispose-on-read counts).
+                sweepDormant();
                 commitPendingNodes();
             } finally {
-                this.sn = false;
+                this.fn = false;
             }
             clock++;
-            scheduled = dirtyQueue.EE >= dirtyQueue.xe || this.Lt[0].length !== 0 || this.Lt[1].length !== 0 || this.k.yt.length !== 0;
+            scheduled = dirtyQueue.EE >= dirtyQueue.Qe || this.Mt[0].length !== 0 || this.Mt[1].length !== 0 || this.m.Lt.length !== 0;
             return;
         }
-        this.sn = true;
+        this.fn = true;
         try {
             if (false) ;
-            runHeap(dirtyQueue, GlobalQueue.Ce);
+            // Before runHeap for the same reason as the fast drain above; late
+            // subscribers (an effect reading a swept memo this flush) revive it,
+            // which is the pay-for-use contract.
+                        sweepDormant();
+            runHeap(dirtyQueue, GlobalQueue.Fe);
             if (activeTransition) {
                 const e = transitionComplete(activeTransition);
                 if (!e) {
@@ -373,74 +507,74 @@ class GlobalQueue extends Queue {
                     // zombies here. Height-adjust entries still process normally: a
                     // dirtied one keeps its height flag and falls through to runHeap's
                     // adjustHeight path on the next pass of the bucket.
-                                        runHeap(zombieQueue, this.k === e ? cancelZombieRecompute : GlobalQueue.Ce);
+                                        runHeap(zombieQueue, this.m === e ? cancelZombieRecompute : GlobalQueue.Fe);
                     // 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.k === e) currentBatch = this.k = createBatch();
+                                        if (this.m === e) currentBatch = this.m = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
-                        GlobalQueue.dn(EFFECT_RENDER);
-                        GlobalQueue.dn(EFFECT_USER);
+                        GlobalQueue.Nn(EFFECT_RENDER);
+                        GlobalQueue.Nn(EFFECT_USER);
                     }
-                    this.stashQueues(e.bt);
+                    this.stashQueues(e.Bt);
                     clock++;
                     // 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.EE >= dirtyQueue.xe || this.k.yt.length > 0;
-                    reassignPendingTransition(e.yt);
+                                        scheduled = dirtyQueue.EE >= dirtyQueue.Qe || this.m.Lt.length > 0;
+                    reassignPendingTransition(e.Lt);
                     activeTransition = null;
                     finalizePureQueue(null, true);
                     return;
                 }
                 const t = activeTransition;
-                const i = this.k;
-                i !== t && i.yt.push(...t.yt);
-                this.restoreQueues(t.bt);
+                const i = this.m;
+                i !== t && i.Lt.push(...t.Lt);
+                this.restoreQueues(t.Bt);
                 transitions.delete(t);
                 activeTransition = null;
-                reassignPendingTransition(i.yt);
+                reassignPendingTransition(i.Lt);
                 finalizePureQueue(t);
                 if (i === t) {
                     // 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 e = createBatch();
-                    e.yt = i.yt;
-                    e.Ke = i.Ke;
-                    e.m = i.m;
-                    e.cn = i.cn;
-                    currentBatch = this.k = e;
+                    e.Lt = i.Lt;
+                    e.ze = i.ze;
+                    e.A = i.A;
+                    e.En = i.En;
+                    currentBatch = this.m = e;
                 }
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
-                    if (dirtyQueue.EE >= dirtyQueue.xe) {
-                        runHeap(dirtyQueue, GlobalQueue.Ce);
+                    if (dirtyQueue.EE >= dirtyQueue.Qe) {
+                        runHeap(dirtyQueue, GlobalQueue.Fe);
                         commitPendingNodes();
                     }
                 } else {
-                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.Ce);
+                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.Fe);
                     finalizePureQueue();
                 }
             }
             clock++;
             // Check if finalization added items to the heap (from optimistic reversion)
-                        scheduled = dirtyQueue.EE >= dirtyQueue.xe;
+                        scheduled = dirtyQueue.EE >= dirtyQueue.Qe;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.dn(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue.Nn(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.dn(EFFECT_USER);
+            activeLanes.size && GlobalQueue.Nn(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.sn = false;
+            this.fn = false;
         }
     }
     notify(e, t, i, n) {
@@ -452,16 +586,16 @@ class GlobalQueue extends Queue {
                 // channel) updates display state on its way up but must be invisible
                 // to completion accounting BY CONSTRUCTION: it never registers a
                 // reporter and never counts toward the loading-boundary diagnostic.
-                                if (t?.i) return true;
+                                if (t?.l) return true;
                 if (activeTransition && t) {
                     const i = t.source;
-                    let n = activeTransition.Ne.get(i);
-                    if (!n) activeTransition.Ne.set(i, n = new Set);
+                    let n = activeTransition._e.get(i);
+                    if (!n) activeTransition._e.set(i, n = new Set);
                     const s = n.size;
                     n.add(e);
                     if (n.size !== s) {
                         schedule();
-                        GlobalQueue.wt?.(activeTransition);
+                        GlobalQueue.zt?.(activeTransition);
                     }
                 }
             }
@@ -470,8 +604,17 @@ class GlobalQueue extends Queue {
         return false;
     }
     initTransition(e) {
-        if (e) e = currentTransition(e);
-        if (e && e === activeTransition) return;
+        if (e) {
+            e = currentTransition(e);
+            // A finished transaction cannot be re-entered: its state is committed
+            // or reverted, so "rejoining" it (A26) is meaningless and re-activating
+            // it spins the drain loop (#3140). The refusal must be a bare return —
+            // redirecting the caller to a fresh batch would re-arm the loop with a
+            // new transaction identity each pass. Stamps are cleared at commit, so
+            // this is a belt for paths that hand over a chased-dead reference
+            // (merged chains, async settles racing completion).
+                        if (e.sn === true || e === activeTransition) return;
+        }
         if (!e && activeTransition && activeTransition.Te === clock) return;
         if (!activeTransition) {
             activeTransition = e ?? createBatch();
@@ -483,7 +626,7 @@ class GlobalQueue extends Queue {
         }
         transitions.add(activeTransition);
         activeTransition.Te = clock;
-        const t = this.k;
+        const t = this.m;
         if (t !== activeTransition) {
             // Adopt the ambient batch into the transaction, then make the
             // transaction the batch so later registrations land there directly.
@@ -492,34 +635,43 @@ class GlobalQueue extends Queue {
             // 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 e = 0; e < t.yt.length; e++) {
-                const i = t.yt[e];
-                i._e = activeTransition;
-                activeTransition.yt.push(i);
+            for (let e = 0; e < t.Lt.length; e++) {
+                const i = t.Lt[e];
+                i.Ae = activeTransition;
+                activeTransition.Lt.push(i);
             }
-            for (let e = 0; e < t.Ke.length; e++) {
-                const i = t.Ke[e];
-                i._e = activeTransition;
-                activeTransition.Ke.push(i);
+            for (let e = 0; e < t.ze.length; e++) {
+                const i = t.ze[e];
+                i.Ae = activeTransition;
+                activeTransition.ze.push(i);
             }
-            if (t.m.length) activeTransition.m.push(...t.m);
-            for (const e of t.cn) activeTransition.cn.add(e);
+            if (t.A.length) activeTransition.A.push(...t.A);
+            for (const e of t.En) activeTransition.En.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();
+                        if (t.cn.size) {
+                for (const e of t.cn) activeTransition.cn.add(e);
+                t.cn.clear();
             }
-            currentBatch = this.k = activeTransition;
+            currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
-            if (!e._e) e._e = activeTransition;
+            if (!e.Ae) e.Ae = activeTransition;
         }
+        // A transaction's ambient window is one flush. Entering must therefore
+        // guarantee a flush: a transaction opened with no writes (an action whose
+        // first statements only await) otherwise leaves activeTransition and the
+        // adopted batch armed across the async gap, and the next unrelated work
+        // to arrive — an optimistic store's authoritative landing, a plain async
+        // settle — is adopted into a transaction it has nothing to do with
+        // (#3141). The scheduled flush parks the incomplete transaction through
+        // the normal machinery and detaches the ambient slots first.
+                schedule();
     }
 }
 
 function queuePendingNode(e) {
-    currentBatch.yt.push(e);
+    currentBatch.Lt.push(e);
 }
 
 // Sticky: flips true on the first refresh() ever (the only setter of
@@ -543,7 +695,7 @@ function armReaskClear() {
 function insertSubs(e, t = false) {
     // §12d: stamp before walking — setSignal's staged-rewrite fast path skips
     // the next walk for this node while the epoch holds (marking is idempotent).
-    e._t = notifyEpoch;
+    e.It = notifyEpoch;
     // Get source lane: prefer node's own lane over current context
     // This is important for isPending signals which need their own lane to flush immediately
     // Presence bits gate the optional-slot probes (see constants.ts): one
@@ -551,14 +703,14 @@ function insertSubs(e, t = false) {
     // lookups in the hottest notify loop. Bits are sticky — the field read
     // stays authoritative when a bit is set.
         const i = e.T;
-    const n = (i & CONFIG_HAS_LANE ? e.o?.Be : undefined) || currentOptimisticLane;
-    const s = (i & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.Qe !== undefined;
-    const o = reaskArmed;
-    for (let i = e.u; i !== null; i = i.fe) {
-        const e = i.ae;
+    const n = (i & CONFIG_HAS_LANE ? e.o?.Je : undefined) || currentOptimisticLane;
+    const s = (i & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.We !== undefined;
+    const r = reaskArmed;
+    for (let i = e.u; i !== null; i = i.ae) {
+        const e = i.ce;
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
-                if (o) e.ie &= ~REACTIVE_REASK;
+                if (r) e.ie &= ~REACTIVE_REASK;
         // Missed-wake latch (#3037): this write is landing while the subscriber
         // is mid-recompute (a nested pull committing beneath its reads), and the
         // heap refuses RECOMPUTING nodes. A gen-current link means the pass
@@ -567,7 +719,7 @@ function insertSubs(e, t = false) {
         // pass either re-reads them fresh or trims them), and neither does the
         // tail link: it is the read IN FLIGHT — read() links before it pulls, so
         // this very commit is what that read returns.
-                if (e.ie & REACTIVE_RECOMPUTING_DEPS && i.ll === e.Ze && i !== e.Ye) e.ie |= REACTIVE_MISSED_WAKE;
+                if (e.ie & REACTIVE_RECOMPUTING_DEPS && i.Ft === e.Ke && i !== e.je) e.ie |= REACTIVE_MISSED_WAKE;
         if (s && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
             e.ie |= REACTIVE_SNAPSHOT_STALE;
             continue;
@@ -578,7 +730,7 @@ function insertSubs(e, t = false) {
         } else if (t) {
             e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        if (e.o) e.o.Be = undefined;
+                        if (e.o) e.o.Je = undefined;
         }
         enqueueSub(e);
     }
@@ -586,7 +738,7 @@ function insertSubs(e, t = false) {
 
 function commitPendingNode(e) {
     const t = e;
-    if (!t.Se) {
+    if (!t.oe) {
         if (e.Pe !== NOT_PENDING) {
             e.be = e.Pe;
             e.Pe = NOT_PENDING;
@@ -598,15 +750,15 @@ function commitPendingNode(e) {
         e.be = e.Pe;
         e.Pe = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.Re && e.Re !== EFFECT_TRACKED) e.Xe = true;
+                if (e.he && e.he !== EFFECT_TRACKED) e.tt = true;
     }
     // The committed hold is the first observable answer for a loading-window
     // node — the window closes here, not at compute time (#2990). Unconditional
     // store to an always-present computed slot.
-        t.Ie = false;
+        t.Ne = false;
     t.ie &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
-    if (t.o != null && (t.o.qe !== null || t.o.We !== null)) GlobalQueue.Fe(t, false, true);
+    if (t.o != null && (t.o.Ye !== null || t.o.qe !== null)) GlobalQueue.He(t, false, true);
     if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.un(e);
 }
 
@@ -621,13 +773,49 @@ function setStoreCommitHook(e) {
     storeCommitHook = e;
 }
 
+/** Patch-channel release hook (next/patch.ts): transition-stamped patch
+ * emissions are released when THEIR batch commits. Transitions never
+ * abort: failed actions still commit (only optimistic overrides revert),
+ * and merged-away transitions hand their stash to the survivor
+ * (mergeTransitionState) — every stash drains exactly once. Injected like
+ * storeCommitHook to stay tree-shakeable. */ let patchCommitHook = null;
+
+function setPatchCommitHook(e) {
+    patchCommitHook = e;
+}
+
+/** Held truth committed this finalize, awaiting its post-revert wake (see
+ * finalizePureQueue): the commit IS the reveal, but subscribers must not
+ * re-derive until the settling transaction's optimistic overrides have
+ * reverted — a commit-time wake recomputes them in the window where
+ * confirming truth is committed and the override still displays, a torn
+ * frame no timeline contains. */ const heldRevealed = [];
+
 function commitPendingNodes() {
-    const e = currentBatch.yt;
+    const e = currentBatch.Lt;
     for (let t = 0; t < e.length; t++) {
-        commitPendingNode(e[t]);
+        const i = e[t];
+        commitPendingNode(i);
+        // The stamp dies with the commit (#3143) — symmetric with
+        // resolveOptimisticNodes clearing optimistic stamps. A stamp outliving
+        // its transaction let any later write (even a value-equal no-op, which
+        // re-opens before the equality bail) resurrect the finished transaction;
+        // a boundary flag rewritten every finalize pass then spun the drain loop
+        // forever (#3140). The held-truth mark dies the same death — the commit
+        // IS the reveal — but its wake defers to the post-revert pass: ordinary
+        // subscribers were masked to committed all hold (some re-derived against
+        // that old view and cached it), and commits are otherwise silent
+        // (staging already notified), so without a wake they'd hold the old
+        // world forever.
+                i.Ae = null;
+        if (i.T & CONFIG_HELD_TRUTH) {
+            i.T &= ~CONFIG_HELD_TRUTH;
+            heldRevealed.push(i);
+        }
     }
     e.length = 0;
     storeCommitHook?.();
+    patchCommitHook?.(currentBatch);
 }
 
 function finalizePureQueue(e = null, t = false) {
@@ -636,25 +824,25 @@ function finalizePureQueue(e = null, t = false) {
     const i = !t;
     if (i) commitPendingNodes();
     if (!t && globalQueue.Qt.length) checkBoundaryChildren(globalQueue);
-    const n = dirtyQueue.EE >= dirtyQueue.xe;
-    if (n) runHeap(dirtyQueue, GlobalQueue.Ce);
+    const n = dirtyQueue.EE >= dirtyQueue.Qe;
+    if (n) runHeap(dirtyQueue, GlobalQueue.Fe);
     if (i) {
         if (n) commitPendingNodes();
         // The settling batch: the completing transaction's, or the ambient one.
-                const t = e ?? globalQueue.k;
+                const t = e ?? globalQueue.m;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.Ke.length) GlobalQueue.fn(t.Ke);
+                if (t.ze.length) GlobalQueue.Tn(t.ze);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
         // 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 (t.cn.size) {
+            for (const e of t.cn) {
                 if (e.ie & REACTIVE_DISPOSED) continue;
                 enqueueSub(e);
             }
-            t.ln.clear();
+            t.cn.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.
@@ -666,18 +854,34 @@ function finalizePureQueue(e = null, t = false) {
         // held boundary display state through the visual channel, and their
         // release is the display-state update point — re-run the boundary sweep
         // (the earlier sweep above ran while the marks were still live).
-                if (t.m.length) {
-            GlobalQueue.M(t.m);
+                if (t.A.length) {
+            GlobalQueue.G(t.A);
             if (globalQueue.Qt.length) checkBoundaryChildren(globalQueue);
         }
         // 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). The
         // completing transition scopes the clear to its own layer keys (#2899).
-                if (t.cn.size) GlobalQueue.Vt(t.cn, e);
+                if (t.En.size) GlobalQueue.qt(t.En, e);
+        // Held-truth reveal wake (#3164), post-revert by construction: this
+        // finalize committed confirming truth whose subscribers were masked all
+        // hold — some re-derived against the committed view (the staging, or a
+        // confirming carrier's landing, notified them as a plain write) and
+        // cached it, and stash-restored applies may carry those torn values.
+        // Waking and recomputing HERE — after _resolveOptimistic and the store
+        // clears above — means every apply paints the settled view; a wake at
+        // commit time would recompute them in the window where truth is
+        // committed but the settling transaction's overrides still display.
+                if (heldRevealed.length !== 0) {
+            while (heldRevealed.length) insertSubs(heldRevealed.pop());
+            if (dirtyQueue.EE >= dirtyQueue.Qe) {
+                runHeap(dirtyQueue, GlobalQueue.Fe);
+                commitPendingNodes();
+            }
+        }
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.Tn(e);
+                if (activeLanes.size) GlobalQueue.In(e);
     }
 }
 
@@ -706,7 +910,7 @@ function checkBoundaryChildren(e) {
 
 function reassignPendingTransition(e) {
     for (let t = 0; t < e.length; t++) {
-        e[t]._e = activeTransition;
+        e[t].Ae = activeTransition;
     }
 }
 
@@ -717,7 +921,7 @@ const globalQueue = new GlobalQueue;
 // 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.k;
+let currentBatch = globalQueue.m;
 
 function flush(e) {
     if (e) {
@@ -734,7 +938,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.sn) {
+    if (globalQueue.fn) {
         return;
     }
     if (halted) return;
@@ -752,21 +956,21 @@ function runQueue(e, t) {
 function reporterBlocksSource(e, t) {
     if (e.ie & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
     if (e.o?.le?.has(t)) return true;
-    for (let i = e.nt; i; i = i.it) {
-        let e = i.ut;
+    for (let i = e.ut; i; i = i.lt) {
+        let e = i.ot;
         while (e) {
-            if (e === t || e.lt === t) return true;
-            e = e.o?.It;
+            if (e === t || e.st === t) return true;
+            e = e.o?.Tt;
         }
     }
     return !!(e.S & STATUS_PENDING && e.o?._ instanceof NotReadyError && e.o?._.source === t);
 }
 
 function transitionComplete(e) {
-    if (e.an) return true;
-    if (e.oe.length) return false;
+    if (e.sn) return true;
+    if (e.ue.length) return false;
     let t = true;
-    for (const [i, n] of e.Ne) {
+    for (const [i, n] of e._e) {
         let s = false;
         for (const e of n) {
             if (reporterBlocksSource(e, i)) {
@@ -775,7 +979,7 @@ function transitionComplete(e) {
             }
             n.delete(e);
         }
-        if (!s) e.Ne.delete(i); else if (i.S & STATUS_PENDING && i.o?._?.source === i) {
+        if (!s) e._e.delete(i); else if (i.S & STATUS_PENDING && i.o?._?.source === i) {
             t = false;
             break;
         }
@@ -783,13 +987,13 @@ 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.En?.(e)) t = false;
-    t && (e.an = true);
+        if (t && GlobalQueue.dn?.(e)) t = false;
+    t && (e.sn = true);
     return t;
 }
 
 function currentTransition(e) {
-    while (e.an && typeof e.an === "object") e = e.an;
+    while (e.sn && typeof e.sn === "object") e = e.sn;
     return e;
 }
 
@@ -803,4 +1007,27 @@ function runInTransition(e, t) {
     }
 }
 
-export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, bumpNotifyEpoch, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, notifyEpoch, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runInTransition, schedule, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };
+/** Run `fn` with `transition` as BOTH the ambient transaction and the
+ * registration batch, restoring both after. runInTransition alone is not
+ * enough for code that WRITES on behalf of a transaction from inside someone
+ * else's window (optimistic replay re-arming a still-open action's edits
+ * during a landing commit, #3123): registrations route through the queue's
+ * batch pointer, and a bare activeTransition swap leaves them in the ambient
+ * batch — a plain batch "completes" at the next flush and reverts optimistic
+ * registrations that were supposed to live with the transaction.
+ * initTransition is the wrong tool here: it MERGES the currently ambient
+ * transaction into the target, entangling whatever the interrupted window
+ * belonged to. */ function runAsTransitionBatch(e, t) {
+    const i = activeTransition;
+    const n = globalQueue.m;
+    try {
+        activeTransition = currentTransition(e);
+        currentBatch = globalQueue.m = activeTransition;
+        return t();
+    } finally {
+        activeTransition = i;
+        currentBatch = globalQueue.m = n;
+    }
+}
+
+export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, bumpNotifyEpoch, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, entangleConfirmingTransitions, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, hasActiveOverride, insertSubs, notifyEpoch, patchCommitHook, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runAsTransitionBatch, runInTransition, schedule, setPatchCommitHook, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };