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

package/dist/prod/core/core.js

@@ -1,6 +1,6 @@
 import { handleAsync, clearStatus, notifyStatus } from "./async.js";
 
-import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, STATUS_UNINITIALIZED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, STATUS_PENDING, STATUS_ERROR, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, OVERRIDE_UNDEFINED, CONFIG_AUTO_DISPOSE, REACTIVE_LAZY, REACTIVE_DISPOSED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, $REFRESH, REACTIVE_MANUAL_WRITE, NO_SNAPSHOT, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
+import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, STATUS_UNINITIALIZED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, STATUS_PENDING, STATUS_ERROR, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, OVERRIDE_UNDEFINED, REACTIVE_LAZY, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, $REFRESH, REACTIVE_MANUAL_WRITE, NO_SNAPSHOT, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -8,15 +8,15 @@ import { trimStaleDeps, link, unobserved } from "./graph.js";
 
 import { deleteFromHeap, queueFor, insertIntoHeapHeight, markNode, markHeap, insertIntoHeap } from "./heap.js";
 
-import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, queuePendingNode, activeAffectsMarks, runInTransition, schedule, dirtyQueue, projectionWriteActive, armReaskClear } from "./scheduler.js";
+import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, queuePendingNode, runInTransition, schedule, dirtyQueue, projectionWriteActive, armReaskClear } from "./scheduler.js";
 
 import "./invariants.js";
 
 import { disposeChildren, markDisposal, inheritId } from "./owner.js";
 
-GlobalQueue.Ce = recompute;
+GlobalQueue.pe = recompute;
 
-GlobalQueue.Oe = disposeChildren;
+GlobalQueue.Ce = disposeChildren;
 
 let tracking = false;
 
@@ -42,25 +42,14 @@ let context = null;
 
 let currentOptimisticLane = null;
 
-/**
- * Marked sources read by the recompute currently on the stack (saved/restored
- * per recompute, like `context`). A computed that reads a node with a live
- * `affects()` mark inherits the mark's pendingness — `recompute` applies the
- * collected sources through `applyAffectsReads` after its commit, because the
- * `clearStatus` at the top of the commit path wipes whatever sentinel entries
- * the node held from the registration-time push. This is the pull half of
- * mark propagation (real async re-establishes itself by re-throwing on read;
- * marks are value-transparent, so they re-establish here instead).
- */ let affectsReads = null;
-
 let snapshotCaptureActive = false;
 
 let snapshotSources = null;
 
 function ownerInSnapshotScope(e) {
     while (e) {
-        if (e.ke) return true;
-        e = e.Fe;
+        if (e.Oe) return true;
+        e = e.Ge;
     }
     return false;
 }
