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

package/dist/prod/core/scheduler.js

@@ -1,4 +1,4 @@
-import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_REASK, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_ZOMBIE, NOT_PENDING, EFFECT_TRACKED, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED } from "./constants.js";
+import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, NOT_PENDING, EFFECT_TRACKED, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED } from "./constants.js";
 
 import { currentOptimisticLane } from "./core.js";
 
@@ -55,7 +55,8 @@ function registerTransientStoreNode(e) {
 }
 
 function canUseSimpleSyncFlush(e) {
-    return transitions.size === 0 && activeLanes.size === 0 && e.wt.length === 0 && e.Be.length === 0 && e.N.length === 0 && e.Lt.size === 0 && transientStoreNodes.size === 0;
+    const t = e.N;
+    return transitions.size === 0 && activeLanes.size === 0 && e.Qt.length === 0 && t.Be.length === 0 && t._.length === 0 && t.dn.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
@@ -70,7 +71,7 @@ function sweepTransientStoreNodes() {
         // 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.P) continue;
+                if (e.M) continue;
         transientStoreNodes.delete(e);
         e.ct?.();
     }
@@ -89,31 +90,57 @@ function setProjectionWriteActive(e) {
     projectionWriteActive = e;
 }
 
+/**
+ * Ambient work IS a transaction: the global queue always carries one
+ * current-transaction-shaped batch (`globalQueue._batch`). With no transition
+ * active, registrations (pending commits, optimistic nodes, affects marks,
+ * optimistic stores) land in a plain ambient batch that the plain flush
+ * finalizes; when a transition initializes it adopts the ambient batch's
+ * contents and `_batch` becomes the transition itself, so later registrations
+ * land there directly — no per-field aliasing.
+ */ function createBatch() {
+    return {
+        Ie: clock,
+        yt: [],
+        Lt: new Map,
+        Be: [],
+        _: [],
+        dn: new Set,
+        Te: [],
+        Bt: {
+            Mt: [ [], [] ],
+            Qt: []
+        },
+        cn: false,
+        un: new Set
+    };
+}
+
 function mergeTransitionState(e, t) {
-    t.Ht = e;
+    t.cn = e;
     e.Te.push(...t.Te);
     for (const i of activeLanes) if (i.ve === t) i.ve = e;
     if (t.Be.length) {
-        // Move (don't copy): the global queue may still alias the outgoing
-        // array, and the adoption pass in initTransition would re-push its
+        // Move (don't copy): the global queue's batch may still be the outgoing
+        // transition, and the adoption pass in initTransition would re-push its
         // contents into the target — duplicating every entry.
         e.Be.push(...t.Be);
         t.Be.length = 0;
     }
-    if (t.N.length) {
-        // Move (don't copy): the global queue may still alias the outgoing
-        // array, and the adoption pass in initTransition would re-push its
+    if (t._.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.N.push(...t.N);
-        t.N.length = 0;
+        e._.push(...t._);
+        t._.length = 0;
     }
-    for (const i of t.Lt) e.Lt.add(i);
-    for (const [i, n] of t.qt) {
-        let t = e.qt.get(i);
-        if (!t) e.qt.set(i, t = new Set);
+    for (const i of t.dn) e.dn.add(i);
+    for (const [i, n] of t.Lt) {
+        let t = e.Lt.get(i);
+        if (!t) e.Lt.set(i, t = new Set);
         for (const e of n) t.add(e);
     }
-    for (const i of t.Qt) e.Qt.add(i);
+    for (const i of t.un) e.un.add(i);
 }
 
 function schedule() {
@@ -123,7 +150,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.Bt && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.Ut && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -153,32 +180,32 @@ function notifyHalted() {
 }
 
 class Queue {
-    He=null;
-    zt=[ [], [] ];
-    wt=[];
+    Fe=null;
+    Mt=[ [], [] ];
+    Qt=[];
     created=clock;
     addChild(e) {
-        this.wt.push(e);
-        e.He = this;
+        this.Qt.push(e);
+        e.Fe = this;
     }
     removeChild(e) {
-        const t = this.wt.indexOf(e);
+        const t = this.Qt.indexOf(e);
         if (t >= 0) {
-            this.wt.splice(t, 1);
-            e.He = null;
+            this.Qt.splice(t, 1);
+            e.Fe = null;
         }
     }
     notify(e, t, i, n) {
-        if (this.He) return this.He.notify(e, t, i, n);
+        if (this.Fe) return this.Fe.notify(e, t, i, n);
         return false;
     }
     run(e) {
-        if (this.zt[e - 1].length) {
-            const t = this.zt[e - 1];
-            this.zt[e - 1] = [];
+        if (this.Mt[e - 1].length) {
+            const t = this.Mt[e - 1];
+            this.Mt[e - 1] = [];
             runQueue(t, e);
         }
-        for (let t = 0; t < this.wt.length; t++) this.wt[t].run?.(e);
+        for (let t = 0; t < this.Qt.length; t++) this.Qt[t].run?.(e);
     }
     enqueue(e, t) {
         if (e) {
@@ -187,50 +214,48 @@ class Queue {
                 const i = findLane(currentOptimisticLane);
                 i.tn[e - 1].push(t);
             } else {
-                this.zt[e - 1].push(t);
+                this.Mt[e - 1].push(t);
             }
         }
         schedule();
     }
     stashQueues(e) {
-        e.zt[0].push(...this.zt[0]);
-        e.zt[1].push(...this.zt[1]);
-        this.zt = [ [], [] ];
-        for (let t = 0; t < this.wt.length; t++) {
-            let i = this.wt[t];
-            let n = e.wt[t];
+        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 = {
-                    zt: [ [], [] ],
-                    wt: []
+                    Mt: [ [], [] ],
+                    Qt: []
                 };
-                e.wt[t] = n;
+                e.Qt[t] = n;
             }
             i.stashQueues(n);
         }
     }
     restoreQueues(e) {
-        this.zt[0].push(...e.zt[0]);
-        this.zt[1].push(...e.zt[1]);
-        for (let t = 0; t < e.wt.length; t++) {
-            const i = e.wt[t];
-            let n = this.wt[t];
+        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];
             if (n) n.restoreQueues(i);
         }
     }
 }
 
 class GlobalQueue extends Queue {
-    Bt=false;
-    xt=null;
-    Yt=[];
-    Be=[];
-    N=[];
-    Lt=new Set;
+    Ut=false;
+    // The current transaction-shaped batch: a plain ambient batch while no
+    // transition is active, the active transition itself after initTransition.
+    N=createBatch();
     static Ce;
     static Oe;
     static ut;
-    static Kt=null;
+    static Vt=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).
@@ -256,15 +281,15 @@ class GlobalQueue extends Queue {
     // verdict.ts, and `pendingCheckActive`/`latestReadActive` only flip inside
     // isPending()/latest()).
     static _e=null;
-    static _=null;
+    static P=null;
     static me=null;
     static R=null;
     static Gt=null;
     static Pt=null;
-    static vt=null;
+    static kt=null;
     static tt=null;
     static nt=null;
-    static Zt=null;
+    static wt=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -273,22 +298,22 @@ class GlobalQueue extends Queue {
     // entry, or a non-null `currentOptimisticLane`, so `!` invocations are safe
     // once the gate holds.
     static bt=null;
-    static Ut=null;
-    static yt=null;
-    static Wt=null;
-    static jt=null;
-    static Mt=null;
-    static gt=null;
+    static En=null;
+    static Tn=null;
+    static In=null;
+    static Nn=null;
+    static On=null;
     static Dt=null;
+    static gt=null;
     static ht=null;
-    static kt=null;
+    static vt=null;
     static $e=null;
     static et=null;
     static Xe=null;
-    static Vt=null;
+    static mn=null;
     flush() {
-        if (this.Bt) return;
-        this.Bt = true;
+        if (this.Ut) return;
+        this.Ut = true;
         try {
             if (false) ;
             runHeap(dirtyQueue, GlobalQueue.Ce);
@@ -297,38 +322,55 @@ class GlobalQueue extends Queue {
                 if (!e) {
                     const e = activeTransition;
                     runHeap(zombieQueue, GlobalQueue.Ce);
-                    this.xt = null;
-                    this.Yt = [];
-                    this.Be = [];
-                    this.N = [];
-                    this.Lt = new Set;
+                    // Detach: the stashed transition keeps its batch; ambient work that
+                    // follows lands in a fresh one. If the batch is already a separate
+                    // ambient one — action done() restored activeTransition without
+                    // adopting the batch, and an ordinary write landed there before
+                    // the scheduled flush (#2916) — keep it: replacing it would strand
+                    // its queued pending nodes with held _pendingValues forever.
+                                        if (this.N === e) currentBatch = this.N = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
-                        GlobalQueue.Mt(EFFECT_RENDER);
-                        GlobalQueue.Mt(EFFECT_USER);
+                        GlobalQueue.On(EFFECT_RENDER);
+                        GlobalQueue.On(EFFECT_USER);
                     }
-                    this.stashQueues(e.Jt);
+                    this.stashQueues(e.Bt);
                     clock++;
-                    scheduled = dirtyQueue.EE >= dirtyQueue.Le;
-                    reassignPendingTransition(e.Yt);
+                    // 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.Le || this.N.yt.length > 0;
+                    reassignPendingTransition(e.yt);
                     activeTransition = null;
                     // The stash pass (committed-view rerun of plain optimistic signals)
                     // wraps finalizePureQueue in the engine; a non-empty _optimisticNodes
                     // means _optimisticWrite ran, which installed the hook.
-                                        if (!e.Te.length && !e.qt.size && e.Be.length) {
-                        GlobalQueue.yt(e);
+                                        if (!e.Te.length && !e.Lt.size && e.Be.length) {
+                        GlobalQueue.Tn(e);
                     } else {
                         finalizePureQueue(null, true);
                     }
                     return;
                 }
-                this.Yt !== activeTransition.Yt && this.Yt.push(...activeTransition.Yt);
-                this.restoreQueues(activeTransition.Jt);
-                transitions.delete(activeTransition);
                 const t = activeTransition;
+                const i = this.N;
+                i !== t && i.yt.push(...t.yt);
+                this.restoreQueues(t.Bt);
+                transitions.delete(t);
                 activeTransition = null;
-                reassignPendingTransition(this.Yt);
+                reassignPendingTransition(i.yt);
                 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.Be = i.Be;
+                    e._ = i._;
+                    e.dn = i.dn;
+                    currentBatch = this.N = e;
+                }
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
@@ -345,15 +387,15 @@ class GlobalQueue extends Queue {
             // Check if finalization added items to the heap (from optimistic reversion)
                         scheduled = dirtyQueue.EE >= dirtyQueue.Le;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.Mt(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue.On(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.Mt(EFFECT_USER);
+            activeLanes.size && GlobalQueue.On(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.Bt = false;
+            this.Ut = false;
         }
     }
     notify(e, t, i, n) {
@@ -363,8 +405,8 @@ class GlobalQueue extends Queue {
                 const t = n !== undefined ? n : e.k;
                 if (activeTransition && t) {
                     const i = t.source;
-                    let n = activeTransition.qt.get(i);
-                    if (!n) activeTransition.qt.set(i, n = new Set);
+                    let n = activeTransition.Lt.get(i);
+                    if (!n) activeTransition.Lt.set(i, n = new Set);
                     const s = n.size;
                     n.add(e);
                     if (n.size !== s) schedule();
@@ -379,21 +421,7 @@ class GlobalQueue extends Queue {
         if (e && e === activeTransition) return;
         if (!e && activeTransition && activeTransition.Ie === clock) return;
         if (!activeTransition) {
-            activeTransition = e ?? {
-                Ie: clock,
-                Yt: [],
-                qt: new Map,
-                Be: [],
-                N: [],
-                Lt: new Set,
-                Te: [],
-                Jt: {
-                    zt: [ [], [] ],
-                    wt: []
-                },
-                Ht: false,
-                Qt: new Set
-            };
+            activeTransition = e ?? createBatch();
         } else if (e) {
             const t = activeTransition;
             mergeTransitionState(e, t);
@@ -402,61 +430,37 @@ class GlobalQueue extends Queue {
         }
         transitions.add(activeTransition);
         activeTransition.Ie = clock;
-        if (this.xt !== null) {
-            this.xt.ve = activeTransition;
-            activeTransition.Yt.push(this.xt);
-            this.xt = null;
-        }
-        if (this.Yt !== activeTransition.Yt) {
-            for (let e = 0; e < this.Yt.length; e++) {
-                const t = this.Yt[e];
-                t.ve = activeTransition;
-                activeTransition.Yt.push(t);
+        const t = this.N;
+        if (t !== activeTransition) {
+            // Adopt the ambient batch into the transaction, then make the
+            // transaction the batch so later registrations land there directly.
+            // Pending and optimistic nodes are re-stamped as the transaction's;
+            // marks don't hijack the node's _transition — a mark on a plain signal
+            // must not entangle unrelated writes to it; the same rule holds one hop
+            // downstream: propagation never queues pended subscribers as pending
+            // nodes, see propagateAffectsMark, #2893.
+            for (let e = 0; e < t.yt.length; e++) {
+                const i = t.yt[e];
+                i.ve = activeTransition;
+                activeTransition.yt.push(i);
             }
-            this.Yt = activeTransition.Yt;
-        }
-        if (this.Be !== activeTransition.Be) {
-            for (let e = 0; e < this.Be.length; e++) {
-                const t = this.Be[e];
-                t.ve = activeTransition;
-                activeTransition.Be.push(t);
+            for (let e = 0; e < t.Be.length; e++) {
+                const i = t.Be[e];
+                i.ve = activeTransition;
+                activeTransition.Be.push(i);
             }
-            this.Be = activeTransition.Be;
-        }
-        if (this.N !== activeTransition.N) {
-            // Adopt ambient marks into the transaction (marks don't hijack the
-            // node's _transition — a mark on a plain signal must not entangle
-            // unrelated writes to it; the same rule holds one hop downstream:
-            // propagation never queues pended subscribers as pending nodes, see
-            // propagateAffectsMark, #2893). After adoption the queue aliases the
-            // transition's array, so later registrations land there directly.
-            activeTransition.N.push(...this.N);
-            this.N = activeTransition.N;
+            if (t._.length) activeTransition._.push(...t._);
+            for (const e of t.dn) activeTransition.dn.add(e);
+            currentBatch = this.N = activeTransition;
         }
         for (const e of activeLanes) {
             if (!e.ve) e.ve = activeTransition;
         }
-        if (this.Lt !== activeTransition.Lt) {
-            for (const e of this.Lt) activeTransition.Lt.add(e);
-            this.Lt = activeTransition.Lt;
-        }
     }
 }
 
 function queuePendingNode(e) {
-    if (activeTransition) {
-        globalQueue.Yt.push(e);
-        return;
-    }
-    if (globalQueue.xt === null && globalQueue.Yt.length === 0) {
-        globalQueue.xt = e;
-        return;
-    }
-    if (globalQueue.xt !== null) {
-        globalQueue.Yt.push(globalQueue.xt);
-        globalQueue.xt = null;
-    }
-    globalQueue.Yt.push(e);
+    currentBatch.yt.push(e);
 }
 
 // Sticky: flips true on the first refresh() ever (the only setter of
@@ -474,23 +478,23 @@ function insertSubs(e, t = false) {
     const i = e.Je || currentOptimisticLane;
     const n = e.Ye !== undefined;
     const s = reaskArmed;
-    for (let a = e.p; a !== null; a = a.de) {
+    for (let r = e.p; r !== null; r = r.de) {
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
-        if (s) a.Ee.u &= ~REACTIVE_REASK;
-        if (n && a.Ee.U & CONFIG_IN_SNAPSHOT_SCOPE) {
-            a.Ee.u |= REACTIVE_SNAPSHOT_STALE;
+        if (s) r.Ee.u &= ~REACTIVE_REASK;
+        if (n && r.Ee.U & CONFIG_IN_SNAPSHOT_SCOPE) {
+            r.Ee.u |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
         if (t && i) {
-            a.Ee.u |= REACTIVE_OPTIMISTIC_DIRTY;
-            assignOrMergeLane(a.Ee, i);
+            r.Ee.u |= REACTIVE_OPTIMISTIC_DIRTY;
+            assignOrMergeLane(r.Ee, i);
         } else if (t) {
-            a.Ee.u |= REACTIVE_OPTIMISTIC_DIRTY;
+            r.Ee.u |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        a.Ee.Je = undefined;
+                        r.Ee.Je = undefined;
         }
-        enqueueSub(a.Ee);
+        enqueueSub(r.Ee);
     }
 }
 
@@ -517,11 +521,7 @@ function commitPendingNode(e) {
 }
 
 function commitPendingNodes() {
-    if (globalQueue.xt !== null) {
-        commitPendingNode(globalQueue.xt);
-        globalQueue.xt = null;
-    }
-    const e = globalQueue.Yt;
+    const e = currentBatch.yt;
     for (let t = 0; t < e.length; t++) {
         commitPendingNode(e[t]);
     }
@@ -533,42 +533,42 @@ function finalizePureQueue(e = null, t = false) {
     // For completing transitions or no-transition, resolve pending and revert optimistic
     const i = !t;
     if (i) commitPendingNodes();
-    if (!t && globalQueue.wt.length) checkBoundaryChildren(globalQueue);
+    if (!t && globalQueue.Qt.length) checkBoundaryChildren(globalQueue);
     const n = dirtyQueue.EE >= dirtyQueue.Le;
     if (n) runHeap(dirtyQueue, GlobalQueue.Ce);
     if (i) {
         if (n) commitPendingNodes();
+        // The settling batch: the completing transaction's, or the ambient one.
+                const t = e ?? globalQueue.N;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                const t = e ? e.Be : globalQueue.Be;
-        if (t.length) GlobalQueue.Ut(t);
+                if (t.Be.length) GlobalQueue.En(t.Be);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
         // so they re-run with the now-committed values visible.
-                if (e && e.Qt.size) {
-            for (const t of e.Qt) {
+                if (e && e.un.size) {
+            for (const t of e.un) {
                 if (t.u & REACTIVE_DISPOSED) continue;
                 enqueueSub(t);
             }
-            e.Qt.clear();
+            e.un.clear();
         }
         // Declared motion ends with the transaction: settle (or plain flush end
         // for ambient marks) releases each registration's refcount. A non-empty
         // batch means registerAffectsMark ran, which installed the hook.
-                const i = e ? e.N : globalQueue.N;
-        if (i.length) GlobalQueue.h(i);
-        const s = e ? e.Lt : globalQueue.Lt;
+                if (t._.length) GlobalQueue.h(t._);
         // A non-empty set means trackOptimisticStore ran, which installed the
         // hook; the hook iterates, clears, and schedules (keeping the loop out of
-        // core lets esbuild shake it — rollup already folds the null guard).
-                if (s.size) GlobalQueue.Kt(s);
+        // 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.dn.size) GlobalQueue.Vt(t.dn, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.jt(e);
+                if (activeLanes.size) GlobalQueue.Nn(e);
     }
 }
 
 function checkBoundaryChildren(e) {
-    for (const t of e.wt) {
+    for (const t of e.Qt) {
         t.Se?.();
         checkBoundaryChildren(t);
     }
@@ -598,6 +598,13 @@ function reassignPendingTransition(e) {
 
 const globalQueue = new GlobalQueue;
 
+// Hot-path mirror of `globalQueue._batch`: `queuePendingNode` runs once per
+// staged write and `commitPendingNodes` once per flush, and the extra
+// property hop through `_batch` was a measured instruction-count regression
+// (CodSpeed update1to1, PR #2905). The field stays authoritative for
+// cross-module readers; every `_batch` assignment updates both.
+let currentBatch = globalQueue.N;
+
 function flush(e) {
     if (e) {
         syncDepth++;
@@ -613,7 +620,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.Bt) {
+    if (globalQueue.Ut) {
         return;
     }
     if (halted) return;
@@ -630,7 +637,7 @@ function runQueue(e, t) {
 
 function reporterBlocksSource(e, t) {
     if (e.u & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-    if (e.m === t || e.M?.has(t)) return true;
+    if (e.m?.has(t)) return true;
     for (let i = e.S; i; i = i.st) {
         let e = i.ot;
         while (e) {
@@ -642,10 +649,10 @@ function reporterBlocksSource(e, t) {
 }
 
 function transitionComplete(e) {
-    if (e.Ht) return true;
+    if (e.cn) return true;
     if (e.Te.length) return false;
     let t = true;
-    for (const [i, n] of e.qt) {
+    for (const [i, n] of e.Lt) {
         let s = false;
         for (const e of n) {
             if (reporterBlocksSource(e, i)) {
@@ -654,7 +661,7 @@ function transitionComplete(e) {
             }
             n.delete(e);
         }
-        if (!s) e.qt.delete(i); else if (i.i & STATUS_PENDING && i.k?.source === i) {
+        if (!s) e.Lt.delete(i); else if (i.i & STATUS_PENDING && i.k?.source === i) {
             t = false;
             break;
         }
@@ -662,13 +669,13 @@ function transitionComplete(e) {
     // Override blockage lives with the engine. Absent hook = "no optimistic
     // blockage", which is exact: only _optimisticWrite (engine) pushes to
     // _optimisticNodes, so without the engine the loop was vacuous anyway.
-        if (t && e.Be.length && GlobalQueue.Wt(e)) t = false;
-    t && (e.Ht = true);
+        if (t && e.Be.length && GlobalQueue.In(e)) t = false;
+    t && (e.cn = true);
     return t;
 }
 
 function currentTransition(e) {
-    while (e.Ht && typeof e.Ht === "object") e = e.Ht;
+    while (e.cn && typeof e.cn === "object") e = e.cn;
     return e;
 }