@solidjs/signals 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/prod/core/scheduler.js

@@ -19,14 +19,14 @@ const transitions = new Set;
 const dirtyQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Le: 0,
+    Fe: 0,
     EE: 0
 };
 
 const zombieQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Le: 0,
+    Fe: 0,
     EE: 0
 };
 
@@ -55,25 +55,25 @@ function registerTransientStoreNode(e) {
 }
 
 function canUseSimpleSyncFlush(e) {
-    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;
+    const t = e.m;
+    return transitions.size === 0 && activeLanes.size === 0 && e.vt.length === 0 && t.Ze.length === 0 && t.A.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
     if (transientStoreNodes.size === 0) return;
     for (const e of transientStoreNodes) {
-        if (e.p !== null) {
+        if (e.o !== null) {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e.ge !== NOT_PENDING) continue;
-        if (e.be !== undefined && e.be !== NOT_PENDING) continue;
+        if (e.Ne !== NOT_PENDING) continue;
+        if (e.Ee !== undefined && e.Ee !== 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.M) continue;
+                if (e.t) continue;
         transientStoreNodes.delete(e);
-        e.ct?.();
+        e.it?.();
     }
 }
 
@@ -100,47 +100,47 @@ function setProjectionWriteActive(e) {
  * land there directly — no per-field aliasing.
  */ function createBatch() {
     return {
-        Ie: clock,
-        yt: [],
-        Lt: new Map,
-        Be: [],
-        _: [],
-        dn: new Set,
-        Te: [],
-        Bt: {
-            Mt: [ [], [] ],
-            Qt: []
+        ce: clock,
+        Qt: [],
+        yt: new Map,
+        Ze: [],
+        A: [],
+        cn: new Set,
+        ie: [],
+        gt: {
+            bt: [ [], [] ],
+            vt: []
         },
-        cn: false,
-        un: new Set
+        fn: false,
+        ln: new Set
     };
 }
 
 function mergeTransitionState(e, t) {
-    t.cn = e;
-    e.Te.push(...t.Te);
-    for (const i of activeLanes) if (i.ve === t) i.ve = e;
-    if (t.Be.length) {
+    t.fn = e;
+    e.ie.push(...t.ie);
+    for (const i of activeLanes) if (i.Ue === t) i.Ue = 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.Be.push(...t.Be);
-        t.Be.length = 0;
+        e.Ze.push(...t.Ze);
+        t.Ze.length = 0;
     }
-    if (t._.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._.push(...t._);
-        t._.length = 0;
+        e.A.push(...t.A);
+        t.A.length = 0;
     }
-    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 i of t.cn) e.cn.add(i);
+    for (const [i, n] of t.yt) {
+        let t = e.yt.get(i);
+        if (!t) e.yt.set(i, t = new Set);
         for (const e of n) t.add(e);
     }
-    for (const i of t.un) e.un.add(i);
+    for (const i of t.ln) e.ln.add(i);
 }
 
 function schedule() {
@@ -150,7 +150,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.Ut && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.kt && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -180,116 +180,113 @@ function notifyHalted() {
 }
 
 class Queue {
-    Fe=null;
-    Mt=[ [], [] ];
-    Qt=[];
+    Ge=null;
+    bt=[ [], [] ];
+    vt=[];
     created=clock;
     addChild(e) {
-        this.Qt.push(e);
-        e.Fe = this;
+        this.vt.push(e);
+        e.Ge = this;
     }
     removeChild(e) {
-        const t = this.Qt.indexOf(e);
+        const t = this.vt.indexOf(e);
         if (t >= 0) {
-            this.Qt.splice(t, 1);
-            e.Fe = null;
+            this.vt.splice(t, 1);
+            e.Ge = null;
         }
     }
     notify(e, t, i, n) {
-        if (this.Fe) return this.Fe.notify(e, t, i, n);
+        if (this.Ge) return this.Ge.notify(e, t, i, n);
         return false;
     }
     run(e) {
-        if (this.Mt[e - 1].length) {
-            const t = this.Mt[e - 1];
-            this.Mt[e - 1] = [];
+        if (this.bt[e - 1].length) {
+            const t = this.bt[e - 1];
+            this.bt[e - 1] = [];
             runQueue(t, e);
         }
-        for (let t = 0; t < this.Qt.length; t++) this.Qt[t].run?.(e);
+        for (let t = 0; t < this.vt.length; t++) this.vt[t].run?.(e);
     }
     enqueue(e, t) {
         if (e) {
             // Route to lane's effect queue if we're in an optimistic recomputation
             if (currentOptimisticLane) {
                 const i = findLane(currentOptimisticLane);
-                i.tn[e - 1].push(t);
+                i.rn[e - 1].push(t);
             } else {
-                this.Mt[e - 1].push(t);
+                this.bt[e - 1].push(t);
             }
         }
         schedule();
     }
     stashQueues(e) {
-        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];
+        e.bt[0].push(...this.bt[0]);
+        e.bt[1].push(...this.bt[1]);
+        this.bt = [ [], [] ];
+        for (let t = 0; t < this.vt.length; t++) {
+            let i = this.vt[t];
+            let n = e.vt[t];
             if (!n) {
                 n = {
-                    Mt: [ [], [] ],
-                    Qt: []
+                    bt: [ [], [] ],
+                    vt: []
                 };
-                e.Qt[t] = n;
+                e.vt[t] = n;
             }
             i.stashQueues(n);
         }
     }
     restoreQueues(e) {
-        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];
+        this.bt[0].push(...e.bt[0]);
+        this.bt[1].push(...e.bt[1]);
+        for (let t = 0; t < e.vt.length; t++) {
+            const i = e.vt[t];
+            let n = this.vt[t];
             if (n) n.restoreQueues(i);
         }
     }
 }
 
 class GlobalQueue extends Queue {
-    Ut=false;
+    kt=false;
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
-    N=createBatch();
+    m=createBatch();
+    static pe;
     static Ce;
-    static Oe;
-    static ut;
-    static Vt=null;
+    static Je;
+    static Dt=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 T=null;
+    static p=null;
     // affects()-side hooks (wired by affects.ts, mirroring _update): the mark
-    // engine — count/register/release plus the post-commit re-application of
-    // marked reads — lives with the feature. Every call site is gated by state
-    // only that module creates, so `!` invocations are safe once the gate holds.
-    static j=null;
+    // 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 D=null;
-    static F=null;
-    static $=null;
-    static I=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static Ot=null;
-    static Rt=null;
+    static Tt=null;
+    static It=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 Ie=null;
+    static ae=null;
     static _e=null;
-    static P=null;
-    static me=null;
-    static R=null;
-    static Gt=null;
-    static Pt=null;
-    static kt=null;
-    static tt=null;
-    static nt=null;
-    static wt=null;
+    static un=null;
+    static St=null;
+    static dt=null;
+    static Rt=null;
+    static ze=null;
+    static k=null;
+    static Lt=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -297,109 +294,112 @@ 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 bt=null;
+    static Pt=null;
     static En=null;
     static Tn=null;
+    static dn=null;
     static In=null;
+    static Ct=null;
+    static At=null;
+    static Ot=null;
+    static We=null;
+    static Ke=null;
+    static Me=null;
     static Nn=null;
-    static On=null;
-    static Dt=null;
-    static gt=null;
-    static ht=null;
-    static vt=null;
-    static $e=null;
-    static et=null;
-    static Xe=null;
-    static mn=null;
     flush() {
-        if (this.Ut) return;
-        this.Ut = true;
+        if (this.kt) return;
+        this.kt = true;
         try {
             if (false) ;
-            runHeap(dirtyQueue, GlobalQueue.Ce);
+            runHeap(dirtyQueue, GlobalQueue.pe);
             if (activeTransition) {
                 const e = transitionComplete(activeTransition);
                 if (!e) {
                     const e = activeTransition;
-                    runHeap(zombieQueue, GlobalQueue.Ce);
+                    runHeap(zombieQueue, GlobalQueue.pe);
                     // Detach: the stashed transition keeps its batch; ambient work that
-                    // follows lands in a fresh one.
-                                        currentBatch = this.N = createBatch();
+                    // 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.m === e) currentBatch = this.m = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
-                        GlobalQueue.On(EFFECT_RENDER);
-                        GlobalQueue.On(EFFECT_USER);
+                        GlobalQueue.In(EFFECT_RENDER);
+                        GlobalQueue.In(EFFECT_USER);
                     }
-                    this.stashQueues(e.Bt);
+                    this.stashQueues(e.gt);
                     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.Fe || this.m.Qt.length > 0;
+                    reassignPendingTransition(e.Qt);
                     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.Lt.size && e.Be.length) {
-                        GlobalQueue.Tn(e);
-                    } else {
-                        finalizePureQueue(null, true);
-                    }
+                    finalizePureQueue(null, true);
                     return;
                 }
                 const t = activeTransition;
-                const i = this.N;
-                i !== t && i.yt.push(...t.yt);
-                this.restoreQueues(t.Bt);
+                const i = this.m;
+                i !== t && i.Qt.push(...t.Qt);
+                this.restoreQueues(t.gt);
                 transitions.delete(t);
                 activeTransition = null;
-                reassignPendingTransition(i.yt);
+                reassignPendingTransition(i.Qt);
                 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;
+                    e.Qt = i.Qt;
+                    e.Ze = i.Ze;
+                    e.A = i.A;
+                    e.cn = i.cn;
+                    currentBatch = this.m = e;
                 }
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
-                    if (dirtyQueue.EE >= dirtyQueue.Le) {
-                        runHeap(dirtyQueue, GlobalQueue.Ce);
+                    if (dirtyQueue.EE >= dirtyQueue.Fe) {
+                        runHeap(dirtyQueue, GlobalQueue.pe);
                         commitPendingNodes();
                     }
                 } else {
-                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.Ce);
+                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.pe);
                     finalizePureQueue();
                 }
             }
             clock++;
             // Check if finalization added items to the heap (from optimistic reversion)
