@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.4

package/dist/prod/core/graph.js

@@ -1,4 +1,4 @@
-import { CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, STATUS_PENDING, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
+import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
 
 import { deleteFromHeap, queueFor } from "./heap.js";
 
@@ -8,36 +8,36 @@ import { bumpNotifyEpoch } from "./scheduler.js";
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(e) {
-    const l = e.ut;
-    const n = e.it;
-    const u = e.fe;
-    const s = e.el;
-    if (u !== null) u.el = s; else l.rt = s;
-    if (s !== null) s.fe = u; else {
-        l.u = u;
-        if (u === null) {
-            l.o?.ft?.();
+    const n = e.ut;
+    const l = e.it;
+    const o = e.ae;
+    const u = e.en;
+    if (o !== null) o.en = u; else n.rt = u;
+    if (u !== null) u.ae = o; else {
+        n.u = o;
+        if (o === null) {
+            n.o?.ft?.();
             // 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
             // the work and re-execute it on the next read. The settle path runs
             // this same last-one-out check when that observer releases (the
-            // untracked-read dispose in core.ts guards on pending identically).
-                        const e = l;
-            e.Se && e.T & CONFIG_AUTO_DISPOSE && !(e.ie & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+            // untracked-read dormancy sweep guards on pending identically).
+                        const e = n;
+            e.oe && e.T & CONFIG_AUTO_DISPOSE && !(e.ie & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
         }
     }
-    return n;
+    return l;
 }
 
 function trimStaleDeps(e) {
-    const l = e.Ye;
-    let n = l !== null ? l.it : e.nt;
-    if (n !== null) {
+    const n = e.Ye;
+    let l = n !== null ? n.it : e.nt;
+    if (l !== null) {
         do {
-            n = unlinkSubs(n);
-        } while (n !== null);
-        if (l !== null) l.it = null; else e.nt = null;
+            l = unlinkSubs(l);
+        } while (l !== null);
+        if (n !== null) n.it = null; else e.nt = null;
     }
 }
 
@@ -46,11 +46,11 @@ function trimStaleDeps(e) {
 // and skipping early also avoids adding one (hidden-class churn) via the
 // null-out below.
 function clearDeps(e) {
-    let l = e.nt;
-    if (!l) return;
+    let n = e.nt;
+    if (!n) return;
     do {
-        l = unlinkSubs(l);
-    } while (l !== null);
+        n = unlinkSubs(n);
+    } while (n !== null);
     e.nt = null;
     e.Ye = null;
 }
@@ -61,27 +61,63 @@ function unobserved(e) {
     disposeChildren(e, true);
 }
 
+/**
+ * Deferred dormancy for never-observed auto-dispose computeds (#3078).
+ *
+ * An untracked top-level read of a subscriber-less observation-lifecycle memo
+ * used to call unobserved() inline at the end of read(). That kept the leak
+ * closed (the compute links the memo into its deps' sub lists — without a
+ * teardown point a never-observed memo is retained by its sources forever;
+ * upstream alien-signals has exactly this retention), but it made reads
+ * destructive: each read disposed the node, the next read revived it with a
+ * full recompute in whatever ambient transition/lane context happened to be
+ * current, so consecutive reads could return different answers with no write
+ * in between.
+ *
+ * Instead, reads queue the node here and the scheduler sweeps at the top of
+ * the next flush (before runHeap, so a same-tick dirtying is reclaimed
+ * instead of recomputed). Reads become idempotent within a tick (the node
+ * stays alive and serves its cache, uniform with observed memos) while
+ * reclamation still happens within one microtask — the enqueue site arms
+ * schedule(), so a flush is guaranteed even when no other work is queued.
+ */ const dormantNodes = new Set;
+
+function sweepDormant() {
+    if (dormantNodes.size === 0) return;
+    for (const e of dormantNodes) {
+        // Re-validate at sweep time: the node may have gained a subscriber (its
+        // lifecycle is the unlinkSubs cascade now), gone pending (in-flight async
+        // is an observer; the settle path re-runs last-one-out), lost its
+        // AUTO_DISPOSE bit (owner teardown strips it, #3024), or already been
+        // torn down.
+        if (!e.u && e.T & CONFIG_AUTO_DISPOSE && !(e.S & STATUS_PENDING) && !(e.ie & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+            unobserved(e);
+        }
+    }
+    dormantNodes.clear();
+}
+
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
-function link(e, l, n = false) {
+function link(e, n, l = false) {
     // Repeat touches within one pass AND-combine `_pendingObserver`: a probe
     // read (`isPending(() => x())`) beside a value read of the same dep must
     // 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 = l.Ye;
-    if (u !== null && u.ut === e) {
-        u.me &&= n;
+    const o = n.Ye;
+    if (o !== null && o.ut === e) {
+        o.me &&= l;
         return;
     }
-    let s = null;
-    const o = l.ie & REACTIVE_RECOMPUTING_DEPS;
-    if (o) {
-        s = u !== null ? u.it : l.nt;
-        if (s !== null && s.ut === e) {
-            s.ll = l.Ze;
-            l.Ye = s;
+    let u = null;
+    const t = n.ie & REACTIVE_RECOMPUTING_DEPS;
+    if (t) {
+        u = o !== null ? o.it : n.nt;
+        if (u !== null && u.ut === e) {
+            u.nn = n.Ze;
+            n.Ye = u;
             // First touch of this pass: the previous pass's label is stale.
-                        s.me = n;
+                        u.me = l;
             return;
         }
     }
@@ -90,26 +126,26 @@ function link(e, l, n = 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 t = e.rt;
-    if (t !== null && t.ae === l && (!o || t.ll === l.Ze)) {
+        const s = e.rt;
+    if (s !== null && s.ce === n && (!t || s.nn === n.Ze)) {
         // 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 (o) t.me &&= n; else t.me = n;
+        if (t) s.me &&= l; else s.me = l;
         return;
     }
-    const i = l.Ye = e.rt = {
+    const r = n.Ye = e.rt = {
         ut: e,
-        ae: l,
-        it: s,
-        el: t,
-        fe: null,
-        ll: l.Ze,
-        me: n
+        ce: n,
+        it: u,
+        en: s,
+        ae: null,
+        nn: n.Ze,
+        me: l
     };
-    if (u !== null) u.it = i; else l.nt = i;
-    if (t !== null) t.fe = i; else e.u = i;
+    if (o !== null) o.it = r; else n.nt = r;
+    if (s !== null) s.ae = r; else e.u = r;
     // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
         bumpNotifyEpoch();
 }
 
-export { clearDeps, link, trimStaleDeps, unlinkSubs, unobserved };
+export { clearDeps, dormantNodes, link, sweepDormant, trimStaleDeps, unlinkSubs, unobserved };

package/dist/prod/core/heap.js

@@ -1,6 +1,6 @@
 import "./core.js";
 
-import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, EFFECT_TRACKED, EFFECT_USER, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_ZOMBIE, REACTIVE_CHECK, REACTIVE_DIRTY, CONFIG_FW_CHILDREN } from "./constants.js";
+import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, EFFECT_TRACKED, EFFECT_USER, REACTIVE_ZOMBIE, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_CHECK, REACTIVE_DIRTY, CONFIG_FW_CHILDREN } from "./constants.js";
 
 import { zombieQueue, dirtyQueue } from "./scheduler.js";
 
@@ -27,7 +27,7 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.ve?.Ct ? e.ve.Ot?.Le : e.ve?.Le) ?? -1;
+    const t = (e.ke?.Ct ? e.ke.Ot?.Le : e.ke?.Le) ?? -1;
     if (t >= e.Le) e.Le = t + 1;
     const n = e.Le;
     const I = E.eE[n];
@@ -97,16 +97,16 @@ function markNode(e, E = REACTIVE_DIRTY) {
     const t = e.ie;
     if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
     e.ie = t & -4 | E;
-    for (let E = e.u; E !== null; E = E.fe) {
-        markNode(E.ae, REACTIVE_CHECK);
+    for (let E = e.u; E !== null; E = E.ae) {
+        markNode(E.ce, REACTIVE_CHECK);
     }
     // Firewall children (projection machinery only): gate the cold-extension
     // deref on the config bit — markNode runs per sub edge per write, and an
     // unconditional _x chase here taxed every propagation (diamond -22%).
         if (e.T & CONFIG_FW_CHILDREN) {
-        for (let E = e.o.l; E !== null; E = E.ce) {
-            for (let e = E.u; e !== null; e = e.fe) {
-                markNode(e.ae, REACTIVE_CHECK);
+        for (let E = e.o.i; E !== null; E = E.Se) {
+            for (let e = E.u; e !== null; e = e.ae) {
+                markNode(e.ce, REACTIVE_CHECK);
             }
         }
     }
@@ -130,17 +130,17 @@ function adjustHeight(e, E) {
     for (let E = e.nt; E; E = E.it) {
         const e = E.ut;
         const n = e.lt || e;
-        if (n.Se && n.Le >= t) t = n.Le + 1;
+        if (n.oe && n.Le >= t) t = n.Le + 1;
     }
     if (e.Le !== t) {
         e.Le = t;
-        for (let E = e.u; E !== null; E = E.fe) {
+        for (let E = e.u; E !== null; E = E.ae) {
             // 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
             // `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap`
             // relies on — the same corruption class as #2759.
-            insertIntoHeapHeight(E.ae, queueFor(E.ae));
+            insertIntoHeapHeight(E.ce, queueFor(E.ce));
         }
     }
 }

package/dist/prod/core/lanes.js

@@ -20,16 +20,16 @@ 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.o?.It;
+        const i = n.o?.Et;
     const t = i?.o?.Be;
     const r = t ? findLane(t) : null;
     e = {
-        nn: n,
+        tn: n,
         Ae: new Set,
-        en: [ [], [] ],
-        tn: null,
+        rn: [ [], [] ],
+        an: null,
         _e: activeTransition,
-        rn: r
+        sn: r
     };
     signalLanes.set(n, e);
     activeLanes.add(e);
@@ -51,13 +51,13 @@ function adoptCompanionLane(n, e) {
     const t = 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 (t !== e && t.nn === n && !t.rn) t.rn = e;
+        if (t !== e && t.tn === n && !t.sn) t.sn = e;
 }
 
 /**
  * Union-find: find the root lane.
  */ function findLane(n) {
-    while (n.tn) n = n.tn;
+    while (n.an) n = n.an;
     return n;
 }
 
@@ -67,16 +67,16 @@ function adoptCompanionLane(n, e) {
     n = findLane(n);
     e = findLane(e);
     if (n === e) return n;
-    e.tn = n;
+    e.an = 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.Ae) n.Ae.add(i);
     e.Ae.clear();
-    n.en[0].push(...e.en[0]);
-    n.en[1].push(...e.en[1]);
-    e.en[0].length = 0;
-    e.en[1].length = 0;
+    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;
 }
 
@@ -97,10 +97,10 @@ 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.o?.Et) {
-        const e = ext(n).Et = currentTransition(n.o?.Et);
-        if (e.an !== true) return e;
-        if (n.o !== null) n.o.Et = null;
+    if (hasActiveOverride(n) && n.o?.Nt) {
+        const e = ext(n).Nt = currentTransition(n.o?.Nt);
+        if (e.fn !== true) return e;
+        if (n.o !== null) n.o.Nt = null;
     }
     return resolveLane(n)?._e ?? n._e;
 }
@@ -122,7 +122,7 @@ function resolveTransition(n) {
         // 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 (t.tn) {
+        if (t.an) {
             ext(n).Be = e;
             n.T |= CONFIG_HAS_LANE;
             return;
@@ -132,10 +132,10 @@ function resolveTransition(n) {
             if (r !== i && !hasActiveOverride(n)) {
                 // Parent-child lanes stay independent so isPending resolves without
                 // waiting for the parent's async. The child keeps ownership.
-                if (i.rn && findLane(i.rn) === r) {
+                if (i.sn && findLane(i.sn) === r) {
                     ext(n).Be = e;
                     n.T |= CONFIG_HAS_LANE;
-                } else if (r.rn && findLane(r.rn) === i) ; else mergeLanes(i, r);
+                } else if (r.sn && findLane(r.sn) === i) ; else mergeLanes(i, r);
             }
             return;
         }

package/dist/prod/core/optimistic.js

@@ -1,4 +1,4 @@
-import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, CONFIG_HAS_LANE, OVERRIDE_UNDEFINED, STATUS_PENDING, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_RENDER, EFFECT_USER } from "./constants.js";
+import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, REACTIVE_DIRTY, REACTIVE_CHECK, CONFIG_HAS_LANE, OVERRIDE_UNDEFINED, STATUS_PENDING, EFFECT_RENDER, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_USER } from "./constants.js";
 
 import { ext, latestReadActive, currentOptimisticLane, stale } from "./core.js";
 
@@ -27,7 +27,14 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     const t = e.o?.De !== NOT_PENDING;
     const i = t ? unwrapOverride(e.o?.De) : e.be;
     if (typeof n === "function") n = n(i);
-    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.Ue || !e.Ue(i, n);
+    const u = !!(e.S & STATUS_UNINITIALIZED) || 
+    // A dirty node's _value is stale (its queued recompute hasn't run — e.g.
+    // a latest() shadow marked by the previous landing's companion snap), so
+    // equality against it must not swallow the write. Without this, a sync
+    // push returning the shadow to that stale value was dropped, the snap
+    // recompute then committed the parent's old value, and the banner showed
+    // the previous transition's target (#3041 follow-up).
+    !!((e.ie ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.Ue || !e.Ue(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.
@@ -41,11 +48,11 @@ 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.k.Ke.push(e);
+     else globalQueue.m.Ke.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).
-        ext(e).Et = activeTransition;
+        ext(e).Nt = activeTransition;
     const l = getOrCreateLane(e);
     ext(e).Be = l;
     e.T |= CONFIG_HAS_LANE;
@@ -56,7 +63,7 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op.
         (e.o?.Ge !== undefined || e.o?.ge !== undefined) && GlobalQueue.Oe !== null && GlobalQueue.Oe(e, n);
-    if (e.Se !== undefined) e.Te = clock;
+    if (e.oe !== undefined) e.Te = clock;
  // §12e: computed-only slot
         insertSubs(e, true);
     schedule();
@@ -93,7 +100,7 @@ function resolveOptimisticNodes(e) {
         ext(n).De = NOT_PENDING;
         if (i !== NOT_PENDING && n.be !== unwrapOverride(i)) insertSubs(n, true);
         n._e = null;
-        if (n.o !== null) n.o.Et = null;
+        if (n.o !== null) n.o.Nt = 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
@@ -101,7 +108,7 @@ function resolveOptimisticNodes(e) {
         for (let t = 0; t < n; t++) {
         const n = e[t];
         if (n.o?.Ge || n.o?.ge) GlobalQueue.un(n);
-        const i = n.o?.It;
+        const i = n.o?.Et;
         if (i && (i.o?.Ge === n || i.o?.ge === n)) GlobalQueue.un(i);
     }
     e.splice(0, n);
@@ -115,29 +122,32 @@ 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.Ae.size > 0) continue;
-        const t = n.en[e - 1];
+        if (n.an || n.Ae.size > 0) continue;
+        const t = n.rn[e - 1];
         if (t.length) {
-            n.en[e - 1] = [];
+            n.rn[e - 1] = [];
             runQueue(t, e);
         }
     }
+    // Optimistic patch applications ride the same visibility slot as lane
+    // effects (in-flight DOM updates); no-op unless patches registered.
+        if (e === EFFECT_RENDER) GlobalQueue.ln?.();
 }
 
 function cleanupCompletedLanes(e) {
     for (const n of activeLanes) {
         const t = e ? n._e === e : !n._e;
         if (!t) continue;
-        if (!n.tn) {
-            if (n.en[0].length) runQueue(n.en[0], EFFECT_RENDER);
-            if (n.en[1].length) runQueue(n.en[1], EFFECT_USER);
+        if (!n.an) {
+            if (n.rn[0].length) runQueue(n.rn[0], EFFECT_RENDER);
+            if (n.rn[1].length) runQueue(n.rn[1], EFFECT_USER);
         }
-        if (n.nn.o?.Be === n) if (n.nn.o !== null) n.nn.o.Be = undefined;
+        if (n.tn.o?.Be === n) if (n.tn.o !== null) n.tn.o.Be = undefined;
         n.Ae.clear();
-        n.en[0].length = 0;
-        n.en[1].length = 0;
+        n.rn[0].length = 0;
+        n.rn[1].length = 0;
         activeLanes.delete(n);
-        signalLanes.delete(n.nn);
+        signalLanes.delete(n.tn);
     }
 }
 
@@ -155,10 +165,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.Pe === NOT_PENDING || e.Se || n !== e && !(n.ie & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e.Pe === NOT_PENDING || e.oe || n !== e && !(n.ie & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
-    activeTransition.ln.add(t);
+    activeTransition.cn.add(t);
     return true;
 }
 
@@ -166,16 +176,31 @@ 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) {
-    if (e.o?.De !== undefined || !!e.o?.Be || !!(n.S & STATUS_PENDING)) return true;
-    if (n === e && stale && t.o?.It !== 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.Pe !== NOT_PENDING && activeTransition === null) globalQueue.k.ln.add(t);
+    if (e.o?.De !== undefined || !!e.o?.Be || !!(n.S & STATUS_PENDING)) {
+        // The committed view hides a staged in-flight value that will promote
+        // silently (commitPendingNode never re-notifies). gatedRead records plain
+        // signals for replay at commit; async memos are excluded from it by the
+        // `_fn` check and reach here instead — a lane-assigned source whose async
+        // already settled (laneAsyncSettled keeps _optimisticLane) served its
+        // committed value to a reader that never re-ran after the landing, so a
+        // pending-gated branch stayed one value behind permanently (#3041
+        // follow-up). Record the reader under the same replay contract.
+        if (e.Pe !== NOT_PENDING) (activeTransition ?? globalQueue.m).cn.add(t);
+        return true;
+    }
+    if (n === e && stale && t.o?.Et !== e) {
+        // The committed view can hide a staged write (a lane member — even just
+        // an isPending companion flip — puts the reader "under a lane"). The
+        // staged value commits with no re-delivery (commitPendingNode never
+        // re-notifies), so record the reader for replay at commit — the same
+        // contract gatedRead provides (#2963). gatedRead itself only covers
+        // signal reads where the reading computed differs from the source; the
+        // owner === el memo/self read lands here instead. With a transaction
+        // active the staged value promotes silently at ITS landing, so record
+        // into the transaction (#3041 follow-up: a pending-gated branch that
+        // first read its async source during the landing flush stayed one value
+        // behind permanently); with none, into the ambient batch.
+        if (e.Pe !== NOT_PENDING) (activeTransition ?? globalQueue.m).cn.add(t);
         return true;
     }
     return false;
@@ -198,7 +223,7 @@ function cleanupCompletedLanes(e) {
         // recompute() runs plain: the value stages and commits with the flush.
         // (el's own override slot excludes companions themselves; a lane merged
         // into a real optimistic lane resolves to a non-companion source.)
-                if (!globalQueue.sn && !activeTransition && !n._e && n.nn.o?.It !== undefined && e.o?.De === undefined) {
+                if (!globalQueue.En && !activeTransition && !n._e && n.tn.o?.Et !== undefined && e.o?.De === undefined) {
             if (e.o !== null) e.o.Be = undefined;
             return false;
         }
@@ -220,11 +245,11 @@ function cleanupCompletedLanes(e) {
 
 /** recompute()'s catch path: track pending async in the current lane. */ function laneAsyncPending(e) {
     const n = findLane(currentOptimisticLane);
-    if (n.nn !== e) {
+    if (n.tn !== e) {
         n.Ae.add(e);
         ext(e).Be = n;
         e.T |= CONFIG_HAS_LANE;
-        GlobalQueue.de !== null && GlobalQueue.de(n.nn);
+        GlobalQueue.de !== null && GlobalQueue.de(n.tn);
     }
 }
 
@@ -232,13 +257,13 @@ function cleanupCompletedLanes(e) {
     const n = resolveLane(e);
     if (n) {
         n.Ae.delete(e);
-        GlobalQueue.de !== null && GlobalQueue.de(n.nn);
+        GlobalQueue.de !== null && GlobalQueue.de(n.tn);
     }
 }
 
 function trackOptimisticStore(e) {
     // After initTransition, globalQueue._batch IS activeTransition (same reference)
-    globalQueue.k.cn.add(e);
+    globalQueue.m.Tn.add(e);
     schedule();
 }
 
@@ -247,19 +272,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.vt !== null) return;
-    GlobalQueue.vt = optimisticWrite;
-    GlobalQueue.fn = resolveOptimisticNodes;
-    GlobalQueue.dn = transitionBlocked;
-    GlobalQueue.En = cleanupCompletedLanes;
-    GlobalQueue.Tn = runLaneEffects;
+    if (GlobalQueue.kt !== null) return;
+    GlobalQueue.kt = optimisticWrite;
+    GlobalQueue.dn = resolveOptimisticNodes;
+    GlobalQueue.In = transitionBlocked;
+    GlobalQueue.Nn = cleanupCompletedLanes;
+    GlobalQueue._n = runLaneEffects;
     GlobalQueue.Ft = gatedRead;
     GlobalQueue.ht = laneSuspends;
     GlobalQueue.gt = laneReadsCommitted;
     GlobalQueue.je = recomputeLane;
     GlobalQueue.$e = laneAsyncPending;
     GlobalQueue.ze = laneAsyncSettled;
-    GlobalQueue.Nn = trackOptimisticStore;
+    GlobalQueue.An = trackOptimisticStore;
 }
 
 export { installOptimisticEngine };

package/dist/prod/core/owner.js

@@ -1,4 +1,4 @@
-import { REACTIVE_DISPOSED, REACTIVE_ZOMBIE, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, CONFIG_TRANSPARENT, defaultContext, CONFIG_AUTO_DISPOSE } from "./constants.js";
+import { REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, CONFIG_TRANSPARENT, defaultContext } from "./constants.js";
 
 import { context, runWithOwner, pendingCheckActive, latestReadActive, tracking } from "./core.js";
 
@@ -12,7 +12,7 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let t = e.ke;
+    let t = e.ve;
     while (t) {
         const e = t.ie;
         t.ie = e | REACTIVE_ZOMBIE;
@@ -54,8 +54,8 @@ function disposeChildren(e, t = false, n) {
                 const t = e;
         if (t.o?.Ge || t.o?.ge) GlobalQueue.un(t);
     }
-    if (t && e.Se && e.o !== null) e.o.Ee = null;
-    let o = n ? e.o?.qe ?? null : e.ke;
+    if (t && e.oe && e.o !== null) e.o.Ee = null;
+    let o = n ? e.o?.qe ?? null : e.ve;
     while (o) {
         const e = o.Ve;
         const t = o;
@@ -82,17 +82,17 @@ function disposeChildren(e, t = false, n) {
     if (n) {
         if (e.o !== null) e.o.qe = null;
     } else {
-        e.ke = null;
+        e.ve = null;
         e.Me = 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 (t && !n && !(i & REACTIVE_ZOMBIE) && e.ve !== null && !(e.ve.ie & REACTIVE_DISPOSED)) {
+        if (t && !n && !(i & REACTIVE_ZOMBIE) && e.ke !== null && !(e.ke.ie & REACTIVE_DISPOSED)) {
         const t = e.ct;
         const n = e.Ve;
-        if (t !== null) t.Ve = n; else e.ve.ke = n;
+        if (t !== null) t.Ve = n; else e.ke.ve = n;
         if (n !== null) n.ct = t;
         e.ct = null;
     }
@@ -124,7 +124,7 @@ function runDisposal(e, t) {
 
 function childId(e, t) {
     let n = e;
-    while (n.T & CONFIG_TRANSPARENT && n.ve) n = n.ve;
+    while (n.T & CONFIG_TRANSPARENT && n.ke) n = n.ke;
     if (n.id != null) return formatId(n.id, t ? n.Me++ : n.Me);
     throw new Error("");
 }
@@ -248,7 +248,7 @@ function disposeRootSelf(e = true) {
         T: n ? CONFIG_TRANSPARENT : 0,
         Ct: true,
         Ot: t?.Ct ? t.Ot : t,
-        ke: null,
+        ve: null,
         Ve: null,
         ct: null,
         he: null,
@@ -256,17 +256,17 @@ function disposeRootSelf(e = true) {
         we: t?.we || defaultContext,
         Me: 0,
         o: null,
-        ve: t,
+        ke: t,
         dispose: disposeRootSelf
     };
     if (t) {
-        const e = t.ke;
+        const e = t.ve;
         if (e === null) {
-            t.ke = i;
+            t.ve = i;
         } else {
             i.Ve = e;
             e.ct = i;
-            t.ke = i;
+            t.ve = i;
         }
     }
     return i;