@@ -71,41 +60,41 @@ function setSnapshotCapture(e) {
 }
 
 function markSnapshotScope(e) {
-    e.ke = true;
+    e.Oe = true;
 }
 
 function releaseSnapshotScope(e) {
-    e.ke = false;
+    e.Oe = false;
     releaseSubtree(e);
     schedule();
 }
 
 function releaseSubtree(e) {
-    let t = e.He;
+    let t = e.me;
     while (t) {
-        if (t.ke) {
-            t = t.Ve;
+        if (t.Oe) {
+            t = t.ve;
             continue;
         }
-        if (t.xe) {
+        if (t.ke) {
             const e = t;
-            e.U &= ~CONFIG_IN_SNAPSHOT_SCOPE;
-            if (e.u & REACTIVE_SNAPSHOT_STALE) {
-                e.u &= ~REACTIVE_SNAPSHOT_STALE;
-                e.u |= REACTIVE_DIRTY;
-                if (dirtyQueue.Le > e.qe) dirtyQueue.Le = e.qe;
+            e.T &= ~CONFIG_IN_SNAPSHOT_SCOPE;
+            if (e.se & REACTIVE_SNAPSHOT_STALE) {
+                e.se &= ~REACTIVE_SNAPSHOT_STALE;
+                e.se |= REACTIVE_DIRTY;
+                if (dirtyQueue.Fe > e.He) dirtyQueue.Fe = e.He;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
         releaseSubtree(t);
-        t = t.Ve;
+        t = t.ve;
     }
 }
 
 function clearSnapshots() {
     if (snapshotSources) {
         for (const e of snapshotSources) {
-            delete e.Ye;
+            delete e.Ve;
             delete e[STORE_SNAPSHOT_PROPS];
         }
         snapshotSources = null;
@@ -114,105 +103,109 @@ function clearSnapshots() {
 }
 
 function recompute(e, t = false) {
-    const n = e.De;
+    const n = e.Ae;
     if (!t) {
-        if (e.ve && (!n || activeTransition) && activeTransition !== e.ve) globalQueue.initTransition(e.ve);
+        if (e.Ue && (!n || activeTransition) && activeTransition !== e.Ue) globalQueue.initTransition(e.Ue);
         deleteFromHeap(e, queueFor(e));
-        e.Ae = null;
+        e.Te = null;
         // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
-                if (e.ve || n === EFFECT_TRACKED) disposeChildren(e); else if (e.He !== null || e.Me !== null) {
+                if (e.Ue || n === EFFECT_TRACKED) disposeChildren(e); else if (e.me !== null || e.xe !== null) {
             markDisposal(e);
-            e.We = e.Me;
-            e.Ze = e.He;
-            e.Me = null;
-            e.He = null;
-            e.je = 0;
+            e.ye = e.xe;
+            e.Le = e.me;
+            e.xe = null;
+            e.me = null;
+            e.Qe = 0;
         } else ;
     }
-    let i = !!(e.u & REACTIVE_OPTIMISTIC_DIRTY);
-    const l = e.be !== undefined && e.be !== NOT_PENDING;
-    const u = !!(e.i & STATUS_UNINITIALIZED);
+    let i = !!(e.se & REACTIVE_OPTIMISTIC_DIRTY);
+    const l = e.Ee !== undefined && e.Ee !== NOT_PENDING;
+    const u = !!(e.S & STATUS_UNINITIALIZED);
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
-        const s = (e.u & REACTIVE_REASK) !== 0;
-    const o = context;
+        const o = (e.se & REACTIVE_REASK) !== 0;
+    const s = context;
     context = e;
-    e.Ke = null;
-    e.ze++;
-    e.u = REACTIVE_RECOMPUTING_DEPS;
-    e.Ie = clock;
-    let a = e.ge === NOT_PENDING ? e.Ue : e.ge;
-    let r = e.qe;
+    e.qe = null;
+    e.Ye++;
+    e.se = REACTIVE_RECOMPUTING_DEPS;
+    e.ce = clock;
+    let a = e.Ne === NOT_PENDING ? e.Re : e.Ne;
+    let r = e.He;
     let c = tracking;
-    const _ = affectsReads;
-    affectsReads = null;
-    let f = null;
-    let E = currentOptimisticLane;
+    let _ = currentOptimisticLane;
     tracking = true;
+    // A computed's fn establishes its OWN dependencies, so it must never run
+    // inside a latest() read window: read() short-circuits through the
+    // companion path before dependency linking, so a memo created (eagerly
+    // computed) inside latest(fn) came out permanently dependency-less (#2926).
+    // latestRead() already suspends the flag for its pull-recomputes; this
+    // covers creation-time computes and flushes that run inside the window.
+        const E = latestReadActive;
+    latestReadActive = false;
     // Lane posture lives with the engine: OPTIMISTIC_DIRTY is only ever set by
     // engine-driven paths, and _optimisticNodes is only pushed by
     // _optimisticWrite, so the hook is installed whenever either gate holds.
         if (i) {
-        const t = GlobalQueue.$e(e, true);
+        const t = GlobalQueue.We(e, true);
         if (t) currentOptimisticLane = t;
-    } else if (activeTransition && !t && activeTransition.Be.length) {
+    } else if (activeTransition && !t && activeTransition.Ze.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.$e(e, false);
+        const t = GlobalQueue.We(e, false);
         if (t) {
             i = true;
             currentOptimisticLane = t;
         }
     }
-    const N = n && n !== EFFECT_USER;
-    const T = stale;
-    if (N) stale = true;
+    const f = n && n !== EFFECT_USER;
+    const N = stale;
+    if (f) stale = true;
     try {
-        if (!false && e.U & CONFIG_SYNC) {
-            a = e.xe(a);
-            e.Ae = null;
+        if (!false && e.T & CONFIG_SYNC) {
+            a = e.ke(a);
+            e.Te = null;
         } else {
             // Snapshot `_inFlight` so we can detect whether `_fn` self-registered an async
             // subscription (e.g. `createProjection` calls `handleAsync` from inside its body
             // with a setter callback). In that case, the outer `handleAsync` call below would
             // clobber the fresh subscription, so we skip it and let the internally-registered
             // iteration drive updates.
-            const t = e.Ae;
-            const n = e.xe(a);
+            const t = e.Te;
+            const n = e.ke(a);
             const i = typeof n === "object" && n !== null;
-            const l = e.Ae !== t;
+            const l = e.Te !== t;
             a = l || !i ? n : handleAsync(e, n);
-            if (!l && !i) e.Ae = null;
+            if (!l && !i) e.Te = null;
         }
         clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths.
-                if (e.Je) GlobalQueue.Xe(e);
+                if (e.je) GlobalQueue.Me(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.et(e);
+        if (t instanceof NotReadyError && currentOptimisticLane) GlobalQueue.Ke(e);
         let n = false;
         if (t instanceof NotReadyError) {
-            e.Re = true;
-            if (GlobalQueue.tt !== null) n = GlobalQueue.tt(e, s);
+            e.Se = true;
+            if (GlobalQueue.ze !== null) n = GlobalQueue.ze(e, o);
         }
-        notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.Je : undefined);
-        if (n) GlobalQueue.nt(e);
+        notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.je : undefined);
+        if (n) GlobalQueue.k(e);
     } finally {
         tracking = c;
-        if (N) stale = T;
-        e.u = REACTIVE_NONE | (t ? e.u & REACTIVE_SNAPSHOT_STALE : 0);
-        context = o;
-        f = affectsReads;
-        affectsReads = _;
+        latestReadActive = E;
+        if (f) stale = N;
+        e.se = REACTIVE_NONE | (t ? e.se & REACTIVE_SNAPSHOT_STALE : 0);
+        context = s;
     }
-    if (!e.k) {
+    if (!e._) {
         trimStaleDeps(e);
-        const s = l ? unwrapOverride(e.be) : e.ge === NOT_PENDING ? e.Ue : e.ge;
-        let o = false;
+        const o = l ? unwrapOverride(e.Ee) : e.Ne === NOT_PENDING ? e.Re : e.Ne;
+        let s = false;
         try {
-            o = !n && u || !e.Ge || !e.Ge(s, a);
+            s = !n && u || !e.Pe || !e.Pe(o, a);
         } catch (t) {
             // A throwing user comparator is an error of this node's computation.
             // Route it through the same status path as a compute-phase throw so
@@ -225,124 +218,111 @@ function recompute(e, t = false) {
         // its runner — happen here instead. `!create` matches the previous `initialized`
         // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
         // effect() can call its runner synchronously for the first run.
-                if (n && o) {
-            e.it = !e.k;
+                if (n && s) {
+            e.$e = !e._;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
-                        if (!t) e.v.enqueue(n, e.lt ??= GlobalQueue.ut.bind(null, e));
+                        if (!t) e.C.enqueue(n, e.Be ??= GlobalQueue.Je.bind(null, e));
         }
-        if (e.k) ; else if (o) {
-            const u = l ? e.be : undefined;
-            if (t || n && activeTransition !== e.ve || i) {
-                e.Ue = a;
+        if (e._) ; else if (s) {
+            const u = l ? e.Ee : undefined;
+            if (t || n && activeTransition !== e.Ue || i) {
+                e.Re = a;
                 // Lane-propagated correction: upstream data is fresh, correct the
                 // override unconditionally. The direct _value commit is the lane's
                 // own reveal schedule; drop any superseded older hold so its queued
                 // commit can't clobber the fresh value.
                                 if (l && i) {
-                    e.be = a === undefined ? OVERRIDE_UNDEFINED : a;
-                    e.ge = NOT_PENDING;
+                    e.Ee = a === undefined ? OVERRIDE_UNDEFINED : a;
+                    e.Ne = NOT_PENDING;
                 }
             } else {
-                e.ge = a;
+                e.Ne = 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.ve) && GlobalQueue._e !== null) GlobalQueue._e(e, a);
+                                if ((activeTransition || e.Ue) && GlobalQueue.Ie !== null) GlobalQueue.Ie(e, a);
             }
-            if (!l || i || e.be !== u) insertSubs(e, i || l);
+            if (!l || i || e.Ee !== u) insertSubs(e, i || l);
         } else if (l) {
             // 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.ge === NOT_PENDING) queuePendingNode(e);
-            e.ge = a;
-        } else if (e.qe != r) {
-            for (let t = e.p; t !== null; t = t.de) {
-                insertIntoHeapHeight(t.Ee, queueFor(t.Ee));
+            if (e.Ne === NOT_PENDING) queuePendingNode(e);
+            e.Ne = a;
+        } else if (e.He != r) {
+            for (let t = e.o; t !== null; t = t.ue) {
+                insertIntoHeapHeight(t.le, queueFor(t.le));
             }
         }
     }
-    currentOptimisticLane = E;
-    // Marks read during this recompute re-attach after the commit above:
-    // earlier, the sentinel's NotReadyError in `_error` would have routed the
-    // fresh value into the error-skip branch instead of committing it. A real
-    // (non-NotReady) error wins over marks (#2893): applying the sentinel here
-    // would clobber the user's error with a NotReadyError from a node whose
-    // reads value-transparency promises can never throw NotReady.
-    // `markedReads` only collects under a live mark, so the hook is installed.
-        if (f && !(e.i & STATUS_ERROR)) GlobalQueue.j(e, f);
-    // Mark-only pending doesn't queue (#2893): the node holds no value needing
-    // a transition-scheduled commit, and queueing would stamp the marking
-    // action's transaction onto it — freezing unrelated writes that share it.
-    // (Single mask test up front keeps the mark-free hot path at original cost.)
-        const I = e.i & (STATUS_PENDING | STATUS_UNINITIALIZED);
-    const p = e.ge !== NOT_PENDING || e.Ze !== null || e.We !== null || I !== 0 && (I !== STATUS_PENDING || activeAffectsMarks === 0 || !GlobalQueue.$(e));
+    currentOptimisticLane = _;
+    const T = e.Ne !== NOT_PENDING || e.Le !== null || e.ye !== null || (e.S & (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.
-        p && (!t || e.i & STATUS_PENDING) && (!e.ve || l) && queuePendingNode(e);
-    e.ve && n && activeTransition !== e.ve && runInTransition(e.ve, () => recompute(e));
+        T && (!t || e.S & STATUS_PENDING) && (!e.Ue || l) && queuePendingNode(e);
+    e.Ue && n && activeTransition !== e.Ue && runInTransition(e.Ue, () => recompute(e));
 }
 
 function updateIfNecessary(e) {
-    if (e.u & REACTIVE_CHECK) {
-        for (let t = e.S; t; t = t.st) {
-            const n = t.ot;
-            const i = n.rt || n;
-            if (i.xe) {
+    if (e.se & REACTIVE_CHECK) {
+        for (let t = e.Xe; t; t = t.et) {
+            const n = t.tt;
+            const i = n.nt || n;
+            if (i.ke) {
                 updateIfNecessary(i);
             }
-            if (e.u & REACTIVE_DIRTY) {
+            if (e.se & REACTIVE_DIRTY) {
                 break;
             }
         }
     }
-    if (e.u & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.k && e.Ie < clock && !e.Ae) {
+    if (e.se & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e._ && e.ce < clock && !e.Te) {
         recompute(e);
     }
-    e.u = e.u & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
+    e.se = e.se & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
 }
 
 function computed(e, t) {
     const n = t?.transparent ?? false;
     const i = {
         id: inheritId(t, n, context),
-        U: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.re ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Ge: t?.equals != null ? t.equals : isEqual,
-        ct: t?.unobserved,
-        Me: null,
-        v: context?.v ?? globalQueue,
+        T: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.V ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Pe: t?.equals != null ? t.equals : isEqual,
+        it: t?.unobserved,
+        xe: null,
+        C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
-        je: 0,
-        xe: e,
-        Ue: undefined,
-        qe: 0,
-        G: null,
-        _t: undefined,
-        ft: null,
-        S: null,
-        Ke: null,
-        ze: 0,
-        p: null,
-        Et: null,
-        Fe: context,
-        Ve: null,
-        Nt: null,
-        He: null,
-        u: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-        i: STATUS_UNINITIALIZED,
-        Ie: clock,
-        ge: NOT_PENDING,
-        We: null,
-        Ze: null,
-        Ae: null,
+        Qe: 0,
+        ke: e,
+        Re: undefined,
+        He: 0,
+        u: null,
+        lt: undefined,
+        ut: null,
+        Xe: null,
+        qe: null,
+        Ye: 0,
+        o: null,
+        ot: null,
+        Ge: context,
         ve: null,
-        A: false
+        st: null,
+        me: null,
+        se: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+        S: STATUS_UNINITIALIZED,
+        ce: clock,
+        Ne: NOT_PENDING,
+        ye: null,
+        Le: null,
+        Te: null,
+        Ue: null,
+        be: false
     };
     setupComputedNode(i, t);
     return i;
@@ -354,50 +334,50 @@ function computed(e, t) {
  * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
  * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
  */ function createEffectNode(e, t, n, i, l, u) {
-    const s = u?.transparent ?? false;
-    const o = {
-        id: inheritId(u, s, context),
-        U: (s ? CONFIG_TRANSPARENT : 0) | (u?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (u?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Ge: false,
-        ct: u?.unobserved,
-        Me: null,
-        v: context?.v ?? globalQueue,
+    const o = u?.transparent ?? false;
+    const s = {
+        id: inheritId(u, o, context),
+        T: (o ? CONFIG_TRANSPARENT : 0) | (u?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (u?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Pe: false,
+        it: u?.unobserved,
+        xe: null,
+        C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
-        je: 0,
-        xe: e,
-        Ue: undefined,
-        qe: 0,
-        G: null,
-        _t: undefined,
-        ft: null,
-        S: null,
-        Ke: null,
-        ze: 0,
-        p: null,
-        Et: null,
-        Fe: context,
-        Ve: null,
-        Nt: null,
-        He: null,
-        u: REACTIVE_LAZY,
-        i: STATUS_UNINITIALIZED,
-        Ie: clock,
-        ge: NOT_PENDING,
-        We: null,
-        Ze: null,
-        Ae: null,
+        Qe: 0,
+        ke: e,
+        Re: undefined,
+        He: 0,
+        u: null,
+        lt: undefined,
+        ut: null,
+        Xe: null,
+        qe: null,
+        Ye: 0,
+        o: null,
+        ot: null,
+        Ge: context,
         ve: null,
-        A: false,
-        it: false,
-        Tt: undefined,
-        It: t,
-        St: n,
-        dt: undefined,
-        De: i,
-        C: l
+        st: null,
+        me: null,
+        se: REACTIVE_LAZY,
+        S: STATUS_UNINITIALIZED,
+        ce: clock,
+        Ne: NOT_PENDING,
+        ye: null,
+        Le: null,
+        Te: null,
+        Ue: null,
+        be: false,
+        $e: false,
+        rt: undefined,
+        ct: t,
+        _t: n,
+        Et: undefined,
+        Ae: i,
+        i: l
     };
-    setupComputedNode(o, lazyOptions);
-    return o;
+    setupComputedNode(s, lazyOptions);
+    return s;
 }
 
 const lazyOptions = {
@@ -405,24 +385,24 @@ const lazyOptions = {
 };
 
 function setupComputedNode(e, t) {
-    e.ft = e;
-    const n = context?.At ? context.Ct : context;
+    e.ut = e;
+    const n = context?.ft ? context.Nt : context;
     if (context) {
-        const t = context.He;
+        const t = context.me;
         if (t === null) {
-            context.He = e;
+            context.me = e;
         } else {
-            e.Ve = t;
-            t.Nt = e;
-            context.He = e;
+            e.ve = t;
+            t.st = e;
+            context.me = e;
         }
     }
-    if (n) e.qe = n.qe + 1;
-    if (GlobalQueue.Ot !== null) GlobalQueue.Ot(e);
+    if (n) e.He = n.He + 1;
+    if (GlobalQueue.Tt !== null) GlobalQueue.Tt(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
-        if (!(e.i & STATUS_PENDING) && !(e.U & CONFIG_NO_SNAPSHOT)) {
-            e.Ye = e.Ue === undefined ? NO_SNAPSHOT : e.Ue;
+        if (!(e.S & STATUS_PENDING) && !(e.T & CONFIG_NO_SNAPSHOT)) {
+            e.Ve = e.Re === undefined ? NO_SNAPSHOT : e.Re;
             snapshotSources.add(e);
         }
     }
@@ -430,20 +410,20 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const i = {
-        Ge: t?.equals != null ? t.equals : isEqual,
-        U: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.re ? CONFIG_NO_SNAPSHOT : 0),
-        ct: t?.unobserved,
-        Ue: e,
-        p: null,
-        Et: null,
-        Ie: clock,
-        rt: n,
-        Ne: n?.G || null,
-        ge: NOT_PENDING
+        Pe: t?.equals != null ? t.equals : isEqual,
+        T: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.V ? CONFIG_NO_SNAPSHOT : 0),
+        it: t?.unobserved,
+        Re: e,
+        o: null,
+        ot: null,
+        ce: clock,
+        nt: n,
+        fe: n?.u || null,
+        Ne: NOT_PENDING
     };
-    n && (n.G = i);
-    if (snapshotCaptureActive && !(i.U & CONFIG_NO_SNAPSHOT) && !((n?.i ?? 0) & STATUS_PENDING)) {
-        i.Ye = e === undefined ? NO_SNAPSHOT : e;
+    n && (n.u = i);
+    if (snapshotCaptureActive && !(i.T & CONFIG_NO_SNAPSHOT) && !((n?.S ?? 0) & STATUS_PENDING)) {
+        i.Ve = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources.add(i);
     }
     return i;
@@ -451,13 +431,13 @@ function signal(e, t, n = null) {
 
 function optimisticSignal(e, t) {
     const n = signal(e, t);
-    n.be = NOT_PENDING;
+    n.Ee = NOT_PENDING;
     return n;
 }
 
 function optimisticComputed(e, t) {
     const n = computed(e, t);
-    n.be = NOT_PENDING;
+    n.Ee = NOT_PENDING;
     return n;
 }
 
@@ -487,11 +467,11 @@ function isEqual(e, t) {
  * );
  * ```
  */ function untrack(e, t) {
-    if (GlobalQueue.Rt === null && !tracking && true) return e();
+    if (GlobalQueue.It === null && !tracking && true) return e();
     const n = tracking;
     tracking = false;
     try {
-        if (GlobalQueue.Rt !== null) return GlobalQueue.Rt(e);
+        if (GlobalQueue.It !== null) return GlobalQueue.It(e);
         return e();
     } finally {
         tracking = n;
@@ -503,10 +483,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.u & REACTIVE_LAZY) {
-        e.u &= ~REACTIVE_LAZY;
+    if (e.se & REACTIVE_LAZY) {
+        e.se &= ~REACTIVE_LAZY;
         recompute(e, true);
-    } else if (e.u & REACTIVE_DISPOSED) {
+    } else if (e.se & REACTIVE_DISPOSED) {
         recompute(e, true);
     } else if (t) {
         updateIfNecessary(e);
@@ -518,101 +498,78 @@ 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.Gt(e);
+    if (latestReadActive) return GlobalQueue.St(e);
     let t = context;
-    if (t?.At) t = t.Ct;
+    if (t?.ft) t = t.Nt;
     const n = e;
-    const i = e.rt;
+    const i = e.nt;
     const l = i || e;
     // Handle isPending() mode: collect pending state while preserving normal read semantics.
     // Probe mode is suspended while preparing the node so nested reads during a
     // recompute don't collect into the probe.
         if (pendingCheckActive) {
-        GlobalQueue.Pt(e, t, l, i);
-    } else if (typeof n.xe === "function") {
+        GlobalQueue.dt(e, t, l, i);
+    } else if (typeof n.ke === "function") {
         prepareComputed(e, false);
     }
-    if (!n.xe && l === e && e.be === undefined && e.Ye === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
-        if (t && tracking) {
-            link(e, t);
-            // A live mark on a read source flows to the reader (probe reads are
-            // excluded: the probe's own collection owns that verdict, and marking
-            // the enclosing memo would make an `isPending` wrapper itself pending).
-                        if (activeAffectsMarks !== 0 && e.M && !pendingCheckActive) (affectsReads ??= []).push(e);
-        }
-        return !t || e.ge === NOT_PENDING ? e.Ue : e.ge;
+    if (!n.ke && l === e && e.Ee === undefined && e.Ve === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+        if (t && tracking) link(e, t);
+        return !t || e.Ne === NOT_PENDING ? e.Re : e.Ne;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
-        // Mark inheritance through derivation (see the fast path above), and its
-        // transitive half (#2893): a mark-pended owner's sentinel sources flow to
-        // the reader like a direct mark — value-transparent reads have no throw
-        // to re-establish through, so without this a mid-window recompute sheds
-        // pendingness permanently past one derivation level.
-                if (activeAffectsMarks !== 0 && !pendingCheckActive) {
-            if (e.M) (affectsReads ??= []).push(e);
-            if (l.i & STATUS_PENDING) GlobalQueue.I(l, affectsReads ??= []);
-        }
-        if (l.xe) {
+        if (l.ke) {
             const n = queueFor(e);
-            if (l.qe >= n.Le) {
+            if (l.He >= n.Fe) {
                 markNode(t);
                 markHeap(n);
                 updateIfNecessary(l);
             }
-            const i = l.qe;
+            const i = l.He;
             // parent check is shallow, might need to be recursive
-                        if (i >= t.qe && e.Fe !== t) {
-                t.qe = i + 1;
+                        if (i >= t.He && e.Ge !== t) {
+                t.He = i + 1;
             }
         }
     }
-    // Mark-only pending never suspends the reader (#2886): an affects() mark is
-    // a promise of change, not an absence of value, so a derived node whose only
-    // pending sources are mark sentinels keeps its real value readable —
-    // pendingness reaches readers through verdicts (isPending), not throws.
-    // (`activeAffectsMarks` gates the source scan off the mark-free hot path;
-    // sentinels can't survive in pending sources past their last release.)
-        if (l.i & STATUS_PENDING && !(activeAffectsMarks !== 0 && GlobalQueue.$(l))) {
-        if (t && !(stale && l.ve && activeTransition !== l.ve)) {
+    if (l.S & STATUS_PENDING) {
+        if (t && !(stale && l.Ue && activeTransition !== l.Ue)) {
             // 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.ht(l)) {
+            if (currentOptimisticLane === null || GlobalQueue.At(l)) {
                 if (!tracking && e !== t) link(e, t);
-                throw l.k;
+                throw l._;
             }
-        } else if (t && l !== e && l.i & STATUS_UNINITIALIZED) {
+        } else if (t && l !== e && l.S & STATUS_UNINITIALIZED) {
             if (!tracking && e !== t) link(e, t);
-            throw l.k;
-        } else if (!t && l.i & STATUS_UNINITIALIZED) {
-            throw l.k;
+            throw l._;
+        } else if (!t && l.S & STATUS_UNINITIALIZED) {
+            throw l._;
         }
     }
-    if (e.xe && e.i & STATUS_ERROR) {
+    if (e.ke && e.S & 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
         // - el._time < clock: only on a later cycle than the one the error was found
-        if (tracking && !pendingCheckActive && e.Ie < clock) {
+        if (tracking && !pendingCheckActive && e.ce < clock) {
             recompute(e);
             return read(e);
-        } else throw e.k;
+        } else throw e._;
     }
-    if (snapshotCaptureActive && t && t.U & CONFIG_IN_SNAPSHOT_SCOPE) {
-        const n = e.Ye;
+    if (snapshotCaptureActive && t && t.T & CONFIG_IN_SNAPSHOT_SCOPE) {
+        const n = e.Ve;
         if (n !== undefined) {
             const i = n === NO_SNAPSHOT ? undefined : n;
-            const l = e.ge !== NOT_PENDING ? e.ge : e.Ue;
-            if (l !== i) t.u |= REACTIVE_SNAPSHOT_STALE;
+            const l = e.Ne !== NOT_PENDING ? e.Ne : e.Re;
+            if (l !== i) t.se |= REACTIVE_SNAPSHOT_STALE;
             return i;
         }
     }
-    if (e.be !== undefined && e.be !== NOT_PENDING) {
-        // An active override means the engine is installed (A17: the override IS
-        // the value for every reader — that check itself stays right here).
-        if (t && stale && GlobalQueue.Dt(e)) return e.Ue;
-        return unwrapOverride(e.be);
+    if (e.Ee !== undefined && e.Ee !== NOT_PENDING) {
+        // A17: the override IS the value for every reader.
+        return unwrapOverride(e.Ee);
     }
     // Entanglement gate: a reader recomputing under an optimistic lane that reads
     // a pending mid-transition write sees the committed value. Projection-store
@@ -621,40 +578,40 @@ 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.gt(e, l, t)) {
-        return e.Ue;
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Ct(e, l, t)) {
+        return e.Re;
     }
     // 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 u = !t || currentOptimisticLane !== null && GlobalQueue.vt(e, l, t) || e.ge === NOT_PENDING || stale && e.ve && activeTransition !== e.ve ? e.Ue : e.ge;
+        const u = !t || currentOptimisticLane !== null && GlobalQueue.Ot(e, l, t) || e.Ne === NOT_PENDING || stale && e.Ue && activeTransition !== e.Ue ? e.Re : e.Ne;
     // 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.kt(e, u);
-    if (!t && l === e && typeof n.xe === "function" && e.U & CONFIG_AUTO_DISPOSE && !(l.i & STATUS_PENDING) && !e.p) {
+        if (pendingCheckActive) GlobalQueue.Rt(e, u);
+    if (!t && l === e && typeof n.ke === "function" && e.T & CONFIG_AUTO_DISPOSE && !(l.S & STATUS_PENDING) && !e.o) {
         unobserved(e);
     }
     return u;
 }
 
 function setSignal(e, t) {
-    if (e.ve && activeTransition !== e.ve) globalQueue.initTransition(e.ve);
+    if (e.Ue && activeTransition !== e.Ue) globalQueue.initTransition(e.Ue);
     // The optimistic write path lives with the engine: only optimisticSignal /
     // optimisticComputed callers and optimistic store nodes carry an
     // _overrideValue slot, and every module that creates one installs the
     // engine first.
-        if (e.be !== undefined && !projectionWriteActive) return GlobalQueue.bt(e, t);
-    const n = e.ge === NOT_PENDING ? e.Ue : e.ge;
+        if (e.Ee !== undefined && !projectionWriteActive) return GlobalQueue.Pt(e, t);
+    const n = e.Ne === NOT_PENDING ? e.Re : e.Ne;
     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 i = !!(e.i & STATUS_UNINITIALIZED) || !e.Ge || !e.Ge(n, t);
+        const i = !!(e.S & STATUS_UNINITIALIZED) || !e.Pe || !e.Pe(n, t);
     if (!i) return t;
-    if (e.ge === NOT_PENDING) queuePendingNode(e);
-    e.ge = t;
-    GlobalQueue._e !== null && GlobalQueue._e(e, t);
-    e.Ie = clock;
+    if (e.Ne === NOT_PENDING) queuePendingNode(e);
+    e.Ne = t;
+    GlobalQueue.Ie !== null && GlobalQueue.Ie(e, t);
+    e.ce = clock;
     insertSubs(e);
     schedule();
     return t;
@@ -668,11 +625,11 @@ function setSignal(e, t) {
  * cleanup point.
  */ function suppressComputedRecompute(e) {
     deleteFromHeap(e, queueFor(e));
-    if (!(e.u & REACTIVE_MANUAL_WRITE) && e.ge === NOT_PENDING) {
+    if (!(e.se & REACTIVE_MANUAL_WRITE) && e.Ne === NOT_PENDING) {
         queuePendingNode(e);
         schedule();
     }
-    e.u = e.u & -4 | REACTIVE_MANUAL_WRITE;
+    e.se = e.se & -4 | REACTIVE_MANUAL_WRITE;
 }
 
 /**
@@ -751,7 +708,7 @@ function staleValues(e, t = true) {
     if (!t) {
         return;
     }
-    if (typeof t.xe === "function" && !(t.u & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))) {
+    if (typeof t.ke === "function" && !(t.se & (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
@@ -759,11 +716,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.u & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
-            t.u |= REACTIVE_REASK;
+        if (!(t.se & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+            t.se |= REACTIVE_REASK;
             armReaskClear();
         }
-        t.u = t.u & ~REACTIVE_CHECK | REACTIVE_DIRTY;
+        t.se = t.se & ~REACTIVE_CHECK | REACTIVE_DIRTY;
         insertIntoHeap(t, queueFor(t));
         schedule();
     }