@solidjs/signals 2.0.0-beta.24 → 2.0.0-beta.26

package/dist/prod/core/effect.js

@@ -14,7 +14,7 @@ import { GlobalQueue, haltReactivity } from "./scheduler.js";
     const r = !!R?.user;
     const f = createEffectNode(t, E, e, r ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, R);
     recompute(f, true);
-    !R?.defer && (f.Ae === EFFECT_USER || R?.schedule ? f.C.enqueue(f.Ae, runEffect.bind(null, f)) : runEffect(f));
+    !R?.defer && (f.Pe === EFFECT_USER || R?.schedule ? f.C.enqueue(f.Pe, runEffect.bind(null, f)) : runEffect(f));
 }
 
 function notifyEffectStatus(t, E) {
@@ -23,7 +23,7 @@ function notifyEffectStatus(t, E) {
     const R = E !== undefined ? E : this._;
     if (e & STATUS_ERROR) {
         this.C.notify(this, STATUS_PENDING, 0);
-        if (this.Ae === EFFECT_USER) {
+        if (this.Pe === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
             // queue it like the effect function. It runs in the same imperative,
             // writable scope, throws escalate the same way, and a held transition
@@ -34,8 +34,8 @@ function notifyEffectStatus(t, E) {
             // `status` arg without node-state writes) don't queue: the status
             // re-propagates unblocked at commit.
             if (this.S & STATUS_ERROR) {
-                this.$e = true;
-                this.C.enqueue(this.Ae, this.Be ??= runEffect.bind(null, this));
+                this.Be = true;
+                this.C.enqueue(this.Pe, this.Je ??= runEffect.bind(null, this));
             }
             return;
         }
@@ -43,13 +43,13 @@ function notifyEffectStatus(t, E) {
             haltReactivity(unwrapStatusError(R));
             throw R;
         }
-    } else if (this.Ae === EFFECT_RENDER) {
+    } else if (this.Pe === EFFECT_RENDER) {
         this.C.notify(this, STATUS_PENDING | STATUS_ERROR, e, R);
     }
 }
 
 function runEffect(t) {
-    if (!t.$e || t.se & REACTIVE_DISPOSED) return;
+    if (!t.Be || t.se & 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
@@ -60,12 +60,12 @@ function runEffect(t) {
     // 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 (t.S & STATUS_ERROR && t.Ae === EFFECT_USER) {
+        if (t.S & STATUS_ERROR && t.Pe === EFFECT_USER) {
         const E = unwrapStatusError(t._);
-        t.rt = t.Pe;
-        t.$e = false;
+        t.ct = t.Ue;
+        t.Be = false;
         try {
-            t._t ? t._t(E, () => {
+            t.ft ? t.ft(E, () => {
                 const E = t.Et;
                 t.Et = undefined;
                 E?.();
@@ -82,7 +82,7 @@ function runEffect(t) {
     t.Et = undefined;
     try {
         E?.();
-        const e = t.ct(t.Pe, t.rt);
+        const e = t._t(t.Ue, t.ct);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
                 t.Et = e;
@@ -94,12 +94,12 @@ function runEffect(t) {
             throw E;
         }
     } finally {
-        t.rt = t.Pe;
-        t.$e = false;
+        t.ct = t.Ue;
+        t.Be = false;
     }
 }
 
-GlobalQueue.Je = runEffect;
+GlobalQueue.Xe = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -107,9 +107,9 @@ GlobalQueue.Je = runEffect;
  * Uses stale reads.
  */ function trackedEffect(t, E) {
     const run = () => {
-        if (!e.$e || e.se & REACTIVE_DISPOSED) return;
+        if (!e.Be || e.se & REACTIVE_DISPOSED) return;
         try {
-            e.$e = false;
+            e.Be = false;
             recompute(e);
         } finally {}
     };
@@ -125,8 +125,8 @@ GlobalQueue.Je = runEffect;
     });
     e.Et = undefined;
     e.T = e.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    e.$e = true;
-    e.Ae = EFFECT_TRACKED;
+    e.Be = true;
+    e.Pe = EFFECT_TRACKED;
     e.i = (t, E) => {
         const R = t !== undefined ? t : e.S;
         if (R & STATUS_ERROR) {
@@ -138,7 +138,7 @@ GlobalQueue.Je = runEffect;
             }
         }
     };
-    e.ht = run;
+    e.Ft = run;
     e.C.enqueue(EFFECT_USER, run);
 }
 

package/dist/prod/core/external.js

@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.ke, () => {
+    const r = externalSourceConfig.factory(e.ae, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.ke = e => {
+    e.ae = e => {
         read(n);
         return r.track(e);
     };
@@ -64,8 +64,8 @@ function externalUntrack(e) {
 // removed on reset) so core's null checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.Tt = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.It = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.It = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.dt = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {

package/dist/prod/core/graph.js

@@ -8,15 +8,15 @@ import "./scheduler.js";
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(l) {
-    const n = l.tt;
-    const e = l.et;
+    const n = l.nt;
+    const e = l.tt;
     const u = l.ue;
     const s = l.ll;
-    if (u !== null) u.ll = s; else n.ot = s;
+    if (u !== null) u.ll = s; else n.st = s;
     if (s !== null) s.ue = u; else {
         n.o = u;
         if (u === null) {
-            n.it?.();
+            n.ut?.();
             // 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
@@ -24,31 +24,31 @@ function unlinkSubs(l) {
             // this same last-one-out check when that observer releases (the
             // untracked-read dispose in core.ts guards on pending identically).
                         const l = n;
-            l.ke && l.T & CONFIG_AUTO_DISPOSE && !(l.se & REACTIVE_ZOMBIE) && !(l.S & STATUS_PENDING) && unobserved(l);
+            l.ae && l.T & CONFIG_AUTO_DISPOSE && !(l.se & REACTIVE_ZOMBIE) && !(l.S & STATUS_PENDING) && unobserved(l);
         }
     }
     return e;
 }
 
 function trimStaleDeps(l) {
-    const n = l.qe;
-    let e = n !== null ? n.et : l.Xe;
+    const n = l.We;
+    let e = n !== null ? n.tt : l.et;
     if (e !== null) {
         do {
             e = unlinkSubs(e);
         } while (e !== null);
-        if (n !== null) n.et = null; else l.Xe = null;
+        if (n !== null) n.tt = null; else l.et = null;
     }
 }
 
 function unobserved(l) {
     deleteFromHeap(l, queueFor(l));
-    let n = l.Xe;
+    let n = l.et;
     while (n !== null) {
         n = unlinkSubs(n);
     }
-    l.Xe = null;
-    l.qe = null;
+    l.et = null;
+    l.We = null;
     disposeChildren(l, true);
 }
 
@@ -59,20 +59,20 @@ function link(l, n, e = false) {
     // not relabel the value dependency as probe-only — the value read is what
     // real-error propagation and affects() coverage key off, regardless of
     // read order within the computation.
-    const u = n.qe;
-    if (u !== null && u.tt === l) {
-        u.De &&= e;
+    const u = n.We;
+    if (u !== null && u.nt === l) {
+        u.ge &&= e;
         return;
     }
     let s = null;
     const t = n.se & REACTIVE_RECOMPUTING_DEPS;
     if (t) {
-        s = u !== null ? u.et : n.Xe;
-        if (s !== null && s.tt === l) {
+        s = u !== null ? u.tt : n.et;
+        if (s !== null && s.nt === l) {
             s.nl = n.Ye;
-            n.qe = s;
+            n.We = s;
             // First touch of this pass: the previous pass's label is stale.
-                        s.De = e;
+                        s.ge = e;
             return;
         }
     }
@@ -81,23 +81,23 @@ function link(l, n, e = false) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
-        const i = l.ot;
+        const i = l.st;
     if (i !== null && i.le === n && (!t || i.nl === n.Ye)) {
         // Gen-matched during a recompute = repeat touch this pass (AND); outside
         // a recompute there is no pass boundary, so the latest read labels it.
-        if (t) i.De &&= e; else i.De = e;
+        if (t) i.ge &&= e; else i.ge = e;
         return;
     }
-    const o = n.qe = l.ot = {
-        tt: l,
+    const o = n.We = l.st = {
+        nt: l,
         le: n,
-        et: s,
+        tt: s,
         ll: i,
         ue: null,
         nl: n.Ye,
-        De: e
+        ge: e
     };
-    if (u !== null) u.et = o; else n.Xe = o;
+    if (u !== null) u.tt = o; else n.et = o;
     if (i !== null) i.ue = o; else l.o = o;
 }
 

package/dist/prod/core/heap.js

@@ -11,29 +11,29 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
  * the heap and go directly to their effect queue; everything else is inserted
  * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
  */ function enqueueSub(e) {
-    if (e.Ae === EFFECT_TRACKED) {
+    if (e.Pe === EFFECT_TRACKED) {
         const E = e;
-        if (!E.$e) {
-            E.$e = true;
-            E.C.enqueue(EFFECT_USER, E.ht);
+        if (!E.Be) {
+            E.Be = true;
+            E.C.enqueue(EFFECT_USER, E.Ft);
         }
         return;
     }
     const E = queueFor(e);
-    if (E.He > e.Fe) E.He = e.Fe;
+    if (E.He > e.Ve) E.He = e.Ve;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.Ge?.ft ? e.Ge.Nt?.Fe : e.Ge?.Fe) ?? -1;
-    if (t >= e.Fe) e.Fe = t + 1;
-    const n = e.Fe;
+    const t = (e.ve?.Nt ? e.ve.Tt?.Ve : e.ve?.Ve) ?? -1;
+    if (t >= e.Ve) e.Ve = t + 1;
+    const n = e.Ve;
     const I = E.eE[n];
     if (I === undefined) E.eE[n] = e; else {
-        const E = I.ut;
+        const E = I.ot;
         E.lt = e;
-        e.ut = E;
-        I.ut = e;
+        e.ot = E;
+        I.ot = e;
     }
     if (n > E.EE) E.EE = n;
 }
@@ -66,15 +66,15 @@ function deleteFromHeap(e, E) {
     const t = e.se;
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.se = t & -25;
-    const n = e.Fe;
-    if (e.ut === e) E.eE[n] = undefined; else {
+    const n = e.Ve;
+    if (e.ot === e) E.eE[n] = undefined; else {
         const t = e.lt;
         const I = E.eE[n];
         const o = t ?? I;
-        if (e === I) E.eE[n] = t; else e.ut.lt = t;
-        o.ut = e.ut;
+        if (e === I) E.eE[n] = t; else e.ot.lt = t;
+        o.ot = e.ot;
     }
-    e.ut = e;
+    e.ot = e;
     e.lt = undefined;
 }
 
@@ -118,14 +118,14 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.Fe;
-    for (let E = e.Xe; E; E = E.et) {
-        const e = E.tt;
-        const n = e.nt || e;
-        if (n.ke && n.Fe >= t) t = n.Fe + 1;
+    let t = e.Ve;
+    for (let E = e.et; E; E = E.tt) {
+        const e = E.nt;
+        const n = e.it || e;
+        if (n.ae && n.Ve >= t) t = n.Ve + 1;
     }
-    if (e.Fe !== t) {
-        e.Fe = t;
+    if (e.Ve !== t) {
+        e.Ve = t;
         for (let E = e.o; E !== null; E = E.ue) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`

package/dist/prod/core/lanes.js

@@ -19,13 +19,13 @@ const activeLanes = new Set;
     // Detect parent lane: _parentSource chains from pendingSignal → pendingValueComputed → original.
     // The child lane should not merge with the parent lane.
         const i = n.nn;
-    const r = i?.je ? findLane(i.je) : null;
+    const r = i?.Me ? findLane(i.Me) : null;
     e = {
         en: n,
-        de: new Set,
+        Ne: new Set,
         rn: [ [], [] ],
         tn: null,
-        Ue: activeTransition,
+        Ie: activeTransition,
         an: r
     };
     signalLanes.set(n, e);
@@ -36,8 +36,8 @@ const activeLanes = new Set;
     // parent-child is a property of the nodes, not of write order — otherwise
     // the owner's write merges the companion's subscribers into this lane and
     // their effects wait on its async instead of flushing immediately.
-        adoptCompanionLane(n.be, e);
-    adoptCompanionLane(n.ge, e);
+        adoptCompanionLane(n.he, e);
+    adoptCompanionLane(n.Ge, e);
     return e;
 }
 
@@ -68,8 +68,8 @@ function adoptCompanionLane(n, e) {
     // Move (not copy) the merged lane's work: after the merge all routing goes
     // through findLane() to the root, so anything left behind here is dead —
     // and anything *added* here later is a routing bug (INV-5).
-        for (const i of e.de) n.de.add(i);
-    e.de.clear();
+        for (const i of e.Ne) n.Ne.add(i);
+    e.Ne.clear();
     n.rn[0].push(...e.rn[0]);
     n.rn[1].push(...e.rn[1]);
     e.rn[0].length = 0;
@@ -80,11 +80,11 @@ function adoptCompanionLane(n, e) {
 /**
  * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
  */ function resolveLane(n) {
-    const e = n.je;
+    const e = n.Me;
     if (!e) return undefined;
     const i = findLane(e);
     if (activeLanes.has(i)) return i;
-    n.je = undefined;
+    n.Me = undefined;
     return undefined;
 }
 
@@ -99,13 +99,13 @@ function resolveTransition(n) {
         if (e.fn !== true) return e;
         n.sn = null;
     }
-    return resolveLane(n)?.Ue ?? n.Ue;
+    return resolveLane(n)?.Ie ?? n.Ie;
 }
 
 /**
  * Check if a node has an active optimistic override.
  */ function hasActiveOverride(n) {
-    return !!(n.Ee !== undefined && n.Ee !== NOT_PENDING);
+    return !!(n.Ae !== undefined && n.Ae !== NOT_PENDING);
 }
 
 /**
@@ -113,13 +113,13 @@ function resolveTransition(n) {
  * a different active lane), merge unless the node has an active override.
  */ function assignOrMergeLane(n, e) {
     const i = findLane(e);
-    const r = n.je;
+    const r = n.Me;
     if (r) {
         // If the subscriber's lane was merged into another lane, it's stale —
         // replace it with the new source lane instead of following the merge chain
         // (which would incorrectly merge the new lane into the old group)
         if (r.tn) {
-            n.je = e;
+            n.Me = e;
             return;
         }
         const t = findLane(r);
@@ -128,13 +128,13 @@ function resolveTransition(n) {
                 // Parent-child lanes stay independent so isPending resolves without
                 // waiting for the parent's async. The child keeps ownership.
                 if (i.an && findLane(i.an) === t) {
-                    n.je = e;
+                    n.Me = e;
                 } else if (t.an && findLane(t.an) === i) ; else mergeLanes(i, t);
             }
             return;
         }
     }
-    n.je = e;
+    n.Me = e;
 }
 
 export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane, resolveTransition, signalLanes };

package/dist/prod/core/optimistic.js

@@ -24,8 +24,8 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
  * once the gate holds — the same late-binding contract as verdict.ts.
  */
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
-    const t = e.Ee !== NOT_PENDING;
-    const i = t ? unwrapOverride(e.Ee) : e.Pe;
+    const t = e.Ae !== NOT_PENDING;
+    const i = t ? unwrapOverride(e.Ae) : e.Ue;
     if (typeof n === "function") n = n(i);
     const u = !!(e.S & STATUS_UNINITIALIZED) || !e.Re || !e.Re(i, n);
     if (!u) {
@@ -41,19 +41,21 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     // 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.m.Ze.push(e);
+     else globalQueue.m.je.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).
         e.sn = activeTransition;
     const o = getOrCreateLane(e);
-    e.je = o;
+    e.Me = o;
     // Literal undefined must not land raw: the slot doubles as the optimistic
     // brand, and erasing it makes the write invisible and routes follow-up
     // writes off the optimistic path into permanent commits (#2898).
-        e.Ee = n === undefined ? OVERRIDE_UNDEFINED : n;
-    GlobalQueue.Ie !== null && GlobalQueue.Ie(e, n);
-    e.ce = clock;
+        e.Ae = n === undefined ? OVERRIDE_UNDEFINED : n;
+    // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
+    // neither companion present the call is a guaranteed no-op.
+        (e.he !== undefined || e.Ge !== undefined) && GlobalQueue.De !== null && GlobalQueue.De(e, n);
+    e.Se = clock;
     insertSubs(e, true);
     schedule();
     return n;
@@ -64,8 +66,8 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
  * 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 n = 0; n < e.Ze.length; n++) {
-        const t = e.Ze[n];
+    for (let n = 0; n < e.je.length; n++) {
+        const t = e.je[n];
         if (hasActiveOverride(t) && "S" in t && t.S & STATUS_PENDING && t._ instanceof NotReadyError) {
             return true;
         }
@@ -80,15 +82,15 @@ function resolveOptimisticNodes(e) {
     const n = e.length;
     for (let t = 0; t < n; t++) {
         const n = e[t];
-        n.je = undefined;
+        n.Me = undefined;
         // 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 (!(n.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
-        const i = n.Ee;
-        n.Ee = NOT_PENDING;
-        if (i !== NOT_PENDING && n.Pe !== unwrapOverride(i)) insertSubs(n, true);
-        n.Ue = null;
+        const i = n.Ae;
+        n.Ae = NOT_PENDING;
+        if (i !== NOT_PENDING && n.Ue !== unwrapOverride(i)) insertSubs(n, true);
+        n.Ie = null;
         n.sn = null;
     }
     // Settlement checkpoint (#2838): companions caught in this batch (or owned
@@ -96,9 +98,9 @@ function resolveOptimisticNodes(e) {
     // transition that produced them (A19 — pending is a property of the data).
         for (let t = 0; t < n; t++) {
         const n = e[t];
-        if (n.be || n.ge) GlobalQueue.un(n);
+        if (n.he || n.Ge) GlobalQueue.un(n);
         const i = n.nn;
-        if (i && (i.be === n || i.ge === n)) GlobalQueue.un(i);
+        if (i && (i.he === n || i.Ge === n)) GlobalQueue.un(i);
     }
     e.splice(0, n);
 }
@@ -111,7 +113,7 @@ function runQueue(e, n) {
  * Run effects from all lanes that are ready (no pending async).
  */ function runLaneEffects(e) {
     for (const n of activeLanes) {
-        if (n.tn || n.de.size > 0) continue;
+        if (n.tn || n.Ne.size > 0) continue;
         const t = n.rn[e - 1];
         if (t.length) {
             n.rn[e - 1] = [];
@@ -122,14 +124,14 @@ function runQueue(e, n) {
 
 function cleanupCompletedLanes(e) {
     for (const n of activeLanes) {
-        const t = e ? n.Ue === e : !n.Ue;
+        const t = e ? n.Ie === e : !n.Ie;
         if (!t) continue;
         if (!n.tn) {
             if (n.rn[0].length) runQueue(n.rn[0], EFFECT_RENDER);
             if (n.rn[1].length) runQueue(n.rn[1], EFFECT_USER);
         }
-        if (n.en.je === n) n.en.je = undefined;
-        n.de.clear();
+        if (n.en.Me === n) n.en.Me = undefined;
+        n.Ne.clear();
         n.rn[0].length = 0;
         n.rn[1].length = 0;
         activeLanes.delete(n);
@@ -141,7 +143,7 @@ function cleanupCompletedLanes(e) {
     // Per-lane suspension: only throw if in same lane as pending async
     // AND the node doesn't have an active override (overrides are the visible value,
     // downstream in the lane should read the override, not throw)
-    const n = e.je;
+    const n = e.Me;
     if (!n) return false;
     return findLane(n) === findLane(currentOptimisticLane) && !hasActiveOverride(e);
 }
@@ -151,7 +153,7 @@ 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, n, t) {
-    if (latestReadActive || e.Ne === NOT_PENDING || e.ke || n !== e && !(n.se & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e._e === NOT_PENDING || e.ae || n !== e && !(n.se & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
     activeTransition.ln.add(t);
@@ -162,7 +164,7 @@ 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, n, t) {
-    return e.Ee !== undefined || !!e.je || n === e && stale && t.nn !== e || !!(n.S & STATUS_PENDING);
+    return e.Ae !== undefined || !!e.Me || n === e && stale && t.nn !== e || !!(n.S & STATUS_PENDING);
 }
 
 /**
@@ -171,8 +173,8 @@ function cleanupCompletedLanes(e) {
  * can run before its OPT-dirty child propagates).
  */ function recomputeLane(e, n) {
     if (n) return resolveLane(e) ?? null;
-    for (let n = e.Xe; n; n = n.et) {
-        const t = n.tt;
+    for (let n = e.et; n; n = n.tt) {
+        const t = n.nt;
         if (t.se & REACTIVE_OPTIMISTIC_DIRTY) {
             const n = resolveLane(t);
             if (n) {
@@ -188,17 +190,17 @@ function cleanupCompletedLanes(e) {
 /** recompute()'s catch path: track pending async in the current lane. */ function laneAsyncPending(e) {
     const n = findLane(currentOptimisticLane);
     if (n.en !== e) {
-        n.de.add(e);
-        e.je = n;
-        GlobalQueue.ae !== null && GlobalQueue.ae(n.en);
+        n.Ne.add(e);
+        e.Me = n;
+        GlobalQueue.ce !== null && GlobalQueue.ce(n.en);
     }
 }
 
 /** recompute()'s success path: the node's async settled, clear it from its lane. */ function laneAsyncSettled(e) {
     const n = resolveLane(e);
     if (n) {
-        n.de.delete(e);
-        GlobalQueue.ae !== null && GlobalQueue.ae(n.en);
+        n.Ne.delete(e);
+        GlobalQueue.ce !== null && GlobalQueue.ce(n.en);
     }
 }
 
@@ -213,18 +215,18 @@ 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.Pt !== null) return;
-    GlobalQueue.Pt = optimisticWrite;
+    if (GlobalQueue.ht !== null) return;
+    GlobalQueue.ht = optimisticWrite;
     GlobalQueue.En = resolveOptimisticNodes;
-    GlobalQueue.Tn = transitionBlocked;
-    GlobalQueue.dn = cleanupCompletedLanes;
+    GlobalQueue.dn = transitionBlocked;
+    GlobalQueue.Tn = cleanupCompletedLanes;
     GlobalQueue.In = runLaneEffects;
-    GlobalQueue.Ct = gatedRead;
-    GlobalQueue.At = laneSuspends;
-    GlobalQueue.Ot = laneReadsCommitted;
-    GlobalQueue.We = recomputeLane;
-    GlobalQueue.Ke = laneAsyncPending;
-    GlobalQueue.Me = laneAsyncSettled;
+    GlobalQueue.Ot = gatedRead;
+    GlobalQueue.Ct = laneSuspends;
+    GlobalQueue.Rt = laneReadsCommitted;
+    GlobalQueue.Ze = recomputeLane;
+    GlobalQueue.ze = laneAsyncPending;
+    GlobalQueue.Ke = laneAsyncSettled;
     GlobalQueue.Nn = trackOptimisticStore;
 }