-                        scheduled = dirtyQueue.EE >= dirtyQueue.Le;
+                        scheduled = dirtyQueue.EE >= dirtyQueue.Fe;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.On(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue.In(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.On(EFFECT_USER);
+            activeLanes.size && GlobalQueue.In(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.Ut = false;
+            this.kt = false;
         }
     }
     notify(e, t, i, n) {
         // Only track async if the boundary is propagating STATUS_PENDING (not caught by boundary)
         if (t & STATUS_PENDING) {
             if (i & STATUS_PENDING) {
-                const t = n !== undefined ? n : e.k;
+                const t = n !== undefined ? n : e._;
+                // A visibility-only mark notification (the affects() boundary
+                // 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?.l) return true;
                 if (activeTransition && t) {
                     const i = t.source;
-                    let n = activeTransition.Lt.get(i);
-                    if (!n) activeTransition.Lt.set(i, n = new Set);
+                    let n = activeTransition.yt.get(i);
+                    if (!n) activeTransition.yt.set(i, n = new Set);
                     const s = n.size;
                     n.add(e);
                     if (n.size !== s) schedule();
@@ -412,7 +412,7 @@ class GlobalQueue extends Queue {
     initTransition(e) {
         if (e) e = currentTransition(e);
         if (e && e === activeTransition) return;
-        if (!e && activeTransition && activeTransition.Ie === clock) return;
+        if (!e && activeTransition && activeTransition.ce === clock) return;
         if (!activeTransition) {
             activeTransition = e ?? createBatch();
         } else if (e) {
@@ -422,8 +422,8 @@ class GlobalQueue extends Queue {
             activeTransition = e;
         }
         transitions.add(activeTransition);
-        activeTransition.Ie = clock;
-        const t = this.N;
+        activeTransition.ce = clock;
+        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.
@@ -432,28 +432,28 @@ 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.ve = activeTransition;
-                activeTransition.yt.push(i);
+            for (let e = 0; e < t.Qt.length; e++) {
+                const i = t.Qt[e];
+                i.Ue = activeTransition;
+                activeTransition.Qt.push(i);
             }
-            for (let e = 0; e < t.Be.length; e++) {
-                const i = t.Be[e];
-                i.ve = activeTransition;
-                activeTransition.Be.push(i);
+            for (let e = 0; e < t.Ze.length; e++) {
+                const i = t.Ze[e];
+                i.Ue = activeTransition;
+                activeTransition.Ze.push(i);
             }
-            if (t._.length) activeTransition._.push(...t._);
-            for (const e of t.dn) activeTransition.dn.add(e);
-            currentBatch = this.N = activeTransition;
+            if (t.A.length) activeTransition.A.push(...t.A);
+            for (const e of t.cn) activeTransition.cn.add(e);
+            currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
-            if (!e.ve) e.ve = activeTransition;
+            if (!e.Ue) e.Ue = activeTransition;
         }
     }
 }
 
 function queuePendingNode(e) {
-    currentBatch.yt.push(e);
+    currentBatch.Qt.push(e);
 }
 
 // Sticky: flips true on the first refresh() ever (the only setter of
@@ -468,53 +468,53 @@ function armReaskClear() {
 function insertSubs(e, t = false) {
     // 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
-    const i = e.Je || currentOptimisticLane;
-    const n = e.Ye !== undefined;
+    const i = e.je || currentOptimisticLane;
+    const n = e.Ve !== undefined;
     const s = reaskArmed;
-    for (let r = e.p; r !== null; r = r.de) {
+    for (let r = e.o; r !== null; r = r.ue) {
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
-        if (s) r.Ee.u &= ~REACTIVE_REASK;
-        if (n && r.Ee.U & CONFIG_IN_SNAPSHOT_SCOPE) {
-            r.Ee.u |= REACTIVE_SNAPSHOT_STALE;
+        if (s) r.le.se &= ~REACTIVE_REASK;
+        if (n && r.le.T & CONFIG_IN_SNAPSHOT_SCOPE) {
+            r.le.se |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
         if (t && i) {
-            r.Ee.u |= REACTIVE_OPTIMISTIC_DIRTY;
-            assignOrMergeLane(r.Ee, i);
+            r.le.se |= REACTIVE_OPTIMISTIC_DIRTY;
+            assignOrMergeLane(r.le, i);
         } else if (t) {
-            r.Ee.u |= REACTIVE_OPTIMISTIC_DIRTY;
+            r.le.se |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        r.Ee.Je = undefined;
+                        r.le.je = undefined;
         }
-        enqueueSub(r.Ee);
+        enqueueSub(r.le);
     }
 }
 
 function commitPendingNode(e) {
     const t = e;
-    if (!t.xe) {
-        if (e.ge !== NOT_PENDING) {
-            e.Ue = e.ge;
-            e.ge = NOT_PENDING;
+    if (!t.ke) {
+        if (e.Ne !== NOT_PENDING) {
+            e.Re = e.Ne;
+            e.Ne = NOT_PENDING;
         }
-        if (e.ye || e.pe) GlobalQueue.R(e);
+        if (e.ge || e.he) GlobalQueue.un(e);
         return;
     }
-    if (e.ge !== NOT_PENDING) {
-        e.Ue = e.ge;
-        e.ge = NOT_PENDING;
+    if (e.Ne !== NOT_PENDING) {
+        e.Re = e.Ne;
+        e.Ne = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.De && e.De !== EFFECT_TRACKED) e.it = true;
+                if (e.Ae && e.Ae !== EFFECT_TRACKED) e.$e = true;
     }
-    t.u &= ~REACTIVE_MANUAL_WRITE;
-    if (!(t.i & STATUS_PENDING)) t.i &= ~STATUS_UNINITIALIZED;
-    if (t.Ze !== null || t.We !== null) GlobalQueue.Oe(t, false, true);
-    if (e.ye || e.pe) GlobalQueue.R(e);
+    t.se &= ~REACTIVE_MANUAL_WRITE;
+    if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
+    if (t.Le !== null || t.ye !== null) GlobalQueue.Ce(t, false, true);
+    if (e.ge || e.he) GlobalQueue.un(e);
 }
 
 function commitPendingNodes() {
-    const e = currentBatch.yt;
+    const e = currentBatch.Qt;
     for (let t = 0; t < e.length; t++) {
         commitPendingNode(e[t]);
     }
@@ -526,43 +526,49 @@ 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.Qt.length) checkBoundaryChildren(globalQueue);
-    const n = dirtyQueue.EE >= dirtyQueue.Le;
-    if (n) runHeap(dirtyQueue, GlobalQueue.Ce);
+    if (!t && globalQueue.vt.length) checkBoundaryChildren(globalQueue);
+    const n = dirtyQueue.EE >= dirtyQueue.Fe;
+    if (n) runHeap(dirtyQueue, GlobalQueue.pe);
     if (i) {
         if (n) commitPendingNodes();
         // The settling batch: the completing transaction's, or the ambient one.
-                const t = e ?? globalQueue.N;
+                const t = e ?? globalQueue.m;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.Be.length) GlobalQueue.En(t.Be);
+                if (t.Ze.length) GlobalQueue.En(t.Ze);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
         // so they re-run with the now-committed values visible.
-                if (e && e.un.size) {
-            for (const t of e.un) {
-                if (t.u & REACTIVE_DISPOSED) continue;
+                if (e && e.ln.size) {
+            for (const t of e.ln) {
+                if (t.se & REACTIVE_DISPOSED) continue;
                 enqueueSub(t);
             }
-            e.un.clear();
+            e.ln.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.
-                if (t._.length) GlobalQueue.h(t._);
+        // batch means registerAffectsMark ran, which installed the hook. Marks
+        // 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.A.length) {
+            GlobalQueue.G(t.A);
+            if (globalQueue.vt.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.dn.size) GlobalQueue.Vt(t.dn, e);
+                if (t.cn.size) GlobalQueue.Dt(t.cn, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.Nn(e);
+                if (activeLanes.size) GlobalQueue.dn(e);
     }
 }
 
 function checkBoundaryChildren(e) {
-    for (const t of e.Qt) {
-        t.Se?.();
+    for (const t of e.vt) {
+        t.ne?.();
         checkBoundaryChildren(t);
     }
 }
@@ -585,7 +591,7 @@ function checkBoundaryChildren(e) {
 
 function reassignPendingTransition(e) {
     for (let t = 0; t < e.length; t++) {
-        e[t].ve = activeTransition;
+        e[t].Ue = activeTransition;
     }
 }
 
@@ -596,7 +602,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.N;
+let currentBatch = globalQueue.m;
 
 function flush(e) {
     if (e) {
@@ -613,7 +619,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.Ut) {
+    if (globalQueue.kt) {
         return;
     }
     if (halted) return;
@@ -629,23 +635,23 @@ function runQueue(e, t) {
 }
 
 function reporterBlocksSource(e, t) {
-    if (e.u & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-    if (e.m?.has(t)) return true;
-    for (let i = e.S; i; i = i.st) {
-        let e = i.ot;
+    if (e.se & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+    if (e.oe?.has(t)) return true;
+    for (let i = e.Xe; i; i = i.et) {
+        let e = i.tt;
         while (e) {
-            if (e === t || e.rt === t) return true;
-            e = e.en;
+            if (e === t || e.nt === t) return true;
+            e = e.nn;
         }
     }
-    return !!(e.i & STATUS_PENDING && e.k instanceof NotReadyError && e.k.source === t);
+    return !!(e.S & STATUS_PENDING && e._ instanceof NotReadyError && e._.source === t);
 }
 
 function transitionComplete(e) {
-    if (e.cn) return true;
-    if (e.Te.length) return false;
+    if (e.fn) return true;
+    if (e.ie.length) return false;
     let t = true;
-    for (const [i, n] of e.Lt) {
+    for (const [i, n] of e.yt) {
         let s = false;
         for (const e of n) {
             if (reporterBlocksSource(e, i)) {
@@ -654,7 +660,7 @@ function transitionComplete(e) {
             }
             n.delete(e);
         }
-        if (!s) e.Lt.delete(i); else if (i.i & STATUS_PENDING && i.k?.source === i) {
+        if (!s) e.yt.delete(i); else if (i.S & STATUS_PENDING && i._?.source === i) {
             t = false;
             break;
         }
@@ -662,13 +668,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.In(e)) t = false;
-    t && (e.cn = true);
+        if (t && e.Ze.length && GlobalQueue.Tn(e)) t = false;
+    t && (e.fn = true);
     return t;
 }
 
 function currentTransition(e) {
-    while (e.cn && typeof e.cn === "object") e = e.cn;
+    while (e.fn && typeof e.fn === "object") e = e.fn;
     return e;
 }