@solidjs/signals 2.0.0-rc.0 → 2.0.0-rc.1

package/dist/prod/core/graph.js

@@ -10,10 +10,10 @@ import "./scheduler.js";
 function unlinkSubs(l) {
     const n = l.it;
     const e = l.nt;
-    const u = l.le;
+    const u = l.ue;
     const s = l.ll;
     if (u !== null) u.ll = s; else n.rt = s;
-    if (s !== null) s.le = u; else {
+    if (s !== null) s.ue = u; else {
         n.o = u;
         if (u === null) {
             n.ut?.();
@@ -61,7 +61,7 @@ function link(l, n, e = false) {
     // read order within the computation.
     const u = n.Ye;
     if (u !== null && u.it === l) {
-        u.Ge &&= e;
+        u.ye &&= e;
         return;
     }
     let s = null;
@@ -72,7 +72,7 @@ function link(l, n, e = false) {
             s.nl = n.Ze;
             n.Ye = s;
             // First touch of this pass: the previous pass's label is stale.
-                        s.Ge = e;
+                        s.ye = e;
             return;
         }
     }
@@ -85,7 +85,7 @@ function link(l, n, e = false) {
     if (i !== null && i.fe === n && (!t || i.nl === 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 (t) i.Ge &&= e; else i.Ge = e;
+        if (t) i.ye &&= e; else i.ye = e;
         return;
     }
     const o = n.Ye = l.rt = {
@@ -93,12 +93,12 @@ function link(l, n, e = false) {
         fe: n,
         nt: s,
         ll: i,
-        le: null,
+        ue: null,
         nl: n.Ze,
-        Ge: e
+        ye: e
     };
     if (u !== null) u.nt = o; else n.tt = o;
-    if (i !== null) i.le = o; else l.o = o;
+    if (i !== null) i.ue = o; else l.o = o;
 }
 
 export { link, trimStaleDeps, unlinkSubs, unobserved };

package/dist/prod/core/heap.js

@@ -15,25 +15,25 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
         const E = e;
         if (!E.Je) {
             E.Je = true;
-            E.C.enqueue(EFFECT_USER, E.Ft);
+            E.C.enqueue(EFFECT_USER, E.ht);
         }
         return;
     }
     const E = queueFor(e);
-    if (E.Ve > e.xe) E.Ve = e.xe;
+    if (E.Ve > e.Le) E.Ve = e.Le;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.ke?.Nt ? e.ke.dt?.xe : e.ke?.xe) ?? -1;
-    if (t >= e.xe) e.xe = t + 1;
-    const n = e.xe;
+    const t = (e.Fe?.Tt ? e.Fe.It?.Le : e.Fe?.Le) ?? -1;
+    if (t >= e.Le) e.Le = t + 1;
+    const n = e.Le;
     const I = E.eE[n];
     if (I === undefined) E.eE[n] = e; else {
-        const E = I.st;
-        E.ot = e;
-        e.st = E;
-        I.st = e;
+        const E = I.ot;
+        E.st = e;
+        e.ot = E;
+        I.ot = e;
     }
     if (n > E.EE) E.EE = n;
 }
@@ -66,23 +66,23 @@ 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.xe;
-    if (e.st === e) E.eE[n] = undefined; else {
-        const t = e.ot;
+    const n = e.Le;
+    if (e.ot === e) E.eE[n] = undefined; else {
+        const t = e.st;
         const I = E.eE[n];
         const o = t ?? I;
-        if (e === I) E.eE[n] = t; else e.st.ot = t;
-        o.st = e.st;
+        if (e === I) E.eE[n] = t; else e.ot.st = t;
+        o.ot = e.ot;
     }
-    e.st = e;
-    e.ot = undefined;
+    e.ot = e;
+    e.st = undefined;
 }
 
 function markHeap(e) {
     if (e.tE) return;
     e.tE = true;
     for (let E = 0; E <= e.EE; E++) {
-        for (let t = e.eE[E]; t !== undefined; t = t.ot) {
+        for (let t = e.eE[E]; t !== undefined; t = t.st) {
             if (t.se & REACTIVE_IN_HEAP) markNode(t);
         }
     }
@@ -92,12 +92,12 @@ function markNode(e, E = REACTIVE_DIRTY) {
     const t = e.se;
     if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
     e.se = t & -4 | E;
-    for (let E = e.o; E !== null; E = E.le) {
+    for (let E = e.o; E !== null; E = E.ue) {
         markNode(E.fe, REACTIVE_CHECK);
     }
     if (e.u !== null) {
         for (let E = e.u; E !== null; E = E.ae) {
-            for (let e = E.o; e !== null; e = e.le) {
+            for (let e = E.o; e !== null; e = e.ue) {
                 markNode(e.fe, REACTIVE_CHECK);
             }
         }
@@ -118,15 +118,15 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.xe;
+    let t = e.Le;
     for (let E = e.tt; E; E = E.nt) {
         const e = E.it;
         const n = e.lt || e;
-        if (n.ce && n.xe >= t) t = n.xe + 1;
+        if (n.ce && n.Le >= t) t = n.Le + 1;
     }
-    if (e.xe !== t) {
-        e.xe = t;
-        for (let E = e.o; E !== null; E = E.le) {
+    if (e.Le !== t) {
+        e.Le = 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`
             // unconditionally can park a zombie in `dirtyQueue` (or a live node in

package/dist/prod/core/lanes.js

@@ -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.ge, e);
-    adoptCompanionLane(n.pe, e);
+        adoptCompanionLane(n.Oe, e);
+    adoptCompanionLane(n.ge, e);
     return e;
 }
 
@@ -105,7 +105,7 @@ function resolveTransition(n) {
 /**
  * Check if a node has an active optimistic override.
  */ function hasActiveOverride(n) {
-    return !!(n._e !== undefined && n._e !== NOT_PENDING);
+    return !!(n.De !== undefined && n.De !== NOT_PENDING);
 }
 
 /**

package/dist/prod/core/optimistic.js

@@ -24,10 +24,10 @@ 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._e !== NOT_PENDING;
-    const i = t ? unwrapOverride(e._e) : e.Ue;
+    const t = e.De !== NOT_PENDING;
+    const i = t ? unwrapOverride(e.De) : e.be;
     if (typeof n === "function") n = n(i);
-    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.be || !e.be(i, n);
+    const u = !!(e.S & STATUS_UNINITIALIZED) || !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.
@@ -51,10 +51,10 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     // 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._e = n === undefined ? OVERRIDE_UNDEFINED : n;
+        e.De = n === undefined ? OVERRIDE_UNDEFINED : n;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op.
-        (e.ge !== undefined || e.pe !== undefined) && GlobalQueue.Pe !== null && GlobalQueue.Pe(e, n);
+        (e.Oe !== undefined || e.ge !== undefined) && GlobalQueue.Pe !== null && GlobalQueue.Pe(e, n);
     e.de = clock;
     insertSubs(e, true);
     schedule();
@@ -87,9 +87,9 @@ function resolveOptimisticNodes(e) {
         // 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._e;
-        n._e = NOT_PENDING;
-        if (i !== NOT_PENDING && n.Ue !== unwrapOverride(i)) insertSubs(n, true);
+        const i = n.De;
+        n.De = NOT_PENDING;
+        if (i !== NOT_PENDING && n.be !== unwrapOverride(i)) insertSubs(n, true);
         n.Ne = null;
         n.sn = null;
     }
@@ -98,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.ge || n.pe) GlobalQueue.un(n);
+        if (n.Oe || n.ge) GlobalQueue.un(n);
         const i = n.nn;
-        if (i && (i.ge === n || i.pe === n)) GlobalQueue.un(i);
+        if (i && (i.Oe === n || i.ge === n)) GlobalQueue.un(i);
     }
     e.splice(0, n);
 }
@@ -153,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.De === NOT_PENDING || e.ce || n !== e && !(n.se & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e._e === NOT_PENDING || e.ce || n !== e && !(n.se & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
     activeTransition.ln.add(t);
@@ -164,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) {
-    if (e._e !== undefined || !!e.Ke || !!(n.S & STATUS_PENDING)) return true;
+    if (e.De !== undefined || !!e.Ke || !!(n.S & STATUS_PENDING)) return true;
     if (n === e && stale && t.nn !== 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"
@@ -173,7 +173,7 @@ function cleanupCompletedLanes(e) {
         // 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.De !== NOT_PENDING && activeTransition === null) globalQueue.m.ln.add(t);
+        if (e._e !== NOT_PENDING && activeTransition === null) globalQueue.m.ln.add(t);
         return true;
     }
     return false;
@@ -184,7 +184,24 @@ function cleanupCompletedLanes(e) {
  * a dependency's optimistic lane (own=false — parent-deeper-than-owned-child
  * can run before its OPT-dirty child propagates).
  */ function recomputeLane(e, n) {
-    if (n) return resolveLane(e) ?? null;
+    if (n) {
+        const n = resolveLane(e);
+        if (!n) return null;
+        // Wake-only lane demotion (#3009): a plain write to a latest()-tracked
+        // source rides the optimistic channel only to wake verdict companions —
+        // its lane is sourced by the companion shadow (_parentSource set) and owns
+        // no transaction. When such a node is pulled mid-tick by a latest()/
+        // isPending() probe, lane posture would direct-commit _value, leaking the
+        // queued write into committed reads before the flush. Return `false` so
+        // 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.cn && !activeTransition && !n.Ne && n.en.nn !== undefined && e.De === undefined) {
+            e.Ke = undefined;
+            return false;
+        }
+        return n;
+    }
     for (let n = e.tt; n; n = n.nt) {
         const t = n.it;
         if (t.se & REACTIVE_OPTIMISTIC_DIRTY) {
@@ -218,7 +235,7 @@ function cleanupCompletedLanes(e) {
 
 function trackOptimisticStore(e) {
     // After initTransition, globalQueue._batch IS activeTransition (same reference)
-    globalQueue.m.cn.add(e);
+    globalQueue.m.dn.add(e);
     schedule();
 }
 
@@ -231,15 +248,15 @@ function trackOptimisticStore(e) {
     GlobalQueue.Gt = optimisticWrite;
     GlobalQueue.En = resolveOptimisticNodes;
     GlobalQueue.Tn = transitionBlocked;
-    GlobalQueue.dn = cleanupCompletedLanes;
-    GlobalQueue.In = runLaneEffects;
+    GlobalQueue.In = cleanupCompletedLanes;
+    GlobalQueue.Nn = runLaneEffects;
     GlobalQueue.Rt = gatedRead;
     GlobalQueue.Ot = laneSuspends;
-    GlobalQueue.Pt = laneReadsCommitted;
+    GlobalQueue.Dt = laneReadsCommitted;
     GlobalQueue.je = recomputeLane;
-    GlobalQueue.$e = laneAsyncPending;
-    GlobalQueue.ze = laneAsyncSettled;
-    GlobalQueue.Nn = trackOptimisticStore;
+    GlobalQueue.ze = laneAsyncPending;
+    GlobalQueue.Be = laneAsyncSettled;
+    GlobalQueue.Qn = trackOptimisticStore;
 }
 
 export { installOptimisticEngine };

package/dist/prod/core/owner.js

@@ -12,7 +12,7 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let n = e.Fe;
+    let n = e.ke;
     while (n) {
         const e = n.se;
         n.se = e | REACTIVE_ZOMBIE;
@@ -55,10 +55,10 @@ function disposeChildren(e, n = false, t) {
         // 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.ge || n.pe) GlobalQueue.un(n);
+        if (n.Oe || n.ge) GlobalQueue.un(n);
     }
     if (n && e.ce) e.Te = null;
-    let l = t ? e.We : e.Fe;
+    let l = t ? e.We : e.ke;
     while (l) {
         const e = l.He;
         const n = l;
@@ -82,32 +82,32 @@ function disposeChildren(e, n = false, t) {
     if (t) {
         e.We = null;
     } else {
-        e.Fe = null;
+        e.ke = 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.ke !== null && !(e.ke.se & REACTIVE_DISPOSED)) {
+        if (n && !t && !(i & REACTIVE_ZOMBIE) && e.Fe !== null && !(e.Fe.se & REACTIVE_DISPOSED)) {
         const n = e.ct;
         const t = e.He;
-        if (n !== null) n.He = t; else e.ke.Fe = t;
+        if (n !== null) n.He = t; else e.Fe.ke = t;
         if (t !== null) t.ct = n;
         e.ct = 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.Tt) {
-        const n = e.Tt;
-        e.Tt = undefined;
+        if (n && e.Nt) {
+        const n = e.Nt;
+        e.Nt = undefined;
         n();
     }
 }
 
 function runDisposal(e, n) {
-    let t = n ? e.Qe : e.ye;
+    let t = n ? e.Qe : e.he;
     if (!t) return;
     if (Array.isArray(t)) {
         for (let e = 0; e < t.length; e++) {
@@ -117,12 +117,12 @@ function runDisposal(e, n) {
     } else {
         t.call(t);
     }
-    n ? e.Qe = null : e.ye = null;
+    n ? e.Qe = null : e.he = null;
 }
 
 function childId(e, n) {
     let t = e;
-    while (t.T & CONFIG_TRANSPARENT && t.ke) t = t.ke;
+    while (t.T & CONFIG_TRANSPARENT && t.Fe) t = t.Fe;
     if (t.id != null) return formatId(t.id, n ? t.qe++ : t.qe);
     throw new Error("");
 }
@@ -204,7 +204,7 @@ function formatId(e, n) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.ye) context.ye = e; else if (Array.isArray(context.ye)) context.ye.push(e); else context.ye = [ context.ye, e ];
+    if (!context.he) context.he = e; else if (Array.isArray(context.he)) context.he.push(e); else context.he = [ context.he, e ];
     return e;
 }
 
@@ -244,28 +244,28 @@ function disposeRootSelf(e = true) {
     const i = {
         id: inheritId(e, t, n),
         T: t ? CONFIG_TRANSPARENT : 0,
-        Nt: true,
-        dt: n?.Nt ? n.dt : n,
-        Fe: null,
+        Tt: true,
+        It: n?.Tt ? n.It : n,
+        ke: null,
         He: null,
         ct: null,
-        ye: null,
+        he: null,
         C: n?.C ?? globalQueue,
         we: n?.we || defaultContext,
         qe: 0,
         Qe: null,
         We: null,
-        ke: n,
+        Fe: n,
         dispose: disposeRootSelf
     };
     if (n) {
-        const e = n.Fe;
+        const e = n.ke;
         if (e === null) {
-            n.Fe = i;
+            n.ke = i;
         } else {
             i.He = e;
             e.ct = i;
-            n.Fe = i;
+            n.ke = i;
         }
     }
     return i;