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

package/dist/prod/core/lanes.js

@@ -18,15 +18,15 @@ 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.en;
-    const r = i?.Je ? findLane(i.Je) : null;
+        const i = n.nn;
+    const r = i?.je ? findLane(i.je) : null;
     e = {
-        rn: n,
-        Pe: new Set,
-        tn: [ [], [] ],
-        an: null,
-        ve: activeTransition,
-        sn: r
+        en: n,
+        de: new Set,
+        rn: [ [], [] ],
+        tn: null,
+        Ue: activeTransition,
+        an: r
     };
     signalLanes.set(n, e);
     activeLanes.add(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.ye, e);
-    adoptCompanionLane(n.pe, e);
+        adoptCompanionLane(n.ge, e);
+    adoptCompanionLane(n.he, e);
     return e;
 }
 
@@ -48,13 +48,13 @@ function adoptCompanionLane(n, e) {
     const r = findLane(i);
     // Only the companion's own unmerged root is safely re-parentable: a root
     // that absorbed other lanes carries work that is not a child of this owner.
-        if (r !== e && r.rn === n && !r.sn) r.sn = e;
+        if (r !== e && r.en === n && !r.an) r.an = e;
 }
 
 /**
  * Union-find: find the root lane.
  */ function findLane(n) {
-    while (n.an) n = n.an;
+    while (n.tn) n = n.tn;
     return n;
 }
 
@@ -64,27 +64,27 @@ function adoptCompanionLane(n, e) {
     n = findLane(n);
     e = findLane(e);
     if (n === e) return n;
-    e.an = n;
+    e.tn = n;
     // 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.Pe) n.Pe.add(i);
-    e.Pe.clear();
-    n.tn[0].push(...e.tn[0]);
-    n.tn[1].push(...e.tn[1]);
-    e.tn[0].length = 0;
-    e.tn[1].length = 0;
+        for (const i of e.de) n.de.add(i);
+    e.de.clear();
+    n.rn[0].push(...e.rn[0]);
+    n.rn[1].push(...e.rn[1]);
+    e.rn[0].length = 0;
+    e.rn[1].length = 0;
     return n;
 }
 
 /**
  * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
  */ function resolveLane(n) {
-    const e = n.Je;
+    const e = n.je;
     if (!e) return undefined;
     const i = findLane(e);
     if (activeLanes.has(i)) return i;
-    n.Je = undefined;
+    n.je = undefined;
     return undefined;
 }
 
@@ -94,18 +94,18 @@ function resolveTransition(n) {
     // transactions (#2912) — the merged root's _transition would hand this
     // node's override to whichever action wrote last through the shared
     // reader. Chase merge chains; a dead owner settled through another path.
-    if (hasActiveOverride(n) && n.fn) {
-        const e = n.fn = currentTransition(n.fn);
-        if (e.cn !== true) return e;
-        n.fn = null;
+    if (hasActiveOverride(n) && n.sn) {
+        const e = n.sn = currentTransition(n.sn);
+        if (e.fn !== true) return e;
+        n.sn = null;
     }
-    return resolveLane(n)?.ve ?? n.ve;
+    return resolveLane(n)?.Ue ?? n.Ue;
 }
 
 /**
  * Check if a node has an active optimistic override.
  */ function hasActiveOverride(n) {
-    return !!(n.be !== undefined && n.be !== NOT_PENDING);
+    return !!(n.Ee !== undefined && n.Ee !== 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.je;
     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.an) {
-            n.Je = e;
+        if (r.tn) {
+            n.je = e;
             return;
         }
         const t = findLane(r);
@@ -127,14 +127,14 @@ function resolveTransition(n) {
             if (t !== i && !hasActiveOverride(n)) {
                 // Parent-child lanes stay independent so isPending resolves without
                 // waiting for the parent's async. The child keeps ownership.
-                if (i.sn && findLane(i.sn) === t) {
-                    n.Je = e;
-                } else if (t.sn && findLane(t.sn) === i) ; else mergeLanes(i, t);
+                if (i.an && findLane(i.an) === t) {
+                    n.je = e;
+                } else if (t.an && findLane(t.an) === i) ; else mergeLanes(i, t);
             }
             return;
         }
     }
-    n.Je = e;
+    n.je = e;
 }
 
 export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane, resolveTransition, signalLanes };

