@solidjs/signals 2.0.0-beta.29 → 2.0.0-beta.31

package/dist/node.cjs

@@ -350,6 +350,15 @@ const zombieQueue = {
     C: 0
 };
 
+/** runHeap callback that discards a queued zombie recompute instead of running
+ * it: unlink pure recompute entries; strip just the recompute bit from dirtied
+ * height-adjust entries so their height work still happens. */ function cancelZombieRecompute(e) {
+    if (e.D & REACTIVE_IN_HEAP_HEIGHT) e.D &= -12; else {
+        deleteFromHeap(e, zombieQueue);
+        e.D &= -4;
+    }
+}
+
 let clock = 0;
 
 let activeTransition = null;
@@ -375,25 +384,25 @@ function registerTransientStoreNode(e) {
 }
 
 function canUseSimpleSyncFlush(e) {
-    const t = e.D;
-    return transitions.size === 0 && activeLanes.size === 0 && e.m.length === 0 && t.v.length === 0 && t.L.length === 0 && t.G.size === 0 && transientStoreNodes.size === 0;
+    const t = e.m;
+    return transitions.size === 0 && activeLanes.size === 0 && e.v.length === 0 && t.L.length === 0 && t.G.length === 0 && t.V.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
     if (transientStoreNodes.size === 0) return;
     for (const e of transientStoreNodes) {
-        if (e.V !== null) {
+        if (e.U !== null) {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e.U !== NOT_PENDING) continue;
+        if (e.k !== NOT_PENDING) continue;
         if (e.A !== undefined && e.A !== 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.k) continue;
+                if (e.W) continue;
         transientStoreNodes.delete(e);
-        e.W?.();
+        e.F?.();
     }
 }
 
@@ -420,47 +429,47 @@ function setProjectionWriteActive(e) {
  * land there directly — no per-field aliasing.
  */ function createBatch() {
     return {
-        F: clock,
-        H: [],
-        M: new Map,
-        v: [],
+        H: clock,
+        M: [],
+        $: new Map,
         L: [],
-        G: new Set,
-        $: [],
-        j: {
-            K: [ [], [] ],
-            m: []
+        G: [],
+        V: new Set,
+        j: [],
+        K: {
+            Y: [ [], [] ],
+            v: []
         },
         I: false,
-        Y: new Set
+        q: new Set
     };
 }
 
 function mergeTransitionState(e, t) {
     t.I = e;
-    e.$.push(...t.$);
+    e.j.push(...t.j);
     for (const n of activeLanes) if (n.T === t) n.T = e;
-    if (t.v.length) {
+    if (t.L.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.v.push(...t.v);
-        t.v.length = 0;
+        e.L.push(...t.L);
+        t.L.length = 0;
     }
-    if (t.L.length) {
+    if (t.G.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.L.push(...t.L);
-        t.L.length = 0;
+        e.G.push(...t.G);
+        t.G.length = 0;
     }
-    for (const n of t.G) e.G.add(n);
-    for (const [n, r] of t.M) {
-        let t = e.M.get(n);
-        if (!t) e.M.set(n, t = new Set);
+    for (const n of t.V) e.V.add(n);
+    for (const [n, r] of t.$) {
+        let t = e.$.get(n);
+        if (!t) e.$.set(n, t = new Set);
         for (const e of r) t.add(e);
     }
-    for (const n of t.Y) e.Y.add(n);
+    for (const n of t.q) e.q.add(n);
 }
 
 function schedule() {
@@ -470,7 +479,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.q && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.B && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -504,30 +513,30 @@ function notifyHalted() {
 let queueRunToken = 0;
 
 class Queue {
-    B=null;
-    K=[ [], [] ];
-    m=[];
-    Z=0;
+    Z=null;
+    Y=[ [], [] ];
+    v=[];
+    X=0;
     created=clock;
     addChild(e) {
-        this.m.push(e);
-        e.B = this;
+        this.v.push(e);
+        e.Z = this;
     }
     removeChild(e) {
-        const t = this.m.indexOf(e);
+        const t = this.v.indexOf(e);
         if (t >= 0) {
-            this.m.splice(t, 1);
-            e.B = null;
+            this.v.splice(t, 1);
+            e.Z = null;
         }
     }
     notify(e, t, n, r) {
-        if (this.B) return this.B.notify(e, t, n, r);
+        if (this.Z) return this.Z.notify(e, t, n, r);
         return false;
     }
     run(e) {
-        if (this.K[e - 1].length) {
-            const t = this.K[e - 1];
-            this.K[e - 1] = [];
+        if (this.Y[e - 1].length) {
+            const t = this.Y[e - 1];
+            this.Y[e - 1] = [];
             runQueue$1(t, e);
         }
         // Effects run here can dispose owners, and disposal removes queues from
@@ -537,12 +546,12 @@ class Queue {
         // can be recovered by rescanning from the front and every child still runs
         // exactly once. Children appended mid-pass carry a stale stamp and run,
         // matching the previous live-array behaviour.
-                const t = this.m;
+                const t = this.v;
         const n = ++queueRunToken;
         for (let r = 0; r < t.length; ) {
             const i = t[r];
-            if (i.Z !== n) {
-                i.Z = n;
+            if (i.X !== n) {
+                i.X = n;
                 i.run?.(e);
                 if (t[r] !== i) {
                     r = 0;
@@ -559,70 +568,69 @@ class Queue {
                 const n = findLane(currentOptimisticLane);
                 n.l[e - 1].push(t);
             } else {
-                this.K[e - 1].push(t);
+                this.Y[e - 1].push(t);
             }
         }
         schedule();
     }
     stashQueues(e) {
-        e.K[0].push(...this.K[0]);
-        e.K[1].push(...this.K[1]);
-        this.K = [ [], [] ];
-        for (let t = 0; t < this.m.length; t++) {
-            let n = this.m[t];
-            let r = e.m[t];
+        e.Y[0].push(...this.Y[0]);
+        e.Y[1].push(...this.Y[1]);
+        this.Y = [ [], [] ];
+        for (let t = 0; t < this.v.length; t++) {
+            let n = this.v[t];
+            let r = e.v[t];
             if (!r) {
                 r = {
-                    K: [ [], [] ],
-                    m: []
+                    Y: [ [], [] ],
+                    v: []
                 };
-                e.m[t] = r;
+                e.v[t] = r;
             }
             n.stashQueues(r);
         }
     }
     restoreQueues(e) {
-        this.K[0].push(...e.K[0]);
-        this.K[1].push(...e.K[1]);
-        for (let t = 0; t < e.m.length; t++) {
-            const n = e.m[t];
-            let r = this.m[t];
+        this.Y[0].push(...e.Y[0]);
+        this.Y[1].push(...e.Y[1]);
+        for (let t = 0; t < e.v.length; t++) {
+            const n = e.v[t];
+            let r = this.v[t];
             if (r) r.restoreQueues(n);
         }
     }
 }
 
 class GlobalQueue extends Queue {
-    q=false;
+    B=false;
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
-    D=createBatch();
-    static X;
+    m=createBatch();
     static J;
     static ee;
-    static te=null;
+    static te;
+    static ne=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 ne=null;
+    static re=null;
     // affects()-side hooks (wired by affects.ts, mirroring _update): the mark
     // engine — count/register/release — lives with the feature. Every call site
     // is gated by state only that module creates, so `!` invocations are safe
     // once the gate holds.
-    static re=null;
     static ie=null;
     static oe=null;
+    static se=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static se=null;
     static ue=null;
+    static le=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 le=null;
     static ae=null;
     static ce=null;
     static fe=null;
@@ -632,6 +640,7 @@ class GlobalQueue extends Queue {
     static Te=null;
     static Oe=null;
     static _e=null;
+    static Re=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -639,7 +648,6 @@ 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 Re=null;
     static pe=null;
     static Ie=null;
     static Ae=null;
@@ -651,68 +659,77 @@ class GlobalQueue extends Queue {
     static ge=null;
     static be=null;
     static De=null;
+    static we=null;
     flush() {
-        if (this.q) return;
-        this.q = true;
+        if (this.B) return;
+        this.B = true;
         try {
             if (false) ;
-            runHeap(dirtyQueue, GlobalQueue.X);
+            runHeap(dirtyQueue, GlobalQueue.J);
             if (activeTransition) {
                 const e = transitionComplete(activeTransition);
                 if (!e) {
                     const e = activeTransition;
-                    runHeap(zombieQueue, GlobalQueue.X);
+                    // When the parking batch IS the transition, all of its writes commit
+                    // only with it — every zombie recompute they queued would run against
+                    // a world the zombie never displays (zombies render mainline until
+                    // commit), so cancel them instead of running them. Only an ambient
+                    // batch's mainline writes (the #2916 shape below) legitimately reach
+                    // 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.J);
                     // 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.D === e) currentBatch = this.D = createBatch();
+                                        if (this.m === e) currentBatch = this.m = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
-                        GlobalQueue.he(EFFECT_RENDER);
-                        GlobalQueue.he(EFFECT_USER);
+                        GlobalQueue.Ne(EFFECT_RENDER);
+                        GlobalQueue.Ne(EFFECT_USER);
                     }
-                    this.stashQueues(e.j);
+                    this.stashQueues(e.K);
                     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.C >= dirtyQueue.P || this.D.H.length > 0;
-                    reassignPendingTransition(e.H);
+                                        scheduled = dirtyQueue.C >= dirtyQueue.P || this.m.M.length > 0;
+                    reassignPendingTransition(e.M);
                     activeTransition = null;
                     finalizePureQueue(null, true);
                     return;
                 }
                 const t = activeTransition;
-                const n = this.D;
-                n !== t && n.H.push(...t.H);
-                this.restoreQueues(t.j);
+                const n = this.m;
+                n !== t && n.M.push(...t.M);
+                this.restoreQueues(t.K);
                 transitions.delete(t);
                 activeTransition = null;
-                reassignPendingTransition(n.H);
+                reassignPendingTransition(n.M);
                 finalizePureQueue(t);
                 if (n === 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.H = n.H;
-                    e.v = n.v;
+                    e.M = n.M;
                     e.L = n.L;
                     e.G = n.G;
-                    currentBatch = this.D = e;
+                    e.V = n.V;
+                    currentBatch = this.m = e;
                 }
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
                     if (dirtyQueue.C >= dirtyQueue.P) {
-                        runHeap(dirtyQueue, GlobalQueue.X);
+                        runHeap(dirtyQueue, GlobalQueue.J);
                         commitPendingNodes();
                     }
                 } else {
-                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.X);
+                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.J);
                     finalizePureQueue();
                 }
             }
@@ -720,31 +737,31 @@ class GlobalQueue extends Queue {
             // Check if finalization added items to the heap (from optimistic reversion)
                         scheduled = dirtyQueue.C >= dirtyQueue.P;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.he(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue.Ne(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.he(EFFECT_USER);
+            activeLanes.size && GlobalQueue.Ne(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.q = false;
+            this.B = false;
         }
     }
     notify(e, t, n, r) {
         // Only track async if the boundary is propagating STATUS_PENDING (not caught by boundary)
         if (t & STATUS_PENDING) {
             if (n & STATUS_PENDING) {
-                const t = r !== undefined ? r : e.we;
+                const t = r !== undefined ? r : e.me;
                 // 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?.me) return true;
+                                if (t?.ve) return true;
                 if (activeTransition && t) {
                     const n = t.source;
-                    let r = activeTransition.M.get(n);
-                    if (!r) activeTransition.M.set(n, r = new Set);
+                    let r = activeTransition.$.get(n);
+                    if (!r) activeTransition.$.set(n, r = new Set);
                     const i = r.size;
                     r.add(e);
                     if (r.size !== i) schedule();
@@ -757,7 +774,7 @@ class GlobalQueue extends Queue {
     initTransition(e) {
         if (e) e = currentTransition(e);
         if (e && e === activeTransition) return;
-        if (!e && activeTransition && activeTransition.F === clock) return;
+        if (!e && activeTransition && activeTransition.H === clock) return;
         if (!activeTransition) {
             activeTransition = e ?? createBatch();
         } else if (e) {
@@ -767,8 +784,8 @@ class GlobalQueue extends Queue {
             activeTransition = e;
         }
         transitions.add(activeTransition);
-        activeTransition.F = clock;
-        const t = this.D;
+        activeTransition.H = 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.
@@ -777,19 +794,25 @@ 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.H.length; e++) {
-                const n = t.H[e];
+            for (let e = 0; e < t.M.length; e++) {
+                const n = t.M[e];
                 n.T = activeTransition;
-                activeTransition.H.push(n);
+                activeTransition.M.push(n);
             }
-            for (let e = 0; e < t.v.length; e++) {
-                const n = t.v[e];
+            for (let e = 0; e < t.L.length; e++) {
+                const n = t.L[e];
                 n.T = activeTransition;
-                activeTransition.v.push(n);
+                activeTransition.L.push(n);
             }
-            if (t.L.length) activeTransition.L.push(...t.L);
-            for (const e of t.G) activeTransition.G.add(e);
-            currentBatch = this.D = activeTransition;
+            if (t.G.length) activeTransition.G.push(...t.G);
+            for (const e of t.V) activeTransition.V.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.q.size) {
+                for (const e of t.q) activeTransition.q.add(e);
+                t.q.clear();
+            }
+            currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
             if (!e.T) e.T = activeTransition;
@@ -798,7 +821,7 @@ class GlobalQueue extends Queue {
 }
 
 function queuePendingNode(e) {
-    currentBatch.H.push(e);
+    currentBatch.M.push(e);
 }
 
 // Sticky: flips true on the first refresh() ever (the only setter of
@@ -814,21 +837,21 @@ 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 n = e.i || currentOptimisticLane;
-    const r = e.ve !== undefined;
+    const r = e.Le !== undefined;
     const i = reaskArmed;
-    for (let o = e.V; o !== null; o = o.Le) {
+    for (let o = e.U; o !== null; o = o.Ge) {
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
-        if (i) o.Ve.Ge &= ~REACTIVE_REASK;
+        if (i) o.Ve.D &= ~REACTIVE_REASK;
         if (r && o.Ve.Ue & CONFIG_IN_SNAPSHOT_SCOPE) {
-            o.Ve.Ge |= REACTIVE_SNAPSHOT_STALE;
+            o.Ve.D |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
         if (t && n) {
-            o.Ve.Ge |= REACTIVE_OPTIMISTIC_DIRTY;
+            o.Ve.D |= REACTIVE_OPTIMISTIC_DIRTY;
             assignOrMergeLane(o.Ve, n);
         } else if (t) {
-            o.Ve.Ge |= REACTIVE_OPTIMISTIC_DIRTY;
+            o.Ve.D |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
                         o.Ve.i = undefined;
         }
@@ -839,27 +862,27 @@ function insertSubs(e, t = false) {
 function commitPendingNode(e) {
     const t = e;
     if (!t.ke) {
-        if (e.U !== NOT_PENDING) {
-            e.We = e.U;
-            e.U = NOT_PENDING;
+        if (e.k !== NOT_PENDING) {
+            e.We = e.k;
+            e.k = NOT_PENDING;
         }
-        if (e._ || e.R) GlobalQueue.fe(e);
+        if (e._ || e.R) GlobalQueue.Ee(e);
         return;
     }
-    if (e.U !== NOT_PENDING) {
-        e.We = e.U;
-        e.U = NOT_PENDING;
+    if (e.k !== NOT_PENDING) {
+        e.We = e.k;
+        e.k = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.Fe && e.Fe !== EFFECT_TRACKED) e.xe = true;
+                if (e.Fe && e.Fe !== EFFECT_TRACKED) e.Qe = true;
     }
-    t.Ge &= ~REACTIVE_MANUAL_WRITE;
-    if (!(t.Qe & STATUS_PENDING)) t.Qe &= ~STATUS_UNINITIALIZED;
-    if (t.He !== null || t.Me !== null) GlobalQueue.J(t, false, true);
-    if (e._ || e.R) GlobalQueue.fe(e);
+    t.D &= ~REACTIVE_MANUAL_WRITE;
+    if (!(t.xe & STATUS_PENDING)) t.xe &= ~STATUS_UNINITIALIZED;
+    if (t.He !== null || t.Me !== null) GlobalQueue.ee(t, false, true);
+    if (e._ || e.R) GlobalQueue.Ee(e);
 }
 
 function commitPendingNodes() {
-    const e = currentBatch.H;
+    const e = currentBatch.M;
     for (let t = 0; t < e.length; t++) {
         commitPendingNode(e[t]);
     }
@@ -871,24 +894,30 @@ function finalizePureQueue(e = null, t = false) {
     // For completing transitions or no-transition, resolve pending and revert optimistic
     const n = !t;
     if (n) commitPendingNodes();
-    if (!t && globalQueue.m.length) checkBoundaryChildren(globalQueue);
+    if (!t && globalQueue.v.length) checkBoundaryChildren(globalQueue);
     const r = dirtyQueue.C >= dirtyQueue.P;
-    if (r) runHeap(dirtyQueue, GlobalQueue.X);
+    if (r) runHeap(dirtyQueue, GlobalQueue.J);
     if (n) {
         if (r) commitPendingNodes();
         // The settling batch: the completing transaction's, or the ambient one.
-                const t = e ?? globalQueue.D;
+                const t = e ?? globalQueue.m;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.v.length) GlobalQueue.pe(t.v);
+                if (t.L.length) GlobalQueue.Ie(t.L);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
-        // so they re-run with the now-committed values visible.
-                if (e && e.Y.size) {
-            for (const t of e.Y) {
-                if (t.Ge & REACTIVE_DISPOSED) continue;
-                enqueueSub(t);
+        // so they re-run with the now-committed values visible. The ambient batch
+        // replays too — laneReadsCommitted records readers whose committed-view
+        // read hid a same-tick plain write that just committed above (#2963).
+                if (t.q.size) {
+            for (const e of t.q) {
+                if (e.D & REACTIVE_DISPOSED) continue;
+                enqueueSub(e);
             }
-            e.Y.clear();
+            t.q.clear();
+            // A completing transition keeps the outer flush loop alive by itself;
+            // the ambient batch needs the re-arm or the replay sits in the heap
+            // until the next unrelated write.
+                        schedule();
         }
         // Declared motion ends with the transaction: settle (or plain flush end
         // for ambient marks) releases each registration's refcount. A non-empty
@@ -896,23 +925,23 @@ function finalizePureQueue(e = null, t = false) {
         // held boundary display state through the visual channel, and their
         // release is the display-state update point — re-run the boundary sweep
         // (the earlier sweep above ran while the marks were still live).
-                if (t.L.length) {
-            GlobalQueue.re(t.L);
-            if (globalQueue.m.length) checkBoundaryChildren(globalQueue);
+                if (t.G.length) {
+            GlobalQueue.ie(t.G);
+            if (globalQueue.v.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.G.size) GlobalQueue.te(t.G, e);
+                if (t.V.size) GlobalQueue.ne(t.V, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.Ae(e);
+                if (activeLanes.size) GlobalQueue.he(e);
     }
 }
 
 function checkBoundaryChildren(e) {
-    for (const t of e.m) {
+    for (const t of e.v) {
         t.$e?.();
         checkBoundaryChildren(t);
     }
@@ -947,7 +976,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.D;
+let currentBatch = globalQueue.m;
 
 function flush(e) {
     if (e) {
@@ -964,7 +993,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.q) {
+    if (globalQueue.B) {
         return;
     }
     if (halted) return;
@@ -980,7 +1009,7 @@ function runQueue$1(e, t) {
 }
 
 function reporterBlocksSource(e, t) {
-    if (e.Ge & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+    if (e.D & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
     if (e.je?.has(t)) return true;
     for (let n = e.Ke; n; n = n.Ye) {
         let e = n.qe;
@@ -989,14 +1018,14 @@ function reporterBlocksSource(e, t) {
             e = e.t;
         }
     }
-    return !!(e.Qe & STATUS_PENDING && e.we instanceof NotReadyError && e.we.source === t);
+    return !!(e.xe & STATUS_PENDING && e.me instanceof NotReadyError && e.me.source === t);
 }
 
 function transitionComplete(e) {
     if (e.I) return true;
-    if (e.$.length) return false;
+    if (e.j.length) return false;
     let t = true;
-    for (const [n, r] of e.M) {
+    for (const [n, r] of e.$) {
         let i = false;
         for (const e of r) {
             if (reporterBlocksSource(e, n)) {
@@ -1005,7 +1034,7 @@ function transitionComplete(e) {
             }
             r.delete(e);
         }
-        if (!i) e.M.delete(n); else if (n.Qe & STATUS_PENDING && n.we?.source === n) {
+        if (!i) e.$.delete(n); else if (n.xe & STATUS_PENDING && n.me?.source === n) {
             t = false;
             break;
         }
@@ -1013,7 +1042,7 @@ 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.Ie?.(e)) t = false;
+        if (t && GlobalQueue.Ae?.(e)) t = false;
     t && (e.I = true);
     return t;
 }
@@ -1034,7 +1063,7 @@ function runInTransition(e, t) {
 }
 
 /** The queue a node belongs to, picked from its own zombie flag. */ function queueFor(e) {
-    return e.Ge & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    return e.D & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
 }
 
 /**
@@ -1044,8 +1073,8 @@ function runInTransition(e, t) {
  */ function enqueueSub(e) {
     if (e.Fe === EFFECT_TRACKED) {
         const t = e;
-        if (!t.xe) {
-            t.xe = true;
+        if (!t.Qe) {
+            t.Qe = true;
             t.Ze.enqueue(EFFECT_USER, t.Xe);
         }
         return;
@@ -1056,7 +1085,7 @@ function runInTransition(e, t) {
 }
 
 function actualInsertIntoHeap(e, t) {
-    const n = (e.B?.Je ? e.B.et?.ze : e.B?.ze) ?? -1;
+    const n = (e.Z?.Je ? e.Z.et?.ze : e.Z?.ze) ?? -1;
     if (n >= e.ze) e.ze = n + 1;
     const r = e.ze;
     const i = t.h[r];
@@ -1070,12 +1099,12 @@ function actualInsertIntoHeap(e, t) {
 }
 
 function insertIntoHeap(e, t) {
-    let n = e.Ge;
+    let n = e.D;
     if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
     if (n & REACTIVE_CHECK) {
-        e.Ge = n & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+        e.D = n & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
     } else {
-        e.Ge = n | REACTIVE_IN_HEAP;
+        e.D = n | REACTIVE_IN_HEAP;
         // An unmarked node entering a marked heap invalidates the markHeap memo:
         // `_marked` is only reset by runHeap, so a write between two mid-tick
         // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
@@ -1087,16 +1116,16 @@ function insertIntoHeap(e, t) {
 }
 
 function insertIntoHeapHeight(e, t) {
-    let n = e.Ge;
+    let n = e.D;
     if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
-    e.Ge = n | REACTIVE_IN_HEAP_HEIGHT;
+    e.D = n | REACTIVE_IN_HEAP_HEIGHT;
     actualInsertIntoHeap(e, t);
 }
 
 function deleteFromHeap(e, t) {
-    const n = e.Ge;
+    const n = e.D;
     if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-    e.Ge = n & -25;
+    e.D = n & -25;
     const r = e.ze;
     if (e.tt === e) t.h[r] = undefined; else {
         const n = e.nt;
@@ -1114,21 +1143,21 @@ function markHeap(e) {
     e.N = true;
     for (let t = 0; t <= e.C; t++) {
         for (let n = e.h[t]; n !== undefined; n = n.nt) {
-            if (n.Ge & REACTIVE_IN_HEAP) markNode(n);
+            if (n.D & REACTIVE_IN_HEAP) markNode(n);
         }
     }
 }
 
 function markNode(e, t = REACTIVE_DIRTY) {
-    const n = e.Ge;
+    const n = e.D;
     if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
-    e.Ge = n & -4 | t;
-    for (let t = e.V; t !== null; t = t.Le) {
+    e.D = n & -4 | t;
+    for (let t = e.U; t !== null; t = t.Ge) {
         markNode(t.Ve, REACTIVE_CHECK);
     }
     if (e.rt !== null) {
         for (let t = e.rt; t !== null; t = t.it) {
-            for (let e = t.V; e !== null; e = e.Le) {
+            for (let e = t.U; e !== null; e = e.Ge) {
                 markNode(e.Ve, REACTIVE_CHECK);
             }
         }
@@ -1140,7 +1169,7 @@ function runHeap(e, t) {
     for (e.P = 0; e.P <= e.C; e.P++) {
         let n = e.h[e.P];
         while (n !== undefined) {
-            if (n.Ge & REACTIVE_IN_HEAP) t(n); else adjustHeight(n, e);
+            if (n.D & REACTIVE_IN_HEAP) t(n); else adjustHeight(n, e);
             n = e.h[e.P];
         }
     }
@@ -1157,7 +1186,7 @@ function adjustHeight(e, t) {
     }
     if (e.ze !== n) {
         e.ze = n;
-        for (let t = e.V; t !== null; t = t.Le) {
+        for (let t = e.U; t !== null; t = t.Ge) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`
             // unconditionally can park a zombie in `dirtyQueue` (or a live node in
@@ -1174,8 +1203,8 @@ const PENDING_OWNER = {};
 function markDisposal(e) {
     let t = e.ot;
     while (t) {
-        const e = t.Ge;
-        t.Ge = e | REACTIVE_ZOMBIE;
+        const e = t.D;
+        t.D = e | REACTIVE_ZOMBIE;
         // migrate height-adjust entries too, not just recompute entries: every
         // `deleteFromHeap` call site picks the queue from the zombie flag, so a
         // node left physically linked in `dirtyQueue` after being zombified gets
@@ -1201,17 +1230,17 @@ function dispose(e) {
 }
 
 function disposeChildren(e, t = false, n) {
-    const r = e.Ge;
+    const r = e.D;
     if (r & REACTIVE_DISPOSED) return;
     if (t) {
-        e.Ge = r | REACTIVE_DISPOSED;
+        e.D = r | REACTIVE_DISPOSED;
         // Companions are created detached and outlive their owner, but a verdict
         // must not: a disposed source can never settle, so an isPending companion
         // latched `true` here would hold a spinner forever (INV-9, the PR #2845
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const t = e;
-        if (t._ || t.R) GlobalQueue.fe(t);
+        if (t._ || t.R) GlobalQueue.Ee(t);
     }
     if (t && e.ke) e.lt = null;
     let i = n ? e.He : e.ot;
@@ -1240,10 +1269,10 @@ function disposeChildren(e, t = false, n) {
     // batch dispose (parent already disposed) and zombie disposal (node sits on
     // parent's _pendingFirstChild). We leave node._nextSibling intact so outer
     // walks that already advanced past us still reach later siblings.
-        if (t && !n && !(r & REACTIVE_ZOMBIE) && e.B !== null && !(e.B.Ge & REACTIVE_DISPOSED)) {
+        if (t && !n && !(r & REACTIVE_ZOMBIE) && e.Z !== null && !(e.Z.D & REACTIVE_DISPOSED)) {
         const t = e.ft;
         const n = e.st;
-        if (t !== null) t.st = n; else e.B.ot = n;
+        if (t !== null) t.st = n; else e.Z.ot = n;
         if (n !== null) n.ft = t;
         e.ft = null;
     }
@@ -1273,7 +1302,7 @@ function runDisposal(e, t) {
 
 function childId(e, t) {
     let n = e;
-    while (n.Ue & CONFIG_TRANSPARENT && n.B) n = n.B;
+    while (n.Ue & CONFIG_TRANSPARENT && n.Z) n = n.Z;
     if (n.id != null) return formatId(n.id, t ? n.ct++ : n.ct);
     throw new Error("");
 }
@@ -1375,7 +1404,7 @@ function formatId(e, t) {
  * }
  * ```
  */ function isDisposed(e) {
-    return !!(e.Ge & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+    return !!(e.D & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
 }
 
 function disposeRootSelf(e = true) {
@@ -1406,7 +1435,7 @@ function disposeRootSelf(e = true) {
         ct: 0,
         Me: null,
         He: null,
-        B: t,
+        Z: t,
         dispose: disposeRootSelf
     };
     if (t) {
@@ -1454,13 +1483,13 @@ function disposeRootSelf(e = true) {
 function unlinkSubs(e) {
     const t = e.qe;
     const n = e.Ye;
-    const r = e.Le;
+    const r = e.Ge;
     const i = e.Tt;
     if (r !== null) r.Tt = i; else t.Ot = i;
-    if (i !== null) i.Le = r; else {
-        t.V = r;
+    if (i !== null) i.Ge = r; else {
+        t.U = r;
         if (r === null) {
-            t.W?.();
+            t.F?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
             // A pending node is exempt: its in-flight async work (or the
             // transition holding it) is an observer — tearing down would orphan
@@ -1468,7 +1497,7 @@ function unlinkSubs(e) {
             // this same last-one-out check when that observer releases (the
             // untracked-read dispose in core.ts guards on pending identically).
                         const e = t;
-            e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !(e.Ge & REACTIVE_ZOMBIE) && !(e.Qe & STATUS_PENDING) && unobserved(e);
+            e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !(e.D & REACTIVE_ZOMBIE) && !(e.xe & STATUS_PENDING) && unobserved(e);
         }
     }
     return n;
@@ -1509,7 +1538,7 @@ function link(e, t, n = false) {
         return;
     }
     let i = null;
-    const o = t.Ge & REACTIVE_RECOMPUTING_DEPS;
+    const o = t.D & REACTIVE_RECOMPUTING_DEPS;
     if (o) {
         i = r !== null ? r.Ye : t.Ke;
         if (i !== null && i.qe === e) {
@@ -1537,12 +1566,12 @@ function link(e, t, n = false) {
         Ve: t,
         Ye: i,
         Tt: s,
-        Le: null,
+        Ge: null,
         Rt: t.It,
         _t: n
     };
     if (r !== null) r.Ye = u; else t.Ke = u;
-    if (s !== null) s.Le = u; else e.V = u;
+    if (s !== null) s.Ge = u; else e.U = u;
 }
 
 // The lazily-created Set is the ONE container for pending sources. Its
@@ -1569,24 +1598,24 @@ function clearPendingSources(e) {
 
 function setPendingError(e, t, n) {
     if (!t) {
-        e.we = null;
+        e.me = null;
         return;
     }
     if (n instanceof NotReadyError && n.source === t) {
-        e.we = n;
+        e.me = n;
         return;
     }
-    const r = e.we;
+    const r = e.me;
     if (!(r instanceof NotReadyError) || r.source !== t) {
-        e.we = new NotReadyError(t);
+        e.me = new NotReadyError(t);
     }
 }
 
 function forEachDependent(e, t) {
-    for (let n = e.V; n !== null; n = n.Le) t(n.Ve, n);
+    for (let n = e.U; n !== null; n = n.Ge) t(n.Ve, n);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
         for (let n = e.rt ?? null; n !== null; n = n.it) {
-        for (let e = n.V; e !== null; e = e.Le) t(e.Ve, e);
+        for (let e = n.U; e !== null; e = e.Ge) t(e.Ve, e);
     }
 }
 
@@ -1601,7 +1630,7 @@ function forEachDependent(e, t) {
 // callbacks handle their own release (settleAutodispose in handleAsync); this
 // covers derivatively-pending dependents, which have no callbacks of their own.
 function releaseIfSettledUnobserved(e) {
-    e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !e.V && !(e.Ge & REACTIVE_ZOMBIE) && !(e.Qe & STATUS_PENDING) && unobserved(e);
+    e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !e.U && !(e.D & REACTIVE_ZOMBIE) && !(e.xe & STATUS_PENDING) && unobserved(e);
 }
 
 // Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
@@ -1614,7 +1643,7 @@ function releaseSettledDependents(e) {
     const visit = e => {
         if (n.has(e)) return;
         n.add(e);
-        if (!e.V && e.Ue & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
+        if (!e.U && e.Ue & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
         forEachDependent(e, visit);
     };
     forEachDependent(e, visit);
@@ -1642,7 +1671,7 @@ function settleErroredDependents(e, t) {
     const visit = e => {
         if (r.has(e)) return;
         r.add(e);
-        if (e.we === t) {
+        if (e.me === t) {
             enqueueSub(e);
             n = true;
         }
@@ -1657,17 +1686,17 @@ function settlePendingSource(e) {
     let n;
     const r = new Set;
     // Companion updates no-op without the verdict layer (null hook).
-        const i = GlobalQueue.ae;
+        const i = GlobalQueue.ce;
     const settle = o => {
         if (r.has(o) || !removePendingSource(o, e)) return;
         r.add(o);
-        o.F = clock;
+        o.H = clock;
         const s = o.je?.values().next().value;
         if (s) {
             setPendingError(o, s);
             i !== null && i(o);
         } else {
-            o.Qe &= ~STATUS_PENDING;
+            o.xe &= ~STATUS_PENDING;
             setPendingError(o);
             i !== null && i(o);
             if (o.At) {
@@ -1678,7 +1707,7 @@ function settlePendingSource(e) {
             // Fully settled with nobody watching: release candidate (#2934). Checked
             // again at release time — deferred so unobserved() can't unlink subs
             // lists this walk is still iterating.
-                        if (!o.V && o.Ue & CONFIG_AUTO_DISPOSE) (n ??= []).push(o);
+                        if (!o.U && o.Ue & CONFIG_AUTO_DISPOSE) (n ??= []).push(o);
         }
         forEachDependent(o, settle);
     };
@@ -1721,7 +1750,7 @@ function handleAsync(e, t, n) {
     // are the transaction's reveal machinery and always re-enter.
         const settleTransition = () => {
         const t = resolveTransition(e);
-        if (t && e.Qe & STATUS_UNINITIALIZED && !currentTransition(t).M.has(e)) {
+        if (t && e.xe & STATUS_UNINITIALIZED && !currentTransition(t).$.has(e)) {
             // Drop the stale stamp too: the plain settle write (setSignal) and the
             // stash-path restamp both re-enter the transaction through it.
             e.T = null;
@@ -1735,7 +1764,7 @@ function handleAsync(e, t, n) {
         // NotReadyError from rejected promises should be treated as pending, not error
                 const r = n instanceof NotReadyError;
         notifyStatus(e, r ? STATUS_PENDING : STATUS_ERROR, n);
-        e.F = clock;
+        e.H = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
         // cleared their pending sources), so stranded lazy ones release here —
         // the error twin of settlePendingSource's release (#2934).
@@ -1746,9 +1775,9 @@ function handleAsync(e, t, n) {
         // If the node was dirtied by a newer write (optimistic override or regular),
         // skip this stale async result — the upcoming flush will recompute the node
         // with the new value, creating a fresh Promise that supersedes this one.
-                if (e.Ge & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+                if (e.D & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
         settleTransition();
-        const o = !!(e.Qe & STATUS_UNINITIALIZED);
+        const o = !!(e.xe & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
         const s = resolveLane(e);
@@ -1766,8 +1795,8 @@ function handleAsync(e, t, n) {
             // (A17 — every reader sees the override); the revert reveals whatever
             // has committed by then, so corrections reveal atomically with their
             // transition rather than escaping it.
-            if (e.U === NOT_PENDING) queuePendingNode(e);
-            e.U = r;
+            if (e.k === NOT_PENDING) queuePendingNode(e);
+            e.k = r;
             // The hold is a companion-visible write like any other (A13/A19): the
             // clearStatus() above computed its verdict before the hold existed, so
             // isPending must re-derive (the value is not final until commit — V1)
@@ -1775,9 +1804,9 @@ function handleAsync(e, t, n) {
             // only notified when the hold is visible to them: under an active
             // override every reader sees the override (A17), so waking subs would
             // re-show an unchanged view — the revert is the notification point.
-                        GlobalQueue.le !== null && GlobalQueue.le(e, r);
+                        GlobalQueue.ae !== null && GlobalQueue.ae(e, r);
             if (!hasActiveOverride(e)) insertSubs(e);
-            e.F = clock;
+            e.H = clock;
         } else if (s) {
             // Route through lane's effect queue for independent flushing
             const t = e.Fe;
@@ -1786,11 +1815,11 @@ function handleAsync(e, t, n) {
             try {
                 if (!t && o || !i || !i(r, n)) {
                     e.We = r;
-                    e.F = clock;
+                    e.H = clock;
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
                     // (computePendingState doesn't read _value).
-                                        GlobalQueue.le !== null && GlobalQueue.le(e, r);
+                                        GlobalQueue.ae !== null && GlobalQueue.ae(e, r);
                     insertSubs(e, true);
                 }
             } catch (t) {
@@ -1822,7 +1851,7 @@ function handleAsync(e, t, n) {
     // Returns whether the node released, so the iterator branch can stop
     // pulling values instead of pumping an unobserved stream forever (#2935).
         const settleAutodispose = () => {
-        if (e.Ue & CONFIG_AUTO_DISPOSE && !e.V && !(e.Qe & STATUS_PENDING)) {
+        if (e.Ue & CONFIG_AUTO_DISPOSE && !e.U && !(e.xe & STATUS_PENDING)) {
             unobserved(e);
             return true;
         }
@@ -1944,12 +1973,12 @@ function clearStatus(e, t = false) {
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
         e.Nt = false;
-    e.Qe = t ? 0 : e.Qe & STATUS_UNINITIALIZED;
-    if (e.we) setPendingError(e);
+    e.xe = t ? 0 : e.xe & STATUS_UNINITIALIZED;
+    if (e.me) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e._ || e.R) GlobalQueue.ae(e);
-    if (e.rt && GlobalQueue.ce !== null) GlobalQueue.ce(e);
+        if (e._ || e.R) GlobalQueue.ce(e);
+    if (e.rt && GlobalQueue.fe !== null) GlobalQueue.fe(e);
     if (e.yt) e.yt();
 }
 
@@ -1963,17 +1992,17 @@ function notifyStatus(e, t, n, r, i) {
     if (!r) {
         if (t === STATUS_PENDING && o) {
             addPendingSource(e, o);
-            e.Qe = STATUS_PENDING | e.Qe & STATUS_UNINITIALIZED;
+            e.xe = STATUS_PENDING | e.xe & STATUS_UNINITIALIZED;
             // Preserve the current source on this propagation so render-effect notification
             // can register every distinct pending source with the transition.
                         setPendingError(e, o, n);
         } else {
             clearPendingSources(e);
-            e.Qe = t | (t !== STATUS_ERROR ? e.Qe & STATUS_UNINITIALIZED : 0);
-            e.we = n;
+            e.xe = t | (t !== STATUS_ERROR ? e.xe & STATUS_UNINITIALIZED : 0);
+            e.me = n;
         }
-        GlobalQueue.ae !== null && GlobalQueue.ae(e);
-        if (e.rt && GlobalQueue.ce !== null) GlobalQueue.ce(e);
+        GlobalQueue.ce !== null && GlobalQueue.ce(e);
+        if (e.rt && GlobalQueue.fe !== null) GlobalQueue.fe(e);
     }
     if (i && !r) {
         assignOrMergeLane(e, i);
@@ -1992,8 +2021,8 @@ function notifyStatus(e, t, n, r, i) {
         return;
     }
     forEachDependent(e, (e, r) => {
-        e.F = clock;
-        if (t === STATUS_PENDING && o && !e.je?.has(o) || t !== STATUS_PENDING && (e.we !== n || e.je)) {
+        e.H = clock;
+        if (t === STATUS_PENDING && o && !e.je?.has(o) || t !== STATUS_PENDING && (e.me !== n || e.je)) {
             // A pending-observer link is the subscription an `isPending` read created.
             // It exists so the observer re-runs when the source settles, but it must
             // not carry a real (non-NotReadyError) error — the synchronous `isPending`
@@ -2010,9 +2039,9 @@ function notifyStatus(e, t, n, r, i) {
     });
 }
 
-GlobalQueue.X = recompute;
+GlobalQueue.J = recompute;
 
-GlobalQueue.J = disposeChildren;
+GlobalQueue.ee = disposeChildren;
 
 let tracking = false;
 
@@ -2045,7 +2074,7 @@ let snapshotSources = null;
 function ownerInSnapshotScope(e) {
     while (e) {
         if (e.Pt) return true;
-        e = e.B;
+        e = e.Z;
     }
     return false;
 }
@@ -2075,9 +2104,9 @@ function releaseSubtree(e) {
         if (t.ke) {
             const e = t;
             e.Ue &= ~CONFIG_IN_SNAPSHOT_SCOPE;
-            if (e.Ge & REACTIVE_SNAPSHOT_STALE) {
-                e.Ge &= ~REACTIVE_SNAPSHOT_STALE;
-                e.Ge |= REACTIVE_DIRTY;
+            if (e.D & REACTIVE_SNAPSHOT_STALE) {
+                e.D &= ~REACTIVE_SNAPSHOT_STALE;
+                e.D |= REACTIVE_DIRTY;
                 if (dirtyQueue.P > e.ze) dirtyQueue.P = e.ze;
                 insertIntoHeap(e, dirtyQueue);
             }
@@ -2090,7 +2119,7 @@ function releaseSubtree(e) {
 function clearSnapshots() {
     if (snapshotSources) {
         for (const e of snapshotSources) {
-            delete e.ve;
+            delete e.Le;
             // StoreNode targets share one pre-initialized hidden class (see
             // createStoreProxy) — assign undefined instead of deleting, and only
             // when present so signal-node sources don't grow the field.
@@ -2117,23 +2146,23 @@ function recompute(e, t = false) {
             e.ct = 0;
         } else ;
     }
-    let r = !!(e.Ge & REACTIVE_OPTIMISTIC_DIRTY);
+    let r = !!(e.D & REACTIVE_OPTIMISTIC_DIRTY);
     const i = e.A !== undefined && e.A !== NOT_PENDING;
-    const o = !!(e.Qe & STATUS_UNINITIALIZED);
+    const o = !!(e.xe & STATUS_UNINITIALIZED);
     // Outgoing error, captured before the compute clears status: if this run
     // recovers to an unchanged value, dependents still holding this object must
     // be swept (settleErroredDependents, #2949).
-        const s = e.Qe & STATUS_ERROR ? e.we : undefined;
+        const s = e.xe & STATUS_ERROR ? e.me : undefined;
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
-        const u = (e.Ge & REACTIVE_REASK) !== 0;
+        const u = (e.D & REACTIVE_REASK) !== 0;
     const l = context;
     context = e;
     e.ut = null;
     e.It++;
-    e.Ge = REACTIVE_RECOMPUTING_DEPS;
-    e.F = clock;
-    let a = e.U === NOT_PENDING ? e.We : e.U;
+    e.D = REACTIVE_RECOMPUTING_DEPS;
+    e.H = clock;
+    let a = e.k === NOT_PENDING ? e.We : e.k;
     let c = e.ze;
     let f = tracking;
     let E = currentOptimisticLane;
@@ -2150,13 +2179,13 @@ function recompute(e, t = false) {
     // engine-driven paths, and _optimisticNodes is only pushed by
     // _optimisticWrite, so the hook is installed whenever either gate holds.
         if (r) {
-        const t = GlobalQueue.Ce(e, true);
+        const t = GlobalQueue.ge(e, true);
         if (t) currentOptimisticLane = t;
-    } else if (activeTransition && !t && activeTransition.v.length) {
+    } else if (activeTransition && !t && activeTransition.L.length) {
         // Lane adoption: parent-deeper-than-owned-child can run before its OPT-dirty
         // child propagates. Walk deps once and inherit the OPT lane so this node
         // recomputes under the right posture and propagates correctly.
-        const t = GlobalQueue.Ce(e, false);
+        const t = GlobalQueue.ge(e, false);
         if (t) {
             r = true;
             currentOptimisticLane = t;
@@ -2185,30 +2214,30 @@ function recompute(e, t = false) {
         // On a status-free node clearStatus is a guaranteed no-op: every branch
         // in its body is gated on one of these fields, and with _statusFlags === 0
         // the flags write (create or not) stores the 0 already there.
-                if (e.Qe !== 0 || e.yt !== undefined || e.we || e.Nt || e.At || e.je !== undefined || e._ !== undefined || e.R !== undefined || e.rt !== null) clearStatus(e, t);
+                if (e.xe !== 0 || e.yt !== undefined || e.me || e.Nt || e.At || e.je !== undefined || e._ !== undefined || e.R !== undefined || e.rt !== null) clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths.
-                if (e.i) GlobalQueue.be(e);
+                if (e.i) GlobalQueue.De(e);
     } catch (t) {
         // Track pending async in the lane (not the lane's source — it creates the lane
         // but doesn't belong to it). Set lane BEFORE notifyStatus for downstream propagation.
-        if (t instanceof NotReadyError && currentOptimisticLane) GlobalQueue.ge(e);
+        if (t instanceof NotReadyError && currentOptimisticLane) GlobalQueue.be(e);
         let n = false;
         if (t instanceof NotReadyError) {
             e.At = true;
-            if (GlobalQueue.Te !== null) n = GlobalQueue.Te(e, u);
+            if (GlobalQueue.Oe !== null) n = GlobalQueue.Oe(e, u);
         }
         notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.i : undefined);
-        if (n) GlobalQueue.Oe(e);
+        if (n) GlobalQueue._e(e);
     } finally {
         tracking = f;
         latestReadActive = d;
         if (S) stale = T;
-        e.Ge = REACTIVE_NONE | (t ? e.Ge & REACTIVE_SNAPSHOT_STALE : 0);
+        e.D = REACTIVE_NONE | (t ? e.D & REACTIVE_SNAPSHOT_STALE : 0);
         context = l;
     }
-    if (!e.we) {
+    if (!e.me) {
         trimStaleDeps(e);
-        const u = i ? unwrapOverride(e.A) : e.U === NOT_PENDING ? e.We : e.U;
+        const u = i ? unwrapOverride(e.A) : e.k === NOT_PENDING ? e.We : e.k;
         let l = false;
         try {
             l = !n && o || !e.ht || !e.ht(u, a);
@@ -2225,12 +2254,12 @@ function recompute(e, t = false) {
         // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
         // effect() can call its runner synchronously for the first run.
                 if (n && l) {
-            e.xe = !e.we;
+            e.Qe = !e.me;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
-                        if (!t) e.Ze.enqueue(n, e.Ct ??= GlobalQueue.ee.bind(null, e));
+                        if (!t) e.Ze.enqueue(n, e.Ct ??= GlobalQueue.te.bind(null, e));
         }
-        if (e.we) ; else if (l) {
+        if (e.me) ; else if (l) {
             const o = i ? e.A : undefined;
             if (t || 
             // Plain sync flush (no transition on either side) commits effect
@@ -2245,28 +2274,28 @@ function recompute(e, t = false) {
                 // commit can't clobber the fresh value.
                                 if (i && r) {
                     e.A = a === undefined ? OVERRIDE_UNDEFINED : a;
-                    e.U = NOT_PENDING;
+                    e.k = NOT_PENDING;
                 }
             } else {
-                e.U = a;
+                e.k = a;
                 // Transition-held sync recompute is a write path like setSignal/asyncWrite,
                 // so sync derivations of held sources stay visible to isPending()/latest()
                 // (#2831). Both companion writes are transition-scoped (optimistic) and
                 // auto-revert/re-derive at commit. Skipped for plain flushes where the
                 // pending value commits before effects run.
-                                if ((activeTransition || e.T) && GlobalQueue.le !== null) GlobalQueue.le(e, a);
+                                if ((activeTransition || e.T) && GlobalQueue.ae !== null) GlobalQueue.ae(e, a);
             }
             // insertSubs only walks _subs (no scheduling of its own), so a
             // subscriber-less node has nothing to notify.
-                        if (e.V !== null && (!i || r || e.A !== o)) insertSubs(e, r || i);
+                        if (e.U !== null && (!i || r || e.A !== o)) insertSubs(e, r || i);
         } else if (i) {
             // Unchanged value (equals the override) recomputed while the override
             // is active: _value may still be stale, so hold the authoritative value
             // for commit on its own transition's schedule — invisibly (A17/A18).
-            if (e.U === NOT_PENDING) queuePendingNode(e);
-            e.U = a;
+            if (e.k === NOT_PENDING) queuePendingNode(e);
+            e.k = a;
         } else if (e.ze != c) {
-            for (let t = e.V; t !== null; t = t.Le) {
+            for (let t = e.U; t !== null; t = t.Ge) {
                 insertIntoHeapHeight(t.Ve, queueFor(t.Ve));
             }
         }
@@ -2275,36 +2304,36 @@ function recompute(e, t = false) {
         // in an errored run and may sit on stale commits (#2949). Changed-value
         // recoveries ride insertSubs above; a comparator throw re-errored the node
         // (el._error re-set), so this only runs on a genuinely clean recovery.
-                if (s !== undefined && !l && !e.we) settleErroredDependents(e, s);
+                if (s !== undefined && !l && !e.me) settleErroredDependents(e, s);
     }
     currentOptimisticLane = E;
-    const O = e.U !== NOT_PENDING || e.He !== null || e.Me !== null || (e.Qe & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    const O = e.k !== NOT_PENDING || e.He !== null || e.Me !== null || (e.xe & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
     // Override-covered holds (hasOverride) always queue: their commit belongs
     // to their own transition's schedule (A18 re-rule) and is unobservable
     // under the override (A17). Revert no longer commits anything, so an
     // unqueued covered hold would leak (INV-7) once the revert clears
     // _transition.
-        O && (!t || e.Qe & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
+        O && (!t || e.xe & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
     e.T && n && activeTransition !== e.T && runInTransition(e.T, () => recompute(e));
 }
 
 function updateIfNecessary(e) {
-    if (e.Ge & REACTIVE_CHECK) {
+    if (e.D & REACTIVE_CHECK) {
         for (let t = e.Ke; t; t = t.Ye) {
             const n = t.qe;
             const r = n.Be || n;
             if (r.ke) {
                 updateIfNecessary(r);
             }
-            if (e.Ge & REACTIVE_DIRTY) {
+            if (e.D & REACTIVE_DIRTY) {
                 break;
             }
         }
     }
-    if (e.Ge & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.we && e.F < clock && !e.lt) {
+    if (e.D & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.me && e.H < clock && !e.lt) {
         recompute(e);
     }
-    e.Ge = e.Ge & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
+    e.D = e.D & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
 }
 
 function computed(e, t) {
@@ -2313,7 +2342,7 @@ function computed(e, t) {
         id: inheritId(t, n, context),
         Ue: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.gt ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
         ht: t?.equals != null ? t.equals : isEqual,
-        W: t?.unobserved,
+        F: t?.unobserved,
         dt: null,
         Ze: context?.Ze ?? globalQueue,
         St: context?.St ?? defaultContext,
@@ -2327,16 +2356,16 @@ function computed(e, t) {
         Ke: null,
         ut: null,
         It: 0,
-        V: null,
+        U: null,
         Ot: null,
-        B: context,
+        Z: context,
         st: null,
         ft: null,
         ot: null,
-        Ge: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-        Qe: STATUS_UNINITIALIZED,
-        F: clock,
-        U: NOT_PENDING,
+        D: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+        xe: STATUS_UNINITIALIZED,
+        H: clock,
+        k: NOT_PENDING,
         Me: null,
         He: null,
         lt: null,
@@ -2358,7 +2387,7 @@ function computed(e, t) {
         id: inheritId(o, s, context),
         Ue: (s ? CONFIG_TRANSPARENT : 0) | (o?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (o?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
         ht: false,
-        W: o?.unobserved,
+        F: o?.unobserved,
         dt: null,
         Ze: context?.Ze ?? globalQueue,
         St: context?.St ?? defaultContext,
@@ -2372,22 +2401,22 @@ function computed(e, t) {
         Ke: null,
         ut: null,
         It: 0,
-        V: null,
+        U: null,
         Ot: null,
-        B: context,
+        Z: context,
         st: null,
         ft: null,
         ot: null,
-        Ge: REACTIVE_LAZY,
-        Qe: STATUS_UNINITIALIZED,
-        F: clock,
-        U: NOT_PENDING,
+        D: REACTIVE_LAZY,
+        xe: STATUS_UNINITIALIZED,
+        H: clock,
+        k: NOT_PENDING,
         Me: null,
         He: null,
         lt: null,
         T: null,
         Nt: false,
-        xe: false,
+        Qe: false,
         bt: undefined,
         Dt: t,
         wt: n,
@@ -2417,11 +2446,11 @@ function setupComputedNode(e, t) {
         }
     }
     if (n) e.ze = n.ze + 1;
-    if (GlobalQueue.se !== null) GlobalQueue.se(e);
+    if (GlobalQueue.ue !== null) GlobalQueue.ue(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
-        if (!(e.Qe & STATUS_PENDING) && !(e.Ue & CONFIG_NO_SNAPSHOT)) {
-            e.ve = e.We === undefined ? NO_SNAPSHOT : e.We;
+        if (!(e.xe & STATUS_PENDING) && !(e.Ue & CONFIG_NO_SNAPSHOT)) {
+            e.Le = e.We === undefined ? NO_SNAPSHOT : e.We;
             snapshotSources.add(e);
         }
     }
@@ -2431,18 +2460,18 @@ function signal(e, t, n = null) {
     const r = {
         ht: t?.equals != null ? t.equals : isEqual,
         Ue: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.gt ? CONFIG_NO_SNAPSHOT : 0),
-        W: t?.unobserved,
+        F: t?.unobserved,
         We: e,
-        V: null,
+        U: null,
         Ot: null,
-        F: clock,
+        H: clock,
         Be: n,
         it: n?.rt || null,
-        U: NOT_PENDING
+        k: NOT_PENDING
     };
     n && (n.rt = r);
-    if (snapshotCaptureActive && !(r.Ue & CONFIG_NO_SNAPSHOT) && !((n?.Qe ?? 0) & STATUS_PENDING)) {
-        r.ve = e === undefined ? NO_SNAPSHOT : e;
+    if (snapshotCaptureActive && !(r.Ue & CONFIG_NO_SNAPSHOT) && !((n?.xe ?? 0) & STATUS_PENDING)) {
+        r.Le = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources.add(r);
     }
     return r;
@@ -2486,11 +2515,11 @@ function isEqual(e, t) {
  * );
  * ```
  */ function untrack(e, t) {
-    if (GlobalQueue.ue === null && !tracking && true) return e();
+    if (GlobalQueue.le === null && !tracking && true) return e();
     const n = tracking;
     tracking = false;
     try {
-        if (GlobalQueue.ue !== null) return GlobalQueue.ue(e);
+        if (GlobalQueue.le !== null) return GlobalQueue.le(e);
         return e();
     } finally {
         tracking = n;
@@ -2502,10 +2531,10 @@ function isEqual(e, t) {
  * an isPending() probe (`refresh`) additionally pulls the node fully up to
  * date so its status flags reflect the current graph.
  */ function prepareComputed(e, t) {
-    if (e.Ge & REACTIVE_LAZY) {
-        e.Ge &= ~REACTIVE_LAZY;
+    if (e.D & REACTIVE_LAZY) {
+        e.D &= ~REACTIVE_LAZY;
         recompute(e, true);
-    } else if (e.Ge & REACTIVE_DISPOSED) {
+    } else if (e.D & REACTIVE_DISPOSED) {
         recompute(e, true);
     } else if (t) {
         updateIfNecessary(e);
@@ -2526,11 +2555,11 @@ function isEqual(e, t) {
  * snapshot / transition / lane / dev-strictRead state all take the full
  * resolution. Anything slow returns READ_SLOW; the caller then calls read().
  */ function readNodeFast(e) {
-    if (latestReadActive || pendingCheckActive || e.ke || e.Be || e.A !== undefined || e.ve !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
+    if (latestReadActive || pendingCheckActive || e.ke || e.Be || e.A !== undefined || e.Le !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
     let t = context;
     if (t?.Je) t = t.et;
     if (t && tracking) link(e, t);
-    return !t || e.U === NOT_PENDING ? e.We : e.U;
+    return !t || e.k === NOT_PENDING ? e.We : e.k;
 }
 
 function read(e) {
@@ -2538,7 +2567,7 @@ function read(e) {
     // Checked before isPending so that isPending(() => latest(x)) checks
     // the _pendingSignal of _latestValueComputed (async in flight) rather
     // than the original node (which stays "pending" while held in a transition).
-    if (latestReadActive) return GlobalQueue.Ee(e);
+    if (latestReadActive) return GlobalQueue.de(e);
     let t = context;
     if (t?.Je) t = t.et;
     const n = e;
@@ -2548,13 +2577,13 @@ function read(e) {
     // Probe mode is suspended while preparing the node so nested reads during a
     // recompute don't collect into the probe.
         if (pendingCheckActive) {
-        GlobalQueue.de(e, t, i, r);
+        GlobalQueue.Se(e, t, i, r);
     } else if (typeof n.ke === "function") {
         prepareComputed(e, false);
     }
-    if (!n.ke && i === e && e.A === undefined && e.ve === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+    if (!n.ke && i === e && e.A === undefined && e.Le === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
         if (t && tracking) link(e, t);
-        return !t || e.U === NOT_PENDING ? e.We : e.U;
+        return !t || e.k === NOT_PENDING ? e.We : e.k;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
@@ -2567,47 +2596,47 @@ function read(e) {
             }
             const r = i.ze;
             // parent check is shallow, might need to be recursive
-                        if (r >= t.ze && e.B !== t) {
+                        if (r >= t.ze && e.Z !== t) {
                 t.ze = r + 1;
             }
         }
     }
-    if (i.Qe & STATUS_PENDING) {
+    if (i.xe & STATUS_PENDING) {
         if (t && !(stale && i.T && activeTransition !== i.T)) {
             // Per-lane suspension lives with the engine (a non-null lane implies it
             // is installed): under a lane, only same-lane pending async without an
             // active override throws.
-            if (currentOptimisticLane === null || GlobalQueue.ye(i)) {
+            if (currentOptimisticLane === null || GlobalQueue.Pe(i)) {
                 if (!tracking && e !== t) link(e, t);
-                throw i.we;
+                throw i.me;
             }
-        } else if (t && i !== e && i.Qe & STATUS_UNINITIALIZED) {
+        } else if (t && i !== e && i.xe & STATUS_UNINITIALIZED) {
             if (!tracking && e !== t) link(e, t);
-            throw i.we;
-        } else if (!t && i.Qe & STATUS_UNINITIALIZED) {
-            throw i.we;
+            throw i.me;
+        } else if (!t && i.xe & STATUS_UNINITIALIZED) {
+            throw i.me;
         }
     }
     // `owner` is the computed itself, or the firewall behind a store node —
     // firewall-backed reads follow the same rules (memo parity, #2897 ruling):
     // an errored derive throws for every late reader instead of silently
     // serving node values (the seed, or last-good data after a failed refetch).
-        if (i.ke && i.Qe & STATUS_ERROR) {
+        if (i.ke && i.xe & STATUS_ERROR) {
         // Only a genuine reactive re-read may retry an errored async source:
         // - tracking: owned/tracked scope only (never events / `untrack` / effect side-effect phase)
         // - !pendingCheckActive: an `isPending` probe observes the error, never refetches
         // - owner._time < clock: only on a later cycle than the one the error was found
-        if (tracking && !pendingCheckActive && i.F < clock) {
+        if (tracking && !pendingCheckActive && i.H < clock) {
             recompute(i);
             return read(e);
-        } else throw i.we;
+        } else throw i.me;
     }
     if (snapshotCaptureActive && t && t.Ue & CONFIG_IN_SNAPSHOT_SCOPE) {
-        const n = e.ve;
+        const n = e.Le;
         if (n !== undefined) {
             const r = n === NO_SNAPSHOT ? undefined : n;
-            const i = e.U !== NOT_PENDING ? e.U : e.We;
-            if (i !== r) t.Ge |= REACTIVE_SNAPSHOT_STALE;
+            const i = e.k !== NOT_PENDING ? e.k : e.We;
+            if (i !== r) t.D |= REACTIVE_SNAPSHOT_STALE;
             return r;
         }
     }
@@ -2622,18 +2651,18 @@ function read(e) {
     // _pendingValue for correct fetching. The sub is recorded for replay at commit
     // so it re-runs with the new committed view. (Gate details live with the
     // engine — a non-null lane implies it is installed.)
-        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Ne(e, i, t)) {
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.ye(e, i, t)) {
         return e.We;
     }
     // In optimistic lane context, return _value for optimistic/lane-assigned signals
     // and for regular signals in stale mode (render effects). Non-stale readers (user
     // effects) see _pendingValue so that latest() and direct reads stay consistent.
     // (The lane-context clause lives with the engine.)
-        const o = !t || currentOptimisticLane !== null && GlobalQueue.Pe(e, i, t) || e.U === NOT_PENDING || stale && e.T && activeTransition !== e.T ? e.We : e.U;
+        const o = !t || currentOptimisticLane !== null && GlobalQueue.Ce(e, i, t) || e.k === NOT_PENDING || stale && e.T && activeTransition !== e.T ? e.We : e.k;
     // Record that this isPending() probe observed the fresh pending value, so
     // the probe doesn't pair "pending" with the new value (#2831).
-        if (pendingCheckActive) GlobalQueue.Se(e, o);
-    if (!t && i === e && typeof n.ke === "function" && e.Ue & CONFIG_AUTO_DISPOSE && !(i.Qe & STATUS_PENDING) && !e.V) {
+        if (pendingCheckActive) GlobalQueue.Te(e, o);
+    if (!t && i === e && typeof n.ke === "function" && e.Ue & CONFIG_AUTO_DISPOSE && !(i.xe & STATUS_PENDING) && !e.U) {
         unobserved(e);
     }
     return o;
@@ -2645,20 +2674,20 @@ function setSignal(e, t) {
     // optimisticComputed callers and optimistic store nodes carry an
     // _overrideValue slot, and every module that creates one installs the
     // engine first.
-        if (e.A !== undefined && !projectionWriteActive) return GlobalQueue.Re(e, t);
-    const n = e.U === NOT_PENDING ? e.We : e.U;
+        if (e.A !== undefined && !projectionWriteActive) return GlobalQueue.pe(e, t);
+    const n = e.k === NOT_PENDING ? e.We : e.k;
     if (typeof t === "function") t = t(n);
     // Uninitialized check first: the first commit has no previous value, so the
     // user comparator must not run against `undefined` (matches recompute).
-        const r = !!(e.Qe & STATUS_UNINITIALIZED) || !e.ht || !e.ht(n, t);
+        const r = !!(e.xe & STATUS_UNINITIALIZED) || !e.ht || !e.ht(n, t);
     if (!r) return t;
-    if (e.U === NOT_PENDING) queuePendingNode(e);
-    e.U = t;
+    if (e.k === NOT_PENDING) queuePendingNode(e);
+    e.k = t;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op (companions are
     // only ever created, never removed, and creating one installs the hook).
-        (e._ !== undefined || e.R !== undefined) && GlobalQueue.le !== null && GlobalQueue.le(e, t);
-    e.F = clock;
+        (e._ !== undefined || e.R !== undefined) && GlobalQueue.ae !== null && GlobalQueue.ae(e, t);
+    e.H = clock;
     insertSubs(e);
     schedule();
     return t;
@@ -2672,11 +2701,11 @@ function setSignal(e, t) {
  * cleanup point.
  */ function suppressComputedRecompute(e) {
     deleteFromHeap(e, queueFor(e));
-    if (!(e.Ge & REACTIVE_MANUAL_WRITE) && e.U === NOT_PENDING) {
+    if (!(e.D & REACTIVE_MANUAL_WRITE) && e.k === NOT_PENDING) {
         queuePendingNode(e);
         schedule();
     }
-    e.Ge = e.Ge & -4 | REACTIVE_MANUAL_WRITE;
+    e.D = e.D & -4 | REACTIVE_MANUAL_WRITE;
 }
 
 /**
@@ -2755,7 +2784,7 @@ function staleValues(e, t = true) {
     if (!t) {
         return;
     }
-    if (typeof t.ke === "function" && !(t.Ge & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))) {
+    if (typeof t.ke === "function" && !(t.D & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))) {
         // A refresh with no value-change dirt already queued is a re-ask of the
         // same question: mark it so the recompute classifies any resulting
         // pending window as quiet (not pending). If the node is already dirty
@@ -2763,11 +2792,11 @@ function staleValues(e, t = true) {
         // REACTIVE_IN_HEAP counts as dirt: insertSubs schedules subscribers by
         // heap insertion alone (no DIRTY/CHECK flag), so a same-batch value
         // change followed by refresh() must not be laundered into a quiet re-ask.
-        if (!(t.Ge & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
-            t.Ge |= REACTIVE_REASK;
+        if (!(t.D & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+            t.D |= REACTIVE_REASK;
             armReaskClear();
         }
-        t.Ge = t.Ge & ~REACTIVE_CHECK | REACTIVE_DIRTY;
+        t.D = t.D & ~REACTIVE_CHECK | REACTIVE_DIRTY;
         insertIntoHeap(t, queueFor(t));
         schedule();
     }
@@ -2833,8 +2862,8 @@ function externalUntrack(e) {
 // removed on reset) so core's null checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.se = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.ue = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.ue = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.le = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {
@@ -2943,7 +2972,7 @@ function isUndefined(e) {
     const n = e.A !== NOT_PENDING;
     const r = n ? unwrapOverride(e.A) : e.We;
     if (typeof t === "function") t = t(r);
-    const i = !!(e.Qe & STATUS_UNINITIALIZED) || !e.ht || !e.ht(r, t);
+    const i = !!(e.xe & STATUS_UNINITIALIZED) || !e.ht || !e.ht(r, t);
     if (!i) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -2957,7 +2986,7 @@ function isUndefined(e) {
     // No revert target is stashed: while the override is active every reader
     // sees it (A17), so authoritative arrivals commit silently into _value and
     // reverting is just dropping the override — _value is already correct.
-     else globalQueue.D.v.push(e);
+     else globalQueue.m.L.push(e);
     // Stamp ownership on the node (post-merge, so entangled writers share the
     // joint root). resolveTransition prefers this over the lane's _transition,
     // which a shared subscriber can merge across transactions (#2912).
@@ -2970,8 +2999,8 @@ function isUndefined(e) {
         e.A = t === undefined ? OVERRIDE_UNDEFINED : t;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op.
-        (e._ !== undefined || e.R !== undefined) && GlobalQueue.le !== null && GlobalQueue.le(e, t);
-    e.F = clock;
+        (e._ !== undefined || e.R !== undefined) && GlobalQueue.ae !== null && GlobalQueue.ae(e, t);
+    e.H = clock;
     insertSubs(e, true);
     schedule();
     return t;
@@ -2982,9 +3011,9 @@ function isUndefined(e) {
  * while one of its optimistic nodes holds an active override that is still
  * pending on real (non-affects-sentinel) async.
  */ function transitionBlocked(e) {
-    for (let t = 0; t < e.v.length; t++) {
-        const n = e.v[t];
-        if (hasActiveOverride(n) && "Qe" in n && n.Qe & STATUS_PENDING && n.we instanceof NotReadyError) {
+    for (let t = 0; t < e.L.length; t++) {
+        const n = e.L[t];
+        if (hasActiveOverride(n) && "xe" in n && n.xe & STATUS_PENDING && n.me instanceof NotReadyError) {
             return true;
         }
     }
@@ -3002,7 +3031,7 @@ function resolveOptimisticNodes(e) {
         // Revert is a pure drop: there is no revert target to commit —
         // override-covered authoritative values hold in _pendingValue and
         // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
-                if (!(t.Qe & STATUS_PENDING)) t.Qe &= ~STATUS_UNINITIALIZED;
+                if (!(t.xe & STATUS_PENDING)) t.xe &= ~STATUS_UNINITIALIZED;
         const r = t.A;
         t.A = NOT_PENDING;
         if (r !== NOT_PENDING && t.We !== unwrapOverride(r)) insertSubs(t, true);
@@ -3014,9 +3043,9 @@ function resolveOptimisticNodes(e) {
     // transition that produced them (A19 — pending is a property of the data).
         for (let n = 0; n < t; n++) {
         const t = e[n];
-        if (t._ || t.R) GlobalQueue.fe(t);
+        if (t._ || t.R) GlobalQueue.Ee(t);
         const r = t.t;
-        if (r && (r._ === t || r.R === t)) GlobalQueue.fe(r);
+        if (r && (r._ === t || r.R === t)) GlobalQueue.Ee(r);
     }
     e.splice(0, t);
 }
@@ -3069,10 +3098,10 @@ function cleanupCompletedLanes(e) {
  * that reads a pending mid-transition write sees the committed value; the sub
  * is recorded for replay at commit.
  */ function gatedRead(e, t, n) {
-    if (latestReadActive || e.U === NOT_PENDING || e.ke || t !== e && !(t.Ge & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e.k === NOT_PENDING || e.ke || t !== e && !(t.D & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
-    activeTransition.Y.add(n);
+    activeTransition.q.add(n);
     return true;
 }
 
@@ -3080,7 +3109,19 @@ function cleanupCompletedLanes(e) {
  * read()'s value selection under a lane: return the committed `_value` for
  * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
  */ function laneReadsCommitted(e, t, n) {
-    return e.A !== undefined || !!e.i || t === e && stale && n.t !== e || !!(t.Qe & STATUS_PENDING);
+    if (e.A !== undefined || !!e.i || !!(t.xe & STATUS_PENDING)) return true;
+    if (t === e && stale && n.t !== e) {
+        // The committed view can hide a same-tick ambient write (a lane member —
+        // even just an isPending companion flip — puts the reader "under a lane"
+        // against unrelated plain writes). With no transaction the write commits
+        // at THIS flush's end with no re-delivery, so record the reader for
+        // replay at commit — the same contract gatedRead provides when a
+        // transaction is active (#2963). If a transaction forms mid-flush,
+        // initTransition carries the recording over to it.
+        if (e.k !== NOT_PENDING && activeTransition === null) globalQueue.m.q.add(n);
+        return true;
+    }
+    return false;
 }
 
 /**
@@ -3091,10 +3132,10 @@ function cleanupCompletedLanes(e) {
     if (t) return resolveLane(e) ?? null;
     for (let t = e.Ke; t; t = t.Ye) {
         const n = t.qe;
-        if (n.Ge & REACTIVE_OPTIMISTIC_DIRTY) {
+        if (n.D & REACTIVE_OPTIMISTIC_DIRTY) {
             const t = resolveLane(n);
             if (t) {
-                e.Ge |= REACTIVE_OPTIMISTIC_DIRTY;
+                e.D |= REACTIVE_OPTIMISTIC_DIRTY;
                 assignOrMergeLane(e, t);
                 return t;
             }
@@ -3108,7 +3149,7 @@ function cleanupCompletedLanes(e) {
     if (t.o !== e) {
         t.u.add(e);
         e.i = t;
-        GlobalQueue.ae !== null && GlobalQueue.ae(t.o);
+        GlobalQueue.ce !== null && GlobalQueue.ce(t.o);
     }
 }
 
@@ -3116,13 +3157,13 @@ function cleanupCompletedLanes(e) {
     const t = resolveLane(e);
     if (t) {
         t.u.delete(e);
-        GlobalQueue.ae !== null && GlobalQueue.ae(t.o);
+        GlobalQueue.ce !== null && GlobalQueue.ce(t.o);
     }
 }
 
 function trackOptimisticStore(e) {
     // After initTransition, globalQueue._batch IS activeTransition (same reference)
-    globalQueue.D.G.add(e);
+    globalQueue.m.V.add(e);
     schedule();
 }
 
@@ -3131,19 +3172,19 @@ function trackOptimisticStore(e) {
  * create optimistic state (verdict.ts at module top level, createOptimistic
  * and createOptimisticStore at first call) BEFORE any optimistic node exists.
  */ function installOptimisticEngine() {
-    if (GlobalQueue.Re !== null) return;
-    GlobalQueue.Re = optimisticWrite;
-    GlobalQueue.pe = resolveOptimisticNodes;
-    GlobalQueue.Ie = transitionBlocked;
-    GlobalQueue.Ae = cleanupCompletedLanes;
-    GlobalQueue.he = runLaneEffects;
-    GlobalQueue.Ne = gatedRead;
-    GlobalQueue.ye = laneSuspends;
-    GlobalQueue.Pe = laneReadsCommitted;
-    GlobalQueue.Ce = recomputeLane;
-    GlobalQueue.ge = laneAsyncPending;
-    GlobalQueue.be = laneAsyncSettled;
-    GlobalQueue.De = trackOptimisticStore;
+    if (GlobalQueue.pe !== null) return;
+    GlobalQueue.pe = optimisticWrite;
+    GlobalQueue.Ie = resolveOptimisticNodes;
+    GlobalQueue.Ae = transitionBlocked;
+    GlobalQueue.he = cleanupCompletedLanes;
+    GlobalQueue.Ne = runLaneEffects;
+    GlobalQueue.ye = gatedRead;
+    GlobalQueue.Pe = laneSuspends;
+    GlobalQueue.Ce = laneReadsCommitted;
+    GlobalQueue.ge = recomputeLane;
+    GlobalQueue.be = laneAsyncPending;
+    GlobalQueue.De = laneAsyncSettled;
+    GlobalQueue.we = trackOptimisticStore;
 }
 
 /**
@@ -3200,13 +3241,13 @@ function collectPendingSources(e) {
  * (`_pendingObserver`) are skipped so an `isPending` wrapper memo never
  * inherits the coverage it reports on.
  */ function markWalk(e, t) {
-    if (e.k) return true;
+    if (e.W) return true;
     // A real error outranks an inherited mark (A16/A24c): an errored node
     // answers probes with its error, not a coverage verdict, and coverage does
     // not flow through it — matching the rails' behavior, where propagation
     // stopped at errored nodes. A DIRECT mark on an errored node still reads
     // pending (the count check above), also matching.
-        if (e.Qe & STATUS_ERROR) return false;
+        if (e.xe & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
     const n = e.Be;
@@ -3216,7 +3257,7 @@ function collectPendingSources(e) {
     // pass's dependency set — walking past it would read dropped deps and
     // latch a stale verdict on the companion.
         const r = e;
-    const i = r.Ge & REACTIVE_RECOMPUTING_DEPS ? r.ut : undefined;
+    const i = r.D & REACTIVE_RECOMPUTING_DEPS ? r.ut : undefined;
     if (i !== null) {
         for (let e = r.Ke ?? null; e !== null; e = e.Ye) {
             if (!e._t && markWalk(e.qe, t)) return true;
@@ -3239,12 +3280,12 @@ function quietPending(e) {
 }
 
 function newQuestionInFlight(e) {
-    return !!(e.Qe & STATUS_PENDING) && !(e.Qe & STATUS_UNINITIALIZED) && !quietPending(e);
+    return !!(e.xe & STATUS_PENDING) && !(e.xe & STATUS_UNINITIALIZED) && !quietPending(e);
 }
 
 function computePendingState(e) {
     const t = e;
-    if (t.Ge & REACTIVE_DISPOSED) return false;
+    if (t.D & REACTIVE_DISPOSED) return false;
     // Mark coverage is transitive by dep-graph reachability: a latest() shadow
     // reaches its owner (and a store leaf its firewall) through its own deps,
     // so the one walk covers direct marks, derivation, and companion chains.
@@ -3255,11 +3296,11 @@ function computePendingState(e) {
         const n = t.Be || t;
         return newQuestionInFlight(n);
     }
-    if (n && e.U !== NOT_PENDING && !hasActiveOverride(e)) {
-        return !!(n.Ge & REACTIVE_MANUAL_WRITE) || !n.lt && !(n.Qe & STATUS_PENDING) || !!(n.Qe & STATUS_PENDING) && quietPending(n);
+    if (n && e.k !== NOT_PENDING && !hasActiveOverride(e)) {
+        return !!(n.D & REACTIVE_MANUAL_WRITE) || !n.lt && !(n.xe & STATUS_PENDING) || !!(n.xe & STATUS_PENDING) && quietPending(n);
     }
-    if (e.U !== NOT_PENDING && !(t.Qe & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.ht || !e.ht(e.U, unwrapOverride(e.A));
+    if (e.k !== NOT_PENDING && !(t.xe & STATUS_UNINITIALIZED)) {
+        if (hasActiveOverride(e)) return !e.ht || !e.ht(e.k, unwrapOverride(e.A));
         return true;
     }
     return newQuestionInFlight(t);
@@ -3298,7 +3339,7 @@ function updateChildCompanions(e) {
         if (r.has(e)) return;
         r.add(e);
         if (e._ || e.R) n(e);
-        for (let t = e.V; t !== null; t = t.Le) visit(t.Ve);
+        for (let t = e.U; t !== null; t = t.Ge) visit(t.Ve);
         for (let t = e.rt ?? null; t !== null; t = t.it) {
             visit(t);
         }
@@ -3310,18 +3351,18 @@ function snapCompanionsToState(e) {
     const t = e._;
     if (t && (t.A === undefined || t.A === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.We !== n || t.U !== NOT_PENDING) {
+        if (t.We !== n || t.k !== NOT_PENDING) {
             t.We = n;
-            t.U = NOT_PENDING;
-            t.F = clock;
+            t.k = NOT_PENDING;
+            t.H = clock;
             insertSubs(t);
             schedule();
         }
     }
     const n = e.R;
-    if (n && !(n.Ge & REACTIVE_DISPOSED)) {
-        if ((n.A === undefined || n.A === NOT_PENDING) && n.U === NOT_PENDING && !Object.is(n.We, e.We) && !(n.Ge & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
-            n.Ge |= REACTIVE_DIRTY;
+    if (n && !(n.D & REACTIVE_DISPOSED)) {
+        if ((n.A === undefined || n.A === NOT_PENDING) && n.k === NOT_PENDING && !Object.is(n.We, e.We) && !(n.D & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+            n.D |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
             schedule();
@@ -3362,18 +3403,18 @@ 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.ze >= e.P && !(t.Ge & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.ze >= e.P && !(t.D & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             prepareComputed(t, true);
         }
         i = read(t);
     } catch (t) {
-        if (t instanceof NotReadyError && (!context || !(e.Qe & STATUS_UNINITIALIZED))) return r;
+        if (t instanceof NotReadyError && (!context || !(e.xe & STATUS_UNINITIALIZED))) return r;
         throw t;
     } finally {
         setLatestReadActive(n);
     }
-    if (t.Qe & STATUS_PENDING) return r;
+    if (t.xe & STATUS_PENDING) return r;
     if (stale && currentOptimisticLane && t.i) {
         const e = findLane(t.i);
         const n = findLane(currentOptimisticLane);
@@ -3385,18 +3426,18 @@ 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.U !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.T && activeTransition !== t.T)) return t.U;
+        if (t.k !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.T && activeTransition !== t.T)) return t.k;
     return i;
 }
 
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, r) {
     setPendingCheckActive(false);
     if (typeof e.ke === "function") prepareComputed(e, true);
-    const i = n.Qe;
+    const i = n.xe;
     if (t && i & STATUS_PENDING && i & STATUS_UNINITIALIZED) {
         if (tracking && e !== t) link(e, t);
         setPendingCheckActive(true);
-        throw n.we;
+        throw n.me;
     }
     collectPendingSources(e);
     if (r) collectPendingSources(r);
@@ -3404,11 +3445,11 @@ function getLatestValueComputed(e) {
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e.U !== NOT_PENDING && t === e.U) pendingProbe.freshReads.add(e);
+    if (pendingProbe !== null && e.k !== NOT_PENDING && t === e.k) pendingProbe.freshReads.add(e);
 }
 
 function applyReask(e, t) {
-    const n = !!(e.Qe & STATUS_PENDING);
+    const n = !!(e.xe & STATUS_PENDING);
     const r = t && !(n && !e.Nt);
     const i = n && e.Nt !== r;
     e.Nt = r;
@@ -3451,7 +3492,7 @@ function isPending(e) {
     } catch (e) {
         collectPending();
         if (e instanceof NotReadyError) {
-            const t = !!(e.source?.Qe & STATUS_UNINITIALIZED);
+            const t = !!(e.source?.xe & STATUS_UNINITIALIZED);
             if (r.found && !t) return true;
             if (context && t) throw e;
         }
@@ -3465,25 +3506,25 @@ 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.le = syncCompanions;
+GlobalQueue.ae = syncCompanions;
 
-GlobalQueue.ae = updatePendingSignal;
+GlobalQueue.ce = updatePendingSignal;
 
-GlobalQueue.ce = updateChildCompanions;
+GlobalQueue.fe = updateChildCompanions;
 
-GlobalQueue.fe = snapCompanionsToState;
+GlobalQueue.Ee = snapCompanionsToState;
 
-GlobalQueue.Ee = latestRead;
+GlobalQueue.de = latestRead;
 
-GlobalQueue.de = pendingCheckRead;
+GlobalQueue.Se = pendingCheckRead;
 
-GlobalQueue.Se = recordFreshRead;
+GlobalQueue.Te = recordFreshRead;
 
-GlobalQueue.Te = applyReask;
+GlobalQueue.Oe = applyReask;
 
-GlobalQueue.Oe = repollDownstreamVerdicts;
+GlobalQueue._e = repollDownstreamVerdicts;
 
-GlobalQueue._e = witnessAffects;
+GlobalQueue.Re = witnessAffects;
 
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
@@ -3498,8 +3539,8 @@ GlobalQueue._e = witnessAffects;
 
 function notifyEffectStatus(e, t) {
     // Use passed values if provided, otherwise read from node
-    const n = e !== undefined ? e : this.Qe;
-    const r = t !== undefined ? t : this.we;
+    const n = e !== undefined ? e : this.xe;
+    const r = t !== undefined ? t : this.me;
     if (n & STATUS_ERROR) {
         this.Ze.notify(this, STATUS_PENDING, 0);
         if (this.Fe === EFFECT_USER) {
@@ -3512,8 +3553,8 @@ function notifyEffectStatus(e, t) {
             // phase takes the success arm instead. Blocked forwards (explicit
             // `status` arg without node-state writes) don't queue: the status
             // re-propagates unblocked at commit.
-            if (this.Qe & STATUS_ERROR) {
-                this.xe = true;
+            if (this.xe & STATUS_ERROR) {
+                this.Qe = true;
                 this.Ze.enqueue(this.Fe, this.Ct ??= runEffect.bind(null, this));
             }
             return;
@@ -3528,7 +3569,7 @@ function notifyEffectStatus(e, t) {
 }
 
 function runEffect(e) {
-    if (!e.xe || e.Ge & REACTIVE_DISPOSED) return;
+    if (!e.Qe || e.D & REACTIVE_DISPOSED) return;
     // Error arm (#2840), user effects only: a compute-phase error that is still
     // the node's settled state at effect time runs the bundle's error handler in
     // this same imperative, writable scope. Unwrap the StatusError used for
@@ -3539,10 +3580,10 @@ function runEffect(e) {
     // Render effects bypass: their errors route to boundaries synchronously in
     // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
     // same flush must not be hijacked by a later-arriving error status.
-        if (e.Qe & STATUS_ERROR && e.Fe === EFFECT_USER) {
-        const t = unwrapStatusError(e.we);
+        if (e.xe & STATUS_ERROR && e.Fe === EFFECT_USER) {
+        const t = unwrapStatusError(e.me);
         e.bt = e.We;
-        e.xe = false;
+        e.Qe = false;
         try {
             e.wt ? e.wt(t, () => {
                 const t = e.Et;
@@ -3566,19 +3607,19 @@ function runEffect(e) {
         // The final cleanup is invoked by disposeChildren at true disposal.
                 e.Et = n;
     } catch (t) {
-        e.we = new StatusError(e, t);
-        e.Qe |= STATUS_ERROR;
+        e.me = new StatusError(e, t);
+        e.xe |= STATUS_ERROR;
         if (!e.Ze.notify(e, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(t);
             throw t;
         }
     } finally {
         e.bt = e.We;
-        e.xe = false;
+        e.Qe = false;
     }
 }
 
-GlobalQueue.ee = runEffect;
+GlobalQueue.te = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -3586,9 +3627,9 @@ GlobalQueue.ee = runEffect;
  * Uses stale reads.
  */ function trackedEffect(e, t) {
     const run = () => {
-        if (!n.xe || n.Ge & REACTIVE_DISPOSED) return;
+        if (!n.Qe || n.D & REACTIVE_DISPOSED) return;
         try {
-            n.xe = false;
+            n.Qe = false;
             recompute(n);
         } finally {}
     };
@@ -3604,13 +3645,13 @@ GlobalQueue.ee = runEffect;
     });
     n.Et = undefined;
     n.Ue = n.Ue & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    n.xe = true;
+    n.Qe = true;
     n.Fe = EFFECT_TRACKED;
     n.yt = (e, t) => {
-        const r = e !== undefined ? e : n.Qe;
+        const r = e !== undefined ? e : n.xe;
         if (r & STATUS_ERROR) {
             n.Ze.notify(n, STATUS_PENDING, 0);
-            const e = t !== undefined ? t : n.we;
+            const e = t !== undefined ? t : n.me;
             if (!n.Ze.notify(n, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(unwrapStatusError(e));
                 throw e;
@@ -3695,11 +3736,11 @@ function restoreTransition(e, t) {
         const i = e(...t);
         globalQueue.initTransition();
         let o = activeTransition;
-        o.$.push(i);
+        o.j.push(i);
         const done = (e, t, s = false) => {
             o = currentTransition(o);
-            const u = o.$.indexOf(i);
-            if (u >= 0) o.$.splice(u, 1);
+            const u = o.j.indexOf(i);
+            if (u >= 0) o.j.splice(u, 1);
             // Re-adopt through initTransition like every other resumption site:
             // a bare setActiveTransition leaves globalQueue._batch as a detached
             // ambient batch, and anything registered before the scheduled flush
@@ -4016,7 +4057,7 @@ function createEffect(e, t, n) {
             // route through the inherited queue.
             const i = getOwner();
             const o = new MicrotaskQueue;
-            o.B = i.Ze;
+            o.Z = i.Ze;
  // notify() forwards up the normal chain
                         i.Ze = o;
             // A user effect rather than a bare computed: computeds are pull-based and
@@ -5287,7 +5328,7 @@ function ownEnumerableKeysPlain(e) {
  * The value a store leaf's backing signal currently shows to readers: active
  * override, else held pending value, else committed value.
  */ function visibleNodeValue(e) {
-    return e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.U !== NOT_PENDING ? e.U : e.We;
+    return e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.k !== NOT_PENDING ? e.k : e.We;
 }
 
 function hasOwnStoreProperty(e, t) {
@@ -5342,7 +5383,7 @@ function getNode(e, t, n, r, i = isEqual, o) {
     }
     if (o && n in o) {
         const e = o[n];
-        s.ve = e === undefined ? NO_SNAPSHOT : e;
+        s.Le = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources?.add(s);
     }
     if (typeof n === "symbol" && n !== $TRACK && n !== $AFFECTS) symbolKeyedRecords.add(t);
@@ -5371,8 +5412,8 @@ function getNode(e, t, n, r, i = isEqual, o) {
  */ function inheritAffectsMarks(e, t, n) {
     // A live scope exists, so affects.ts already installed the mark engine.
     for (const [r, i] of affectsScopes) {
-        if (r.k && i.scope.has(t) && (i.key === undefined || i.key === n)) {
-            GlobalQueue.ie(e);
+        if (r.W && i.scope.has(t) && (i.key === undefined || i.key === n)) {
+            GlobalQueue.oe(e);
             i.inherited.push(e);
         }
     }
@@ -5460,11 +5501,11 @@ i) {
     // Callers guard on `pendingCheckActive`, which only flips inside
     // isPending() — the verdict layer is loaded and its hook installed.
     const n = e[STORE_NODE]?.[$AFFECTS];
-    if (n?.k) GlobalQueue._e(n);
+    if (n?.W) GlobalQueue.Re(n);
     if (affectsScopes.size) {
         const r = e[STORE_VALUE];
         for (const [e, i] of affectsScopes) {
-            if (e !== n && e.k && i.scope.has(r) && (i.key === undefined || i.key === t)) GlobalQueue._e(e);
+            if (e !== n && e.W && i.scope.has(r) && (i.key === undefined || i.key === t)) GlobalQueue.Re(e);
         }
     }
 }
@@ -5481,11 +5522,11 @@ i) {
  * @internal
  */ function getStoreAffectsNodes(e, t) {
     const n = getNodes(e, STORE_NODE);
-    GlobalQueue.ne ||= e => {
+    GlobalQueue.re ||= e => {
         const t = affectsScopes.get(e);
         if (!t) return;
         affectsScopes.delete(e);
-        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.oe(t.inherited[e]);
+        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.se(t.inherited[e]);
     };
     if (t === undefined) {
         const t = getNode(e, n, $AFFECTS, undefined, false);
@@ -5612,7 +5653,7 @@ function prepareStoreWrite(e, t, n) {
     }
     const r = e[STORE_VALUE];
     const i = r[n];
-    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.Qe ?? 0) & STATUS_PENDING)) {
+    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.xe ?? 0) & STATUS_PENDING)) {
         if (!e[STORE_SNAPSHOT_PROPS]) {
             e[STORE_SNAPSHOT_PROPS] = Object.create(null);
             snapshotSources?.add(e);
@@ -5640,7 +5681,7 @@ function prepareStoreWrite(e, t, n) {
     // STORE_OPTIMISTIC is only set by createOptimisticStore, which installs the
     // optimistic engine before wrapping.
     if (e[STORE_OPTIMISTIC] && !projectionWriteActive) {
-        GlobalQueue.De(t);
+        GlobalQueue.we(t);
     }
 }
 
@@ -5735,8 +5776,8 @@ let Writing = null;
  */ function throwIfUnreadable(e) {
     const t = e[STORE_FIREWALL];
     if (!t) return;
-    const n = t.Qe;
-    if (n & STATUS_ERROR || n & STATUS_UNINITIALIZED && n & STATUS_PENDING) throw t.we ?? new NotReadyError(t);
+    const n = t.xe;
+    if (n & STATUS_ERROR || n & STATUS_UNINITIALIZED && n & STATUS_PENDING) throw t.me ?? new NotReadyError(t);
 }
 
 const storeTraps = {
@@ -6082,7 +6123,7 @@ function createStore(e, t, n) {
  * nothing is stored downstream and nothing can be stranded or stripped by
  * mid-window recomputes.
  */ function markAffects(e) {
-    e.k = (e.k || 0) + 1;
+    e.W = (e.W || 0) + 1;
     shiftAffectsMarks(1);
 }
 
@@ -6098,9 +6139,9 @@ function createStore(e, t, n) {
  * flush that would surface them, before effects run — verdict-only, netting
  * no visual change.
  */ function notifyMarkBoundaries(e) {
-    if (!e.V && !e.rt) return;
+    if (!e.U && !e.rt) return;
     const t = new NotReadyError(e);
-    t.me = true;
+    t.ve = true;
     const n = new Set;
     const visit = e => {
         if (n.has(e)) return;
@@ -6126,10 +6167,10 @@ function createStore(e, t, n) {
  * earlier overlapping registration get covered, and dedup stops re-descent.
  */ function registerAffectsMark(e) {
     markAffects(e);
-    globalQueue.D.L.push(e);
+    globalQueue.m.G.push(e);
     // Companions only exist once the verdict layer (isPending/latest) loaded;
     // without them there is no materialized verdict to poke.
-        GlobalQueue.Oe !== null && GlobalQueue.Oe(e);
+        GlobalQueue._e !== null && GlobalQueue._e(e);
     notifyMarkBoundaries(e);
     schedule();
 }
@@ -6141,10 +6182,10 @@ function createStore(e, t, n) {
  * setSignal would open a fresh override window that nothing settles).
  */ function releaseAffectsMark(e) {
     shiftAffectsMarks(-1);
-    e.k--;
-    if (!e.k) {
-        GlobalQueue.Oe !== null && GlobalQueue.Oe(e, true);
-        GlobalQueue.ne?.(e);
+    e.W--;
+    if (!e.W) {
+        GlobalQueue._e !== null && GlobalQueue._e(e, true);
+        GlobalQueue.re?.(e);
     }
 }
 
@@ -6161,11 +6202,11 @@ function createStore(e, t, n) {
 // Each call site is gated by state only this module creates (a non-empty
 // `_affectsNodes` batch, a live scope in the store's `affectsScopes`), so the
 // hooks are installed before the first time any of them can fire.
-GlobalQueue.re = releaseAffectsMarks;
+GlobalQueue.ie = releaseAffectsMarks;
 
-GlobalQueue.ie = markAffects;
+GlobalQueue.oe = markAffects;
 
-GlobalQueue.oe = releaseAffectsMark;
+GlobalQueue.se = releaseAffectsMark;
 
 function affects(e, t) {
     const n = e?.[$TARGET];
@@ -6186,8 +6227,8 @@ function createOptimisticStore(e, t, n) {
     // STORE_OPTIMISTIC take the engine's write path, so install it before any
     // node can be created.
     installOptimisticEngine();
-    if (!GlobalQueue.te) {
-        GlobalQueue.te = clearOptimisticStores;
+    if (!GlobalQueue.ne) {
+        GlobalQueue.ne = clearOptimisticStores;
         // Store half of the engine's override blockage (#2951): signal-form
         // createOptimistic carries the pending async and the override on ONE node,
         // so transitionBlocked sees both; a derived optimistic STORE splits them —
@@ -6198,10 +6239,10 @@ function createOptimisticStore(e, t, n) {
         // clobbering instead of composing). Optimistic state clears when truth
         // lands or its transaction ends — never mid-refetch. Wrapped here (engine
         // is already installed above) so store-free apps never carry the check.
-                const e = GlobalQueue.Ie;
-        GlobalQueue.Ie = t => {
-            for (const e of t.G) {
-                if ((e[$TARGET]?.[STORE_FIREWALL]?.Qe ?? 0) & STATUS_PENDING) return true;
+                const e = GlobalQueue.Ae;
+        GlobalQueue.Ae = t => {
+            for (const e of t.V) {
+                if ((e[$TARGET]?.[STORE_FIREWALL]?.xe ?? 0) & STATUS_PENDING) return true;
             }
             return e(t);
         };
@@ -6285,7 +6326,7 @@ function clearOptimisticStores(e, t) {
                 const o = visibleNodeValue(a);
                 a.A = NOT_PENDING;
                 a.p = null;
-                a.U = NOT_PENDING;
+                a.k = NOT_PENDING;
                 a.We = i;
                 if (!a.ht || !a.ht(o, i)) {
                     insertSubs(a, true);
@@ -6798,8 +6839,8 @@ function mapArray(e, t, n) {
         kt: [],
         Wt: [],
         Ft: r,
-        xt: r || n?.keyed === false ? [] : undefined,
-        Qt: i && n?.keyed !== false ? [] : undefined,
+        Qt: r || n?.keyed === false ? [] : undefined,
+        xt: i && n?.keyed !== false ? [] : undefined,
         Ht: n?.keyed === false,
         Mt: n?.fallback
     };
@@ -6832,14 +6873,14 @@ function updateKeyedMap() {
         let n, r, i, o, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        s = this.xt ? this.Ht ? () => {
+        s = this.Qt ? this.Ht ? () => {
             i[r] = signal(e[r], pureOptions);
             return this.Ut(accessor(i[r]), r);
         } : () => {
             i[r] = signal(e[r], pureOptions);
             o && (o[r] = signal(r, pureOptions));
             return this.Ut(accessor(i[r]), o ? accessor(o[r]) : undefined);
-        } : this.Qt ? () => {
+        } : this.xt ? () => {
             const t = e[r];
             o[r] = signal(r, pureOptions);
             return this.Ut(t, accessor(o[r]));
@@ -6855,8 +6896,8 @@ function updateKeyedMap() {
                 this.Vt = [];
                 this.kt = [];
                 this.Lt = 0;
-                this.xt && (this.xt = []);
                 this.Qt && (this.Qt = []);
+                this.xt && (this.xt = []);
             }
             if (this.Mt && !this.kt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
@@ -6869,8 +6910,8 @@ function updateKeyedMap() {
          else if (this.Lt === 0) {
             const u = new Array(t);
             const l = new Array(t);
-            i = this.xt && new Array(t);
-            o = this.Qt && new Array(t);
+            i = this.Qt && new Array(t);
+            o = this.xt && new Array(t);
             try {
                 for (r = 0; r < t; r++) u[r] = runWithOwner(l[r] = createOwner(), s);
             } catch (e) {
@@ -6882,19 +6923,19 @@ function updateKeyedMap() {
  // previous fallback
                         this.kt = u;
             this.Wt = l;
-            i && (this.xt = i);
-            o && (this.Qt = o);
+            i && (this.Qt = i);
+            o && (this.xt = o);
             this.Vt = e.slice(0);
             this.Lt = t;
         } else {
             let u, l, a, c, f, E, d, S, T;
             // skip common prefix
-                        for (u = 0, l = Math.min(this.Lt, t); u < l && (this.Vt[u] === e[u] || this.xt && compare(this.Ft, this.Vt[u], e[u])); u++) {
-                if (this.xt) setSignal(this.xt[u], e[u]);
+                        for (u = 0, l = Math.min(this.Lt, t); u < l && (this.Vt[u] === e[u] || this.Qt && compare(this.Ft, this.Vt[u], e[u])); u++) {
+                if (this.Qt) setSignal(this.Qt[u], e[u]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (l = this.Lt - 1, a = t - 1; l >= u && a >= u && (this.Vt[l] === e[a] || this.xt && compare(this.Ft, this.Vt[l], e[a])); l--, 
+                        for (l = this.Lt - 1, a = t - 1; l >= u && a >= u && (this.Vt[l] === e[a] || this.Qt && compare(this.Ft, this.Vt[l], e[a])); l--, 
             a--) ;
             // no structural change (every position matched in place at equal
             // length — the common post-reconcile shape): keep the same mapped
@@ -6906,8 +6947,8 @@ function updateKeyedMap() {
             const O = t - this.Lt;
             const _ = new Array(t);
             const R = new Array(t);
-            i = this.xt ? new Array(t) : undefined;
-            o = this.Qt ? new Array(t) : undefined;
+            i = this.Qt ? new Array(t) : undefined;
+            o = this.xt ? new Array(t) : undefined;
             // 0) prepare a map of all indices in the changed window of newItems,
             // scanning backwards so we encounter them in natural order
                         E = new Map;
@@ -6929,8 +6970,8 @@ function updateKeyedMap() {
                 if (r !== undefined && r !== -1) {
                     _[r] = this.kt[n];
                     R[r] = this.Wt[n];
-                    i && (i[r] = this.xt[n]);
-                    o && (o[r] = this.Qt[n]);
+                    i && (i[r] = this.Qt[n]);
+                    o && (o[r] = this.xt[n]);
                     r = d[r];
                     E.set(f, r);
                 } else (S ??= []).push(this.Wt[n]);
@@ -6952,8 +6993,8 @@ function updateKeyedMap() {
                         for (n = 0; n < u; n++) {
                 _[n] = this.kt[n];
                 R[n] = this.Wt[n];
-                i && (i[n] = this.xt[n]);
-                o && (o[n] = this.Qt[n]);
+                i && (i[n] = this.Qt[n]);
+                o && (o[n] = this.xt[n]);
             }
             for (r = u; r <= a; r++) {
                 if (i) setSignal(i[r], e[r]);
@@ -6963,18 +7004,18 @@ function updateKeyedMap() {
                 _[r] = this.kt[r - O];
                 R[r] = this.Wt[r - O];
                 if (i) {
-                    i[r] = this.xt[r - O];
+                    i[r] = this.Qt[r - O];
                     setSignal(i[r], e[r]);
                 }
                 if (o) {
-                    o[r] = this.Qt[r - O];
+                    o[r] = this.xt[r - O];
                     if (O !== 0) setSignal(o[r], r);
                 }
             }
             this.kt = _;
             this.Wt = R;
-            i && (this.xt = i);
-            o && (this.Qt = o);
+            i && (this.Qt = i);
+            o && (this.xt = o);
             this.Lt = t;
             // save a copy of the mapped items for the next update
                         this.Vt = e.slice(0);
@@ -7089,12 +7130,12 @@ function boundaryComputed(e, t) {
     });
     n.yt = (e, t) => {
         // Use passed values if provided, otherwise read from node
-        const r = e !== undefined ? e : n.Qe;
-        const i = t !== undefined ? t : n.we;
+        const r = e !== undefined ? e : n.xe;
+        const i = t !== undefined ? t : n.me;
         // Notify both status dimensions like a render effect does; the queue chain
         // consumes this boundary's own type and forwards the remainder upward until
         // a boundary that handles it is found.
-                n.Qe &= ~n.Yt;
+                n.xe &= ~n.Yt;
         const o = n.Ze.notify(n, STATUS_PENDING | STATUS_ERROR, r, i);
         // The queue is the only propagation channel: a foreign status must not stay
         // reader-visible on the tree, or reads re-throw it across the boundary and
@@ -7102,8 +7143,8 @@ function boundaryComputed(e, t) {
         // untouched, so the tree still recomputes when the foreign source settles.
                 const s = r & ~n.Yt & (STATUS_PENDING | STATUS_ERROR);
         if (s) {
-            n.Qe &= ~s;
-            if (n.we === i && !(n.Qe & (STATUS_PENDING | STATUS_ERROR))) n.we = undefined;
+            n.xe &= ~s;
+            if (n.me === i && !(n.xe & (STATUS_PENDING | STATUS_ERROR))) n.me = undefined;
         }
         // An ERROR the chain could not deliver to any boundary is uncaught. The
         // scrub above already removed it from reader-visible state, so without
@@ -7306,7 +7347,7 @@ class CollectionQueue extends Queue {
         ownedWrite: true,
         gt: true
     });
-    we;
+    me;
     Jt=signal(false, {
         ownedWrite: true,
         gt: true
@@ -7352,13 +7393,13 @@ class CollectionQueue extends Queue {
                 if (this.Tn & STATUS_PENDING && this.rn) return super.notify(e, t, n, r);
         if (n & this.Tn) {
             this.Zt = true;
-            const t = r?.source || e.we?.source;
+            const t = r?.source || e.me?.source;
             if (t) {
                 const e = this.Bt.size === 0;
                 this.Bt.add(t);
                 if (e) setSignal(this.zt, true);
                 if (this.Tn & STATUS_ERROR) {
-                    setSignal(this.we, unwrapStatusError(t.we));
+                    setSignal(this.me, unwrapStatusError(t.me));
                 }
             }
         }
@@ -7371,11 +7412,11 @@ class CollectionQueue extends Queue {
             // mark's lifetime (the visual channel): the marked node carries no
             // status of its own, so the count is the liveness test. The release
             // sweep (finalizePureQueue after mark release) re-runs this check.
-            if (e.Ge & REACTIVE_DISPOSED || !e.k && !(e.Qe & this.Tn) && !(this.Tn & STATUS_ERROR && e.Qe & STATUS_PENDING)) this.Bt.delete(e);
+            if (e.D & REACTIVE_DISPOSED || !e.W && !(e.xe & this.Tn) && !(this.Tn & STATUS_ERROR && e.xe & STATUS_PENDING)) this.Bt.delete(e);
         }
         if (!this.Bt.size) {
             if (this.Tn & STATUS_PENDING && this.Zt && !this.rn && this.On) {
-                this.Zt = !!(this.On.Qe & this.Tn);
+                this.Zt = !!(this.On.xe & this.Tn);
             } else {
                 this.Zt = false;
             }
@@ -7397,7 +7438,7 @@ function createCollectionBoundary(e, t, n, r) {
     const i = createOwner();
     if (_revealUsed) setContext(RevealControllerContext, null, i);
     const o = new CollectionQueue(e);
-    if (e === STATUS_ERROR) o.we = signal(undefined, {
+    if (e === STATUS_ERROR) o.me = signal(undefined, {
         ownedWrite: true,
         gt: true
     });
@@ -7411,7 +7452,7 @@ function createCollectionBoundary(e, t, n, r) {
         } catch (e) {
             if (e instanceof NotReadyError) t = true; else throw e;
         }
-        o.Zt = t || !!(s.Qe & e) || s.we instanceof NotReadyError;
+        o.Zt = t || !!(s.xe & e) || s.me instanceof NotReadyError;
     });
     const u = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (u) {
@@ -7488,7 +7529,7 @@ function createCollectionBoundary(e, t, n, r) {
  * }
  * ```
  */ function createErrorBoundary(e, t) {
-    return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e.we), () => {
+    return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e.me), () => {
         for (const t of e.Bt) recompute(t);
         schedule();
     }));