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

package/dist/prod/core/scheduler.js

@@ -19,14 +19,14 @@ const transitions = new Set;
 const dirtyQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    He: 0,
+    Ve: 0,
     EE: 0
 };
 
 const zombieQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    He: 0,
+    Ve: 0,
     EE: 0
 };
 
@@ -65,7 +65,7 @@ function registerTransientStoreNode(e) {
 
 function canUseSimpleSyncFlush(e) {
     const t = e.m;
-    return transitions.size === 0 && activeLanes.size === 0 && e.vt.length === 0 && t.je.length === 0 && t.A.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
+    return transitions.size === 0 && activeLanes.size === 0 && e.vt.length === 0 && t.Me.length === 0 && t.A.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
@@ -76,7 +76,7 @@ function sweepTransientStoreNodes() {
             continue;
         }
         if (e.De !== NOT_PENDING) continue;
-        if (e.Ae !== undefined && e.Ae !== NOT_PENDING) continue;
+        if (e._e !== undefined && e._e !== 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).
@@ -109,10 +109,10 @@ function setProjectionWriteActive(e) {
  * land there directly — no per-field aliasing.
  */ function createBatch() {
     return {
-        Se: clock,
+        de: clock,
         Qt: [],
-        Ee: new Map,
-        je: [],
+        Ie: new Map,
+        Me: [],
         A: [],
         cn: new Set,
         ie: [],
@@ -128,13 +128,13 @@ function setProjectionWriteActive(e) {
 function mergeTransitionState(e, t) {
     t.fn = e;
     e.ie.push(...t.ie);
-    for (const i of activeLanes) if (i.Ie === t) i.Ie = e;
-    if (t.je.length) {
+    for (const i of activeLanes) if (i.Ne === t) i.Ne = e;
+    if (t.Me.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.je.push(...t.je);
-        t.je.length = 0;
+        e.Me.push(...t.Me);
+        t.Me.length = 0;
     }
     if (t.A.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
@@ -144,9 +144,9 @@ function mergeTransitionState(e, t) {
         t.A.length = 0;
     }
     for (const i of t.cn) e.cn.add(i);
-    for (const [i, n] of t.Ee) {
-        let t = e.Ee.get(i);
-        if (!t) e.Ee.set(i, t = new Set);
+    for (const [i, n] of t.Ie) {
+        let t = e.Ie.get(i);
+        if (!t) e.Ie.set(i, t = new Set);
         for (const e of n) t.add(e);
     }
     for (const i of t.ln) e.ln.add(i);
@@ -193,24 +193,24 @@ function notifyHalted() {
 let queueRunToken = 0;
 
 class Queue {
-    ve=null;
+    ke=null;
     bt=[ [], [] ];
     vt=[];
     kt=0;
     created=clock;
     addChild(e) {
         this.vt.push(e);
-        e.ve = this;
+        e.ke = this;
     }
     removeChild(e) {
         const t = this.vt.indexOf(e);
         if (t >= 0) {
             this.vt.splice(t, 1);
-            e.ve = null;
+            e.ke = null;
         }
     }
     notify(e, t, i, n) {
-        if (this.ve) return this.ve.notify(e, t, i, n);
+        if (this.ke) return this.ke.notify(e, t, i, n);
         return false;
     }
     run(e) {
@@ -288,7 +288,7 @@ class GlobalQueue extends Queue {
     m=createBatch();
     static Ce;
     static me;
-    static Xe;
+    static et;
     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
@@ -303,24 +303,24 @@ class GlobalQueue extends Queue {
     static h=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static dt=null;
     static It=null;
+    static St=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 _e=null;
-    static ce=null;
-    static Ge=null;
+    static Pe=null;
+    static Se=null;
+    static Oe=null;
     static un=null;
-    static St=null;
     static At=null;
-    static Pt=null;
-    static $e=null;
+    static Ct=null;
+    static ht=null;
+    static Be=null;
     static k=null;
-    static Gt=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).
@@ -328,17 +328,17 @@ 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 ht=null;
+    static Gt=null;
     static En=null;
     static Tn=null;
     static dn=null;
     static In=null;
-    static Ot=null;
-    static Ct=null;
     static Rt=null;
-    static Ze=null;
+    static Ot=null;
+    static Pt=null;
+    static je=null;
+    static $e=null;
     static ze=null;
-    static Ke=null;
     static Nn=null;
     flush() {
         if (this.gt) return;
@@ -376,7 +376,7 @@ class GlobalQueue extends Queue {
                     // 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.He || this.m.Qt.length > 0;
+                                        scheduled = dirtyQueue.EE >= dirtyQueue.Ve || this.m.Qt.length > 0;
                     reassignPendingTransition(e.Qt);
                     activeTransition = null;
                     finalizePureQueue(null, true);
@@ -396,7 +396,7 @@ class GlobalQueue extends Queue {
                     // there and must survive to the next flush.
                     const e = createBatch();
                     e.Qt = i.Qt;
-                    e.je = i.je;
+                    e.Me = i.Me;
                     e.A = i.A;
                     e.cn = i.cn;
                     currentBatch = this.m = e;
@@ -404,7 +404,7 @@ class GlobalQueue extends Queue {
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
-                    if (dirtyQueue.EE >= dirtyQueue.He) {
+                    if (dirtyQueue.EE >= dirtyQueue.Ve) {
                         runHeap(dirtyQueue, GlobalQueue.Ce);
                         commitPendingNodes();
                     }
@@ -415,7 +415,7 @@ class GlobalQueue extends Queue {
             }
             clock++;
             // Check if finalization added items to the heap (from optimistic reversion)
-                        scheduled = dirtyQueue.EE >= dirtyQueue.He;
+                        scheduled = dirtyQueue.EE >= dirtyQueue.Ve;
             // Run lane effects first (for ready lanes), then regular effects
                         activeLanes.size && GlobalQueue.In(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
@@ -440,8 +440,8 @@ class GlobalQueue extends Queue {
                                 if (t?.l) return true;
                 if (activeTransition && t) {
                     const i = t.source;
-                    let n = activeTransition.Ee.get(i);
-                    if (!n) activeTransition.Ee.set(i, n = new Set);
+                    let n = activeTransition.Ie.get(i);
+                    if (!n) activeTransition.Ie.set(i, n = new Set);
                     const s = n.size;
                     n.add(e);
                     if (n.size !== s) schedule();
@@ -454,7 +454,7 @@ class GlobalQueue extends Queue {
     initTransition(e) {
         if (e) e = currentTransition(e);
         if (e && e === activeTransition) return;
-        if (!e && activeTransition && activeTransition.Se === clock) return;
+        if (!e && activeTransition && activeTransition.de === clock) return;
         if (!activeTransition) {
             activeTransition = e ?? createBatch();
         } else if (e) {
@@ -464,7 +464,7 @@ class GlobalQueue extends Queue {
             activeTransition = e;
         }
         transitions.add(activeTransition);
-        activeTransition.Se = clock;
+        activeTransition.de = clock;
         const t = this.m;
         if (t !== activeTransition) {
             // Adopt the ambient batch into the transaction, then make the
@@ -476,13 +476,13 @@ class GlobalQueue extends Queue {
             // nodes, see propagateAffectsMark, #2893.
             for (let e = 0; e < t.Qt.length; e++) {
                 const i = t.Qt[e];
-                i.Ie = activeTransition;
+                i.Ne = activeTransition;
                 activeTransition.Qt.push(i);
             }
-            for (let e = 0; e < t.je.length; e++) {
-                const i = t.je[e];
-                i.Ie = activeTransition;
-                activeTransition.je.push(i);
+            for (let e = 0; e < t.Me.length; e++) {
+                const i = t.Me[e];
+                i.Ne = activeTransition;
+                activeTransition.Me.push(i);
             }
             if (t.A.length) activeTransition.A.push(...t.A);
             for (const e of t.cn) activeTransition.cn.add(e);
@@ -495,7 +495,7 @@ class GlobalQueue extends Queue {
             currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
-            if (!e.Ie) e.Ie = activeTransition;
+            if (!e.Ne) e.Ne = activeTransition;
         }
     }
 }
@@ -516,49 +516,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.Me || currentOptimisticLane;
-    const n = e.xe !== undefined;
+    const i = e.Ke || currentOptimisticLane;
+    const n = e.Le !== undefined;
     const s = reaskArmed;
-    for (let r = e.o; r !== null; r = r.ue) {
+    for (let r = e.o; r !== null; r = r.le) {
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
-        if (s) r.le.se &= ~REACTIVE_REASK;
-        if (n && r.le.T & CONFIG_IN_SNAPSHOT_SCOPE) {
-            r.le.se |= REACTIVE_SNAPSHOT_STALE;
+        if (s) r.fe.se &= ~REACTIVE_REASK;
+        if (n && r.fe.T & CONFIG_IN_SNAPSHOT_SCOPE) {
+            r.fe.se |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
         if (t && i) {
-            r.le.se |= REACTIVE_OPTIMISTIC_DIRTY;
-            assignOrMergeLane(r.le, i);
+            r.fe.se |= REACTIVE_OPTIMISTIC_DIRTY;
+            assignOrMergeLane(r.fe, i);
         } else if (t) {
-            r.le.se |= REACTIVE_OPTIMISTIC_DIRTY;
+            r.fe.se |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        r.le.Me = undefined;
+                        r.fe.Ke = undefined;
         }
-        enqueueSub(r.le);
+        enqueueSub(r.fe);
     }
 }
 
 function commitPendingNode(e) {
     const t = e;
-    if (!t.ae) {
+    if (!t.ce) {
         if (e.De !== NOT_PENDING) {
-            e.be = e.De;
+            e.Ue = e.De;
             e.De = NOT_PENDING;
         }
-        if (e.Re || e.pe) GlobalQueue.un(e);
+        if (e.ge || e.pe) GlobalQueue.un(e);
         return;
     }
     if (e.De !== NOT_PENDING) {
-        e.be = e.De;
+        e.Ue = e.De;
         e.De = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.Pe && e.Pe !== EFFECT_TRACKED) e.Be = true;
+                if (e.Re && e.Re !== EFFECT_TRACKED) e.Je = true;
     }
+    // The committed hold is the first observable answer for a loading-window
+    // node — the window closes here, not at compute time (#2990). Unconditional
+    // store to an always-present computed slot.
+        t.Ee = false;
     t.se &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
-    if (t.Qe !== null || t.ye !== null) GlobalQueue.me(t, false, true);
-    if (e.Re || e.pe) GlobalQueue.un(e);
+    if (t.We !== null || t.Qe !== null) GlobalQueue.me(t, false, true);
+    if (e.ge || e.pe) GlobalQueue.un(e);
 }
 
 function commitPendingNodes() {
@@ -575,7 +579,7 @@ function finalizePureQueue(e = null, t = false) {
     const i = !t;
     if (i) commitPendingNodes();
     if (!t && globalQueue.vt.length) checkBoundaryChildren(globalQueue);
-    const n = dirtyQueue.EE >= dirtyQueue.He;
+    const n = dirtyQueue.EE >= dirtyQueue.Ve;
     if (n) runHeap(dirtyQueue, GlobalQueue.Ce);
     if (i) {
         if (n) commitPendingNodes();
@@ -583,7 +587,7 @@ function finalizePureQueue(e = null, t = false) {
                 const t = e ?? globalQueue.m;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.je.length) GlobalQueue.En(t.je);
+                if (t.Me.length) GlobalQueue.En(t.Me);
         // 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
@@ -645,7 +649,7 @@ function checkBoundaryChildren(e) {
 
 function reassignPendingTransition(e) {
     for (let t = 0; t < e.length; t++) {
-        e[t].Ie = activeTransition;
+        e[t].Ne = activeTransition;
     }
 }
 
@@ -691,10 +695,10 @@ function runQueue(e, t) {
 function reporterBlocksSource(e, t) {
     if (e.se & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
     if (e.oe?.has(t)) return true;
-    for (let i = e.et; i; i = i.tt) {
-        let e = i.nt;
+    for (let i = e.tt; i; i = i.nt) {
+        let e = i.it;
         while (e) {
-            if (e === t || e.it === t) return true;
+            if (e === t || e.lt === t) return true;
             e = e.nn;
         }
     }
@@ -705,7 +709,7 @@ function transitionComplete(e) {
     if (e.fn) return true;
     if (e.ie.length) return false;
     let t = true;
-    for (const [i, n] of e.Ee) {
+    for (const [i, n] of e.Ie) {
         let s = false;
         for (const e of n) {
             if (reporterBlocksSource(e, i)) {
@@ -714,7 +718,7 @@ function transitionComplete(e) {
             }
             n.delete(e);
         }
-        if (!s) e.Ee.delete(i); else if (i.S & STATUS_PENDING && i._?.source === i) {
+        if (!s) e.Ie.delete(i); else if (i.S & STATUS_PENDING && i._?.source === i) {
             t = false;
             break;
         }

package/dist/prod/core/verdict.js

@@ -32,21 +32,21 @@ let pendingProbe = null;
  * Get or create the pending signal for a node (lazy).
  * Used by isPending() to track pending state reactively.
  */ function getPendingSignal(e) {
-    if (!e.Re) {
+    if (!e.ge) {
         // Start false, write true if pending - ensures reversion returns to false
-        e.Re = optimisticSignal(false, {
+        e.ge = optimisticSignal(false, {
             ownedWrite: true
         });
-        e.Re.nn = e;
-        if (computePendingState(e)) setSignal(e.Re, true);
+        e.ge.nn = e;
+        if (computePendingState(e)) setSignal(e.ge, true);
     }
-    return e.Re;
+    return e.ge;
 }
 
 function collectPendingSources(e) {
     if (!pendingProbe) return;
     pendingProbe.sources.add(e);
-    const t = e.it || e;
+    const t = e.lt || e;
     if (t !== e) pendingProbe.sources.add(t);
 }
 
@@ -79,17 +79,17 @@ function collectPendingSources(e) {
         if (e.S & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
-    const n = e.it;
+    const n = e.lt;
     if (n && markWalk(n, t)) return true;
     // Mid-recompute (the clearStatus companion poke runs before
     // trimStaleDeps), only the validated prefix [_deps.._depsTail] is this
     // pass's dependency set — walking past it would read dropped deps and
     // latch a stale verdict on the companion.
         const i = e;
-    const r = i.se & REACTIVE_RECOMPUTING_DEPS ? i.We : undefined;
+    const r = i.se & REACTIVE_RECOMPUTING_DEPS ? i.Ye : undefined;
     if (r !== null) {
-        for (let e = i.et ?? null; e !== null; e = e.tt) {
-            if (!e.Oe && markWalk(e.nt, t)) return true;
+        for (let e = i.tt ?? null; e !== null; e = e.nt) {
+            if (!e.Ge && markWalk(e.it, t)) return true;
             if (e === r) break;
         }
     }
@@ -102,12 +102,19 @@ function collectPendingSources(e) {
 
 function quietPending(e) {
     if (e.oe) {
-        for (const t of e.oe) if (!t.Ue) return false;
+        for (const t of e.oe) if (!t.he) return false;
         return true;
     }
-    return e.Ue;
+    return e.he;
 }
 
+// NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
+// on purpose: commit #0 answers the question by declaration, so the window
+// reads NOT pending — first-load affordances live in the value channel
+// (null / skeleton provenance the author encoded), and isPending stays what
+// it always was: refetch truth for an answered question. This keeps the
+// verdict fully correlated with transition-class machinery and keeps server
+// (always false) and client hydration trivially consistent.
 function newQuestionInFlight(e) {
     return !!(e.S & STATUS_PENDING) && !(e.S & STATUS_UNINITIALIZED) && !quietPending(e);
 }
@@ -119,37 +126,41 @@ function computePendingState(e) {
     // reaches its owner (and a store leaf its firewall) through its own deps,
     // so the one walk covers direct marks, derivation, and companion chains.
         if (markCovered(e)) return true;
-    const n = e.it;
+    const n = e.lt;
     if (e.nn) {
         const t = e.nn;
-        const n = t.it || t;
+        const n = t.lt || t;
         return newQuestionInFlight(n);
     }
     if (n && e.De !== NOT_PENDING && !hasActiveOverride(e)) {
         return !!(n.se & REACTIVE_MANUAL_WRITE) || !n.Te && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
     }
-    if (e.De !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.he || !e.he(e.De, unwrapOverride(e.Ae));
+    // `!comp._loading`: a hold created while the loading window is still open is
+    // the window's own landing in flight to its commit — verdict-quiet like the
+    // rest of the window (the UNINITIALIZED check suppresses exactly this frame
+    // for windowless first loads; born-committed nodes need their own gate, #2990).
+        if (e.De !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ee) {
+        if (hasActiveOverride(e)) return !e.be || !e.be(e.De, unwrapOverride(e._e));
         return true;
     }
     return newQuestionInFlight(t);
 }
 
 function syncCompanions(e, t) {
-    if (e.Re) updatePendingSignal(e);
+    if (e.ge) updatePendingSignal(e);
     if (e.pe) setSignal(e.pe, t);
 }
 
 function updatePendingSignal(e) {
-    if (e.Re) {
-        setSignal(e.Re, computePendingState(e));
+    if (e.ge) {
+        setSignal(e.ge, computePendingState(e));
     }
     if (e.pe) updatePendingSignal(e.pe);
 }
 
 function updateChildCompanions(e) {
-    for (let t = e.u; t !== null; t = t.fe) {
-        if (t.Re || t.pe) updatePendingSignal(t);
+    for (let t = e.u; t !== null; t = t.ae) {
+        if (t.ge || t.pe) updatePendingSignal(t);
     }
 }
 
@@ -167,9 +178,9 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (i.has(e)) return;
         i.add(e);
-        if (e.Re || e.pe) n(e);
-        for (let t = e.o; t !== null; t = t.ue) visit(t.le);
-        for (let t = e.u ?? null; t !== null; t = t.fe) {
+        if (e.ge || e.pe) n(e);
+        for (let t = e.o; t !== null; t = t.le) visit(t.fe);
+        for (let t = e.u ?? null; t !== null; t = t.ae) {
             visit(t);
         }
     };
@@ -177,20 +188,20 @@ function updateChildCompanions(e) {
 }
 
 function snapCompanionsToState(e) {
-    const t = e.Re;
-    if (t && (t.Ae === undefined || t.Ae === NOT_PENDING)) {
+    const t = e.ge;
+    if (t && (t._e === undefined || t._e === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.be !== n || t.De !== NOT_PENDING) {
-            t.be = n;
+        if (t.Ue !== n || t.De !== NOT_PENDING) {
+            t.Ue = n;
             t.De = NOT_PENDING;
-            t.Se = clock;
+            t.de = clock;
             insertSubs(t);
             schedule();
         }
     }
     const n = e.pe;
     if (n && !(n.se & REACTIVE_DISPOSED)) {
-        if ((n.Ae === undefined || n.Ae === NOT_PENDING) && n.De === NOT_PENDING && !Object.is(n.be, e.be) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n._e === undefined || n._e === NOT_PENDING) && n.De === NOT_PENDING && !Object.is(n.Ue, e.Ue) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
             n.se |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
@@ -223,7 +234,7 @@ function getLatestValueComputed(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e.Ae !== undefined && e.Ae !== NOT_PENDING ? unwrapOverride(e.Ae) : e.be;
+    const i = e._e !== undefined && e._e !== NOT_PENDING ? unwrapOverride(e._e) : e.Ue;
     let r;
     try {
         // An untracked latest() read has no reading context, so read() never
@@ -232,7 +243,7 @@ function getLatestValueComputed(e) {
         // until the flush (#2922). Mirror the tracked-read pull here: mark the
         // queued staleness through the graph, then bring the shadow up to date.
         const e = queueFor(t);
-        if (t.Ve >= e.He && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.xe >= e.Ve && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             prepareComputed(t, true);
         }
@@ -244,10 +255,10 @@ function getLatestValueComputed(e) {
         setLatestReadActive(n);
     }
     if (t.S & STATUS_PENDING) return i;
-    if (stale && currentOptimisticLane && t.Me) {
-        const e = findLane(t.Me);
+    if (stale && currentOptimisticLane && t.Ke) {
+        const e = findLane(t.Ke);
         const n = findLane(currentOptimisticLane);
-        if (e !== n && e.Ne.size > 0) {
+        if (e !== n && e.Ae.size > 0) {
             return i;
         }
     }
@@ -255,13 +266,13 @@ function getLatestValueComputed(e) {
     // speculative value in _pendingValue; a contextless read() only surfaces
     // _value. Overrides stay authoritative (A17), and stale readers keep the
     // other transition's committed view, matching read()'s own selection.
-        if (t.De !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ie && activeTransition !== t.Ie)) return t.De;
+        if (t.De !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ne && activeTransition !== t.Ne)) return t.De;
     return r;
 }
 
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, i) {
     setPendingCheckActive(false);
-    if (typeof e.ae === "function") prepareComputed(e, true);
+    if (typeof e.ce === "function") prepareComputed(e, true);
     const r = n.S;
     if (t && r & STATUS_PENDING && r & STATUS_UNINITIALIZED) {
         if (tracking && e !== t) link(e, t);
@@ -279,9 +290,9 @@ function recordFreshRead(e, t) {
 
 function applyReask(e, t) {
     const n = !!(e.S & STATUS_PENDING);
-    const i = t && !(n && !e.Ue);
-    const r = n && e.Ue !== i;
-    e.Ue = i;
+    const i = t && !(n && !e.he);
+    const r = n && e.he !== i;
+    e.he = i;
     return r;
 }
 
@@ -335,24 +346,24 @@ function isPending(e) {
 // Hook installation (same late-binding pattern as GlobalQueue._update /
 // _propagateAffects): core call sites fire these behind the same guards the
 // direct calls used, so behavior is identical once this module loads.
-GlobalQueue._e = syncCompanions;
+GlobalQueue.Pe = syncCompanions;
 
-GlobalQueue.ce = updatePendingSignal;
+GlobalQueue.Se = updatePendingSignal;
 
-GlobalQueue.Ge = updateChildCompanions;
+GlobalQueue.Oe = updateChildCompanions;
 
 GlobalQueue.un = snapCompanionsToState;
 
-GlobalQueue.St = latestRead;
+GlobalQueue.At = latestRead;
 
-GlobalQueue.At = pendingCheckRead;
+GlobalQueue.Ct = pendingCheckRead;
 
-GlobalQueue.Pt = recordFreshRead;
+GlobalQueue.ht = recordFreshRead;
 
-GlobalQueue.$e = applyReask;
+GlobalQueue.Be = applyReask;
 
 GlobalQueue.k = repollDownstreamVerdicts;
 
-GlobalQueue.Gt = witnessAffects;
+GlobalQueue.Lt = witnessAffects;
 
 export { isPending, latest };