@solidjs/signals 2.0.0-rc.4 → 2.0.0-rc.6

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";
 
@@ -10,9 +10,9 @@ 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";
 
@@ -21,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
 };
 
@@ -63,7 +63,7 @@ const transientStoreNodes = new Set;
 
 function canUseSimpleSyncFlush(e) {
     const t = e.m;
-    return transitions.size === 0 && activeLanes.size === 0 && e.Qt.length === 0 && t.Ke.length === 0 && t.A.length === 0 && t.Tn.size === 0 && transientStoreNodes.size === 0;
+    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() {
@@ -73,14 +73,14 @@ function sweepTransientStoreNodes() {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e.Pe !== NOT_PENDING) continue;
-        if (e.o?.De !== undefined && e.o?.De !== NOT_PENDING) continue;
+        if (e.Re !== NOT_PENDING) continue;
+        if (e.o?.Pe !== undefined && e.o?.Pe !== 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?.();
     }
 }
 
@@ -108,31 +108,31 @@ function setProjectionWriteActive(e) {
  */ function createBatch() {
     return {
         Te: clock,
-        yt: [],
-        Ne: new Map,
-        Ke: [],
+        Lt: [],
+        _e: new Map,
+        ze: [],
         A: [],
-        Tn: new Set,
+        En: new Set,
         ue: [],
-        bt: {
-            Lt: [ [], [] ],
+        Bt: {
+            Mt: [ [], [] ],
             Qt: []
         },
-        fn: false,
+        sn: false,
         cn: new Set
     };
 }
 
 function mergeTransitionState(e, t) {
-    t.fn = e;
+    t.sn = e;
     e.ue.push(...t.ue);
-    for (const i of activeLanes) if (i._e === t) i._e = e;
-    if (t.Ke.length) {
+    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.A.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
@@ -141,18 +141,18 @@ function mergeTransitionState(e, t) {
         e.A.push(...t.A);
         t.A.length = 0;
     }
-    for (const i of t.Tn) e.Tn.add(i);
+    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.Mt;
+        const i = t.wt;
     if (i !== undefined) {
-        t.Mt = undefined;
-        let n = e.Mt;
-        if (n !== undefined) n.push(...i); else n = e.Mt = i;
+        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 —
@@ -162,14 +162,110 @@ function mergeTransitionState(e, t) {
             if (t !== undefined && t.qe === i[e]) t.qa = n;
         }
     }
-    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, 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.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 r = n.ot;
+        if (r.Re !== NOT_PENDING) {
+            const e = r.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 s = n === null ? currentBatch.Lt : n !== t && n.sn !== true ? n.Lt : null;
+            if (s !== null) i = stealEntangledCargo(s, 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.ge && !(t.T & CONFIG_AUTHORITATIVE_READ)) enqueueSub(t);
+            }
+        }
+    }
+    e.length = 0;
+    transitions.add(t);
+    return true;
+}
+
 function schedule() {
     if (halted) {
         notifyHalted();
@@ -177,7 +273,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.En && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.fn && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -212,9 +308,9 @@ let queueRunToken = 0;
 
 class Queue {
     ke=null;
-    Lt=[ [], [] ];
+    Mt=[ [], [] ];
     Qt=[];
-    Vt=0;
+    jt=0;
     created=clock;
     addChild(e) {
         this.Qt.push(e);
@@ -232,9 +328,9 @@ class Queue {
         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
@@ -247,11 +343,11 @@ class Queue {
                 const t = this.Qt;
         const i = ++queueRunToken;
         for (let n = 0; n < t.length; ) {
-            const s = t[n];
-            if (s.Vt !== i) {
-                s.Vt = i;
-                s.run?.(e);
-                if (t[n] !== s) {
+            const r = t[n];
+            if (r.jt !== i) {
+                r.jt = i;
+                r.run?.(e);
+                if (t[n] !== r) {
                     n = 0;
                     continue;
                 }
@@ -264,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.rn[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;
@@ -289,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];
@@ -300,14 +396,14 @@ class Queue {
 }
 
 class GlobalQueue extends Queue {
-    En=false;
+    fn=false;
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
     m=createBatch();
-    static Ce;
     static Fe;
-    static tt;
-    static Bt=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).
@@ -321,27 +417,27 @@ class GlobalQueue extends Queue {
     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 Ue=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 kt=null;
+    static et=null;
     static k=null;
-    static wt=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 jt=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).
@@ -349,31 +445,35 @@ 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 kt=null;
+    static xt=null;
+    static Tn=null;
     static dn=null;
     static In=null;
     static Nn=null;
-    static _n=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 Ft=null;
-    static ht=null;
-    static gt=null;
-    static je=null;
+    static vt=null;
+    static Vt=null;
+    static bt=null;
+    static Be=null;
     static $e=null;
-    static ze=null;
-    static An=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 he=null;
+    static Xe=null;
+    static _n=null;
     flush() {
-        if (this.En) 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.En = 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
@@ -381,20 +481,20 @@ class GlobalQueue extends Queue {
                 sweepDormant();
                 commitPendingNodes();
             } finally {
-                this.En = false;
+                this.fn = false;
             }
             clock++;
-            scheduled = dirtyQueue.EE >= dirtyQueue.xe || this.Lt[0].length !== 0 || this.Lt[1].length !== 0 || this.m.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.En = true;
+        this.fn = true;
         try {
             if (false) ;
             // 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.Ce);
+            runHeap(dirtyQueue, GlobalQueue.Fe);
             if (activeTransition) {
                 const e = transitionComplete(activeTransition);
                 if (!e) {
@@ -407,7 +507,7 @@ 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.m === 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
@@ -417,64 +517,64 @@ class GlobalQueue extends Queue {
                                         if (this.m === e) currentBatch = this.m = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
-                        GlobalQueue._n(EFFECT_RENDER);
-                        GlobalQueue._n(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.m.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.m;
-                i !== t && i.yt.push(...t.yt);
-                this.restoreQueues(t.bt);
+                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.Lt = i.Lt;
+                    e.ze = i.ze;
                     e.A = i.A;
-                    e.Tn = i.Tn;
+                    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._n(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue.Nn(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue._n(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.En = false;
+            this.fn = false;
         }
     }
     notify(e, t, i, n) {
@@ -489,13 +589,13 @@ class GlobalQueue extends Queue {
                                 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);
-                    const s = n.size;
+                    let n = activeTransition._e.get(i);
+                    if (!n) activeTransition._e.set(i, n = new Set);
+                    const r = n.size;
                     n.add(e);
-                    if (n.size !== s) {
+                    if (n.size !== r) {
                         schedule();
-                        GlobalQueue.jt?.(activeTransition);
+                        GlobalQueue.zt?.(activeTransition);
                     }
                 }
             }
@@ -504,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();
@@ -526,18 +635,18 @@ 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.A.length) activeTransition.A.push(...t.A);
-            for (const e of t.Tn) activeTransition.Tn.add(e);
+            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.cn.size) {
@@ -547,13 +656,22 @@ class GlobalQueue extends Queue {
             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
@@ -577,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
@@ -585,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;
+    const n = (i & CONFIG_HAS_LANE ? e.o?.Je : undefined) || currentOptimisticLane;
+    const r = (i & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.We !== undefined;
+    const s = 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 (s) 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
@@ -601,8 +719,8 @@ 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.nn === e.Ze && i !== e.Ye) e.ie |= REACTIVE_MISSED_WAKE;
-        if (s && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
+                if (e.ie & REACTIVE_RECOMPUTING_DEPS && i.Ft === e.Ke && i !== e.je) e.ie |= REACTIVE_MISSED_WAKE;
+        if (r && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
             e.ie |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
@@ -612,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);
     }
@@ -621,26 +739,32 @@ function insertSubs(e, t = false) {
 function commitPendingNode(e) {
     const t = e;
     if (!t.oe) {
-        if (e.Pe !== NOT_PENDING) {
-            e.be = e.Pe;
-            e.Pe = NOT_PENDING;
+        if (e.Re !== NOT_PENDING) {
+            e.be = e.Re;
+            e.Re = NOT_PENDING;
         }
         if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.un(e);
         return;
     }
-    if (e.Pe !== NOT_PENDING) {
-        e.be = e.Pe;
-        e.Pe = NOT_PENDING;
+    if (e.Re !== NOT_PENDING) {
+        e.be = e.Re;
+        e.Re = 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.ge && e.ge !== EFFECT_TRACKED) e.tt = true;
+        // A quiet re-ask classification preserved through a held landing dies
+        // with the value commit — the commit IS the reveal (#3178). Gated on the
+        // staged value: status propagation queues pending nodes whose windows
+        // are still OPEN (no staged value), and their live classification must
+        // survive this sweep.
+                if (e.o) e.o.De = false;
     }
     // 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);
 }
 
@@ -666,10 +790,34 @@ 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?.();
@@ -682,15 +830,15 @@ 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.m;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.Ke.length) GlobalQueue.dn(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
@@ -720,10 +868,26 @@ function finalizePureQueue(e = null, t = false) {
         // 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.Tn.size) GlobalQueue.Bt(t.Tn, 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.Nn(e);
+                if (activeLanes.size) GlobalQueue.In(e);
     }
 }
 
@@ -752,7 +916,7 @@ function checkBoundaryChildren(e) {
 
 function reassignPendingTransition(e) {
     for (let t = 0; t < e.length; t++) {
-        e[t]._e = activeTransition;
+        e[t].Ae = activeTransition;
     }
 }
 
@@ -780,7 +944,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.En) {
+    if (globalQueue.fn) {
         return;
     }
     if (halted) return;
@@ -798,30 +962,30 @@ 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?.Et;
+            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.fn) return true;
+    if (e.sn) return true;
     if (e.ue.length) return false;
     let t = true;
-    for (const [i, n] of e.Ne) {
-        let s = false;
+    for (const [i, n] of e._e) {
+        let r = false;
         for (const e of n) {
             if (reporterBlocksSource(e, i)) {
-                s = true;
+                r = true;
                 break;
             }
             n.delete(e);
         }
-        if (!s) e.Ne.delete(i); else if (i.S & STATUS_PENDING && i.o?._?.source === i) {
+        if (!r) e._e.delete(i); else if (i.S & STATUS_PENDING && i.o?._?.source === i) {
             t = false;
             break;
         }
@@ -829,13 +993,20 @@ 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.In?.(e)) t = false;
-    t && (e.fn = true);
+        if (t && GlobalQueue.dn?.(e)) t = false;
+    t && (e.sn = true);
     return t;
 }
 
+/** A fresh, unentered transaction (#3146): the optimistic store's truth
+ * flight DECLARES an owned transaction instead of relying on whatever the
+ * ambient adoption machinery stamped on its firewall. Activate it with
+ * initTransition; it is a plain batch until then. */ function createTransition() {
+    return createBatch();
+}
+
 function currentTransition(e) {
-    while (e.fn && typeof e.fn === "object") e = e.fn;
+    while (e.sn && typeof e.sn === "object") e = e.sn;
     return e;
 }
 
@@ -849,4 +1020,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, patchCommitHook, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runInTransition, schedule, setPatchCommitHook, 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, createTransition, 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 };