package/dist/prod/core/optimistic.js

@@ -1,16 +1,14 @@
-import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, OVERRIDE_UNDEFINED, STATUS_PENDING, CONFIG_OWNED_WRITE, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_RENDER, EFFECT_USER } from "./constants.js";
+import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, OVERRIDE_UNDEFINED, STATUS_PENDING, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_RENDER, EFFECT_USER } from "./constants.js";
 
 import { latestReadActive, currentOptimisticLane, stale } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
-import { enqueueSub } from "./heap.js";
-
 import "./invariants.js";
 
 import { resolveTransition, getOrCreateLane, hasActiveOverride, activeLanes, signalLanes, findLane, resolveLane, assignOrMergeLane } from "./lanes.js";
 
-import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule, finalizePureQueue } from "./scheduler.js";
+import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule } from "./scheduler.js";
 
 /**
  * The optimistic write engine, moved out of core.ts/scheduler.ts. Everything
@@ -25,15 +23,11 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
  * `_optimisticNodes.length`, `activeLanes.size`), so `!` invocations are safe
  * once the gate holds — the same late-binding contract as verdict.ts.
  */
-// When a background transition is stashed, plain optimistic signals need one
-// committed-view rerun. Keep that override local to the stash flush.
-let stashedOptimisticReads = null;
-
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
-    const t = e.be !== NOT_PENDING;
-    const i = t ? unwrapOverride(e.be) : e.Ue;
+    const t = e.Ee !== NOT_PENDING;
+    const i = t ? unwrapOverride(e.Ee) : e.Re;
     if (typeof n === "function") n = n(i);
-    const u = !!(e.i & STATUS_UNINITIALIZED) || !e.Ge || !e.Ge(i, n);
+    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.Pe || !e.Pe(i, n);
     if (!u) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -47,66 +41,32 @@ let stashedOptimisticReads = null;
     // 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.N.Be.push(e);
+     else globalQueue.m.Ze.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.fn = activeTransition;
-    const s = getOrCreateLane(e);
-    e.Je = s;
+        e.sn = activeTransition;
+    const o = getOrCreateLane(e);
+    e.je = 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.be = n === undefined ? OVERRIDE_UNDEFINED : n;
-    GlobalQueue._e !== null && GlobalQueue._e(e, n);
-    e.Ie = clock;
+        e.Ee = n === undefined ? OVERRIDE_UNDEFINED : n;
+    GlobalQueue.Ie !== null && GlobalQueue.Ie(e, n);
+    e.ce = clock;
     insertSubs(e, true);
     schedule();
     return n;
 }
 
-function readStashed(e) {
-    return !!stashedOptimisticReads?.has(e);
-}
-
-function queueStashedOptimisticEffects(e) {
-    for (let n = e.p; n !== null; n = n.de) {
-        const e = n.Ee;
-        if (!e.De) continue;
-        enqueueSub(e);
-    }
-}
-
-/**
- * Incomplete-transition finalization when the stashed transition holds
- * optimistic nodes: give plain optimistic signals one committed-view rerun.
- */ function stashOptimistic(e) {
-    stashedOptimisticReads = new Set;
-    for (let n = 0; n < e.Be.length; n++) {
-        const t = e.Be[n];
-        if (t.xe || t.U & CONFIG_OWNED_WRITE) continue;
-        stashedOptimisticReads.add(t);
-        queueStashedOptimisticEffects(t);
-    }
-    try {
-        finalizePureQueue(null, true);
-    } finally {
-        stashedOptimisticReads = null;
-    }
-}
-
 /**
  * transitionComplete's override blockage: a settling transition stays open
  * 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.Be.length; n++) {
-        const t = e.Be[n];
-        if (hasActiveOverride(t) && "i" in t && t.i & STATUS_PENDING && t.k instanceof NotReadyError && 
-        // Mark-sourced pending never blocks settlement: affects() releases AT
-        // settle, so counting its sentinel here would deadlock the window it
-        // is scoped to.
-        !t.k.source?.l) {
+    for (let n = 0; n < e.Ze.length; n++) {
+        const t = e.Ze[n];
+        if (hasActiveOverride(t) && "S" in t && t.S & STATUS_PENDING && t._ instanceof NotReadyError) {
             return true;
         }
     }
@@ -120,25 +80,25 @@ function resolveOptimisticNodes(e) {
     const n = e.length;
     for (let t = 0; t < n; t++) {
         const n = e[t];
-        n.Je = undefined;
+        n.je = 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.i & STATUS_PENDING)) n.i &= ~STATUS_UNINITIALIZED;
-        const i = n.be;
-        n.be = NOT_PENDING;
-        if (i !== NOT_PENDING && n.Ue !== unwrapOverride(i)) insertSubs(n, true);
-        n.ve = null;
-        n.fn = null;
+                if (!(n.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
+        const i = n.Ee;
+        n.Ee = NOT_PENDING;
+        if (i !== NOT_PENDING && n.Re !== unwrapOverride(i)) insertSubs(n, true);
+        n.Ue = null;
+        n.sn = null;
     }
     // Settlement checkpoint (#2838): companions caught in this batch (or owned
     // by a node in it) re-derive from committed state, so verdicts survive the
     // 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.ye || n.pe) GlobalQueue.R(n);
-        const i = n.en;
-        if (i && (i.ye === n || i.pe === n)) GlobalQueue.R(i);
+        if (n.ge || n.he) GlobalQueue.un(n);
+        const i = n.nn;
+        if (i && (i.ge === n || i.he === n)) GlobalQueue.un(i);
     }
     e.splice(0, n);
 }
@@ -151,10 +111,10 @@ 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.an || n.Pe.size > 0) continue;
-        const t = n.tn[e - 1];
+        if (n.tn || n.de.size > 0) continue;
+        const t = n.rn[e - 1];
         if (t.length) {
-            n.tn[e - 1] = [];
+            n.rn[e - 1] = [];
             runQueue(t, e);
         }
     }
@@ -162,18 +122,18 @@ function runQueue(e, n) {
 
 function cleanupCompletedLanes(e) {
     for (const n of activeLanes) {
-        const t = e ? n.ve === e : !n.ve;
+        const t = e ? n.Ue === e : !n.Ue;
         if (!t) continue;
-        if (!n.an) {
-            if (n.tn[0].length) runQueue(n.tn[0], EFFECT_RENDER);
-            if (n.tn[1].length) runQueue(n.tn[1], EFFECT_USER);
+        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.rn.Je === n) n.rn.Je = undefined;
-        n.Pe.clear();
-        n.tn[0].length = 0;
-        n.tn[1].length = 0;
+        if (n.en.je === n) n.en.je = undefined;
+        n.de.clear();
+        n.rn[0].length = 0;
+        n.rn[1].length = 0;
         activeLanes.delete(n);
-        signalLanes.delete(n.rn);
+        signalLanes.delete(n.en);
     }
 }
 
@@ -181,7 +141,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.je;
     if (!n) return false;
     return findLane(n) === findLane(currentOptimisticLane) && !hasActiveOverride(e);
 }
@@ -191,10 +151,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, n, t) {
-    if (latestReadActive || e.ge === NOT_PENDING || e.xe || n !== e && !(n.u & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e.Ne === NOT_PENDING || e.ke || n !== e && !(n.se & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
-    activeTransition.un.add(t);
+    activeTransition.ln.add(t);
     return true;
 }
 
@@ -202,7 +162,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.be !== undefined || !!e.Je || n === e && stale && t.en !== e || !!(n.i & STATUS_PENDING);
+    return e.Ee !== undefined || !!e.je || n === e && stale && t.nn !== e || !!(n.S & STATUS_PENDING);
 }
 
 /**
@@ -211,12 +171,12 @@ 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.S; n; n = n.st) {
-        const t = n.ot;
-        if (t.u & REACTIVE_OPTIMISTIC_DIRTY) {
+    for (let n = e.Xe; n; n = n.et) {
+        const t = n.tt;
+        if (t.se & REACTIVE_OPTIMISTIC_DIRTY) {
             const n = resolveLane(t);
             if (n) {
-                e.u |= REACTIVE_OPTIMISTIC_DIRTY;
+                e.se |= REACTIVE_OPTIMISTIC_DIRTY;
                 assignOrMergeLane(e, n);
                 return n;
             }
@@ -227,24 +187,24 @@ function cleanupCompletedLanes(e) {
 
 /** recompute()'s catch path: track pending async in the current lane. */ function laneAsyncPending(e) {
     const n = findLane(currentOptimisticLane);
-    if (n.rn !== e) {
-        n.Pe.add(e);
-        e.Je = n;
-        GlobalQueue.P !== null && GlobalQueue.P(n.rn);
+    if (n.en !== e) {
+        n.de.add(e);
+        e.je = n;
+        GlobalQueue.ae !== null && GlobalQueue.ae(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.Pe.delete(e);
-        GlobalQueue.P !== null && GlobalQueue.P(n.rn);
+        n.de.delete(e);
+        GlobalQueue.ae !== null && GlobalQueue.ae(n.en);
     }
 }
 
 function trackOptimisticStore(e) {
     // After initTransition, globalQueue._batch IS activeTransition (same reference)
-    globalQueue.N.dn.add(e);
+    globalQueue.m.cn.add(e);
     schedule();
 }
 
@@ -253,21 +213,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.bt !== null) return;
-    GlobalQueue.bt = optimisticWrite;
+    if (GlobalQueue.Pt !== null) return;
+    GlobalQueue.Pt = optimisticWrite;
     GlobalQueue.En = resolveOptimisticNodes;
-    GlobalQueue.Tn = stashOptimistic;
-    GlobalQueue.In = transitionBlocked;
-    GlobalQueue.Nn = cleanupCompletedLanes;
-    GlobalQueue.On = runLaneEffects;
-    GlobalQueue.Dt = readStashed;
-    GlobalQueue.gt = gatedRead;
-    GlobalQueue.ht = laneSuspends;
-    GlobalQueue.vt = laneReadsCommitted;
-    GlobalQueue.$e = recomputeLane;
-    GlobalQueue.et = laneAsyncPending;
-    GlobalQueue.Xe = laneAsyncSettled;
-    GlobalQueue.mn = trackOptimisticStore;
+    GlobalQueue.Tn = transitionBlocked;
+    GlobalQueue.dn = cleanupCompletedLanes;
+    GlobalQueue.In = runLaneEffects;
+    GlobalQueue.Ct = gatedRead;
+    GlobalQueue.At = laneSuspends;
+    GlobalQueue.Ot = laneReadsCommitted;
+    GlobalQueue.We = recomputeLane;
+    GlobalQueue.Ke = laneAsyncPending;
+    GlobalQueue.Me = laneAsyncSettled;
+    GlobalQueue.Nn = trackOptimisticStore;
 }
 
 export { installOptimisticEngine };

package/dist/prod/core/owner.js

@@ -12,10 +12,10 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let n = e.He;
+    let n = e.me;
     while (n) {
-        const e = n.u;
-        n.u = e | REACTIVE_ZOMBIE;
+        const e = n.se;
+        n.se = 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
@@ -26,79 +26,79 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(n, zombieQueue); else insertIntoHeapHeight(n, zombieQueue);
         }
         markDisposal(n);
-        n = n.Ve;
+        n = n.ve;
     }
 }
 
 function dispose(e) {
-    let n = e.S;
+    let n = e.Xe;
     while (n !== null) {
         n = unlinkSubs(n);
     }
-    e.S = null;
-    e.Ke = null;
+    e.Xe = null;
+    e.qe = null;
     disposeChildren(e, true);
 }
 
 function disposeChildren(e, n = false, t) {
-    const i = e.u;
+    const i = e.se;
     if (i & REACTIVE_DISPOSED) return;
     if (n) {
-        e.u = i | REACTIVE_DISPOSED;
+        e.se = i | 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 n = e;
-        if (n.ye || n.pe) GlobalQueue.R(n);
+        if (n.ge || n.he) GlobalQueue.un(n);
     }
-    if (n && e.xe) e.Ae = null;
-    let l = t ? e.Ze : e.He;
+    if (n && e.ke) e.Te = null;
+    let l = t ? e.Le : e.me;
     while (l) {
-        const e = l.Ve;
-        if (l.S) {
+        const e = l.ve;
+        if (l.Xe) {
             const e = l;
             deleteFromHeap(e, queueFor(e));
-            let n = e.S;
+            let n = e.Xe;
             do {
                 n = unlinkSubs(n);
             } while (n !== null);
-            e.S = null;
-            e.Ke = null;
+            e.Xe = null;
+            e.qe = null;
         }
         disposeChildren(l, true);
         l = e;
     }
     if (t) {
-        e.Ze = null;
+        e.Le = null;
     } else {
-        e.He = null;
-        e.je = 0;
+        e.me = null;
+        e.Qe = 0;
     }
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // 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 (n && !t && !(i & REACTIVE_ZOMBIE) && e.Fe !== null && !(e.Fe.u & REACTIVE_DISPOSED)) {
-        const n = e.Nt;
-        const t = e.Ve;
-        if (n !== null) n.Ve = t; else e.Fe.He = t;
-        if (t !== null) t.Nt = n;
-        e.Nt = null;
+        if (n && !t && !(i & REACTIVE_ZOMBIE) && e.Ge !== null && !(e.Ge.se & REACTIVE_DISPOSED)) {
+        const n = e.st;
+        const t = e.ve;
+        if (n !== null) n.ve = t; else e.Ge.me = t;
+        if (t !== null) t.st = n;
+        e.st = null;
     }
     runDisposal(e, t);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (n && e.dt) {
-        const n = e.dt;
-        e.dt = undefined;
+        if (n && e.Et) {
+        const n = e.Et;
+        e.Et = undefined;
         n();
     }
 }
 
 function runDisposal(e, n) {
-    let t = n ? e.We : e.Me;
+    let t = n ? e.ye : e.xe;
     if (!t) return;
     if (Array.isArray(t)) {
         for (let e = 0; e < t.length; e++) {
@@ -108,13 +108,13 @@ function runDisposal(e, n) {
     } else {
         t.call(t);
     }
-    n ? e.We = null : e.Me = null;
+    n ? e.ye = null : e.xe = null;
 }
 
 function childId(e, n) {
     let t = e;
-    while (t.U & CONFIG_TRANSPARENT && t.Fe) t = t.Fe;
-    if (t.id != null) return formatId(t.id, n ? t.je++ : t.je);
+    while (t.T & CONFIG_TRANSPARENT && t.Ge) t = t.Ge;
+    if (t.id != null) return formatId(t.id, n ? t.Qe++ : t.Qe);
     throw new Error("");
 }
 
@@ -195,7 +195,7 @@ function formatId(e, n) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.Me) context.Me = e; else if (Array.isArray(context.Me)) context.Me.push(e); else context.Me = [ context.Me, e ];
+    if (!context.xe) context.xe = e; else if (Array.isArray(context.xe)) context.xe.push(e); else context.xe = [ context.xe, e ];
     return e;
 }
 
@@ -215,7 +215,7 @@ function formatId(e, n) {
  * }
  * ```
  */ function isDisposed(e) {
-    return !!(e.u & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+    return !!(e.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
 }
 
 function disposeRootSelf(e = true) {
@@ -234,29 +234,29 @@ function disposeRootSelf(e = true) {
     const t = e?.transparent ?? false;
     const i = {
         id: inheritId(e, t, n),
-        U: t ? CONFIG_TRANSPARENT : 0,
-        At: true,
-        Ct: n?.At ? n.Ct : n,
-        He: null,
-        Ve: null,
-        Nt: null,
-        Me: null,
-        v: n?.v ?? globalQueue,
+        T: t ? CONFIG_TRANSPARENT : 0,
+        ft: true,
+        Nt: n?.ft ? n.Nt : n,
+        me: null,
+        ve: null,
+        st: null,
+        xe: null,
+        C: n?.C ?? globalQueue,
         we: n?.we || defaultContext,
-        je: 0,
-        We: null,
-        Ze: null,
-        Fe: n,
+        Qe: 0,
+        ye: null,
+        Le: null,
+        Ge: n,
         dispose: disposeRootSelf
     };
     if (n) {
-        const e = n.He;
+        const e = n.me;
         if (e === null) {
-            n.He = i;
+            n.me = i;
         } else {
-            i.Ve = e;
-            e.Nt = i;
-            n.He = i;
+            i.ve = e;
+            e.st = i;
+            n.me = i;
         }
     }
     return i;