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

package/dist/prod/core/lanes.js

@@ -1,4 +1,6 @@
-import { NOT_PENDING } from "./constants.js";
+import { NOT_PENDING, CONFIG_HAS_LANE } from "./constants.js";
+
+import { ext } from "./core.js";
 
 import { currentTransition, activeTransition } from "./scheduler.js";
 
@@ -18,15 +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.nn;
-    const r = i?.Ke ? findLane(i.Ke) : null;
+        const i = n.o?.It;
+    const t = i?.o?.Be;
+    const r = t ? findLane(t) : null;
     e = {
-        en: n,
+        nn: n,
         Ae: new Set,
-        rn: [ [], [] ],
+        en: [ [], [] ],
         tn: null,
-        Ne: activeTransition,
-        an: r
+        _e: activeTransition,
+        rn: r
     };
     signalLanes.set(n, e);
     activeLanes.add(e);
@@ -36,8 +39,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.o?.Ge, e);
+    adoptCompanionLane(n.o?.ge, e);
     return e;
 }
 
@@ -45,10 +48,10 @@ function adoptCompanionLane(n, e) {
     if (!n) return;
     const i = signalLanes.get(n);
     if (!i) return;
-    const r = findLane(i);
+    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 (r !== e && r.en === n && !r.an) r.an = e;
+        if (t !== e && t.nn === n && !t.rn) t.rn = e;
 }
 
 /**
@@ -70,21 +73,21 @@ function adoptCompanionLane(n, e) {
     // 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.rn[0].push(...e.rn[0]);
-    n.rn[1].push(...e.rn[1]);
-    e.rn[0].length = 0;
-    e.rn[1].length = 0;
+    n.en[0].push(...e.en[0]);
+    n.en[1].push(...e.en[1]);
+    e.en[0].length = 0;
+    e.en[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.Ke;
+    const e = n.o?.Be;
     if (!e) return undefined;
     const i = findLane(e);
     if (activeLanes.has(i)) return i;
-    n.Ke = undefined;
+    if (n.o !== null) n.o.Be = undefined;
     return undefined;
 }
 
@@ -94,18 +97,19 @@ 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.sn) {
-        const e = n.sn = currentTransition(n.sn);
-        if (e.fn !== true) return e;
-        n.sn = null;
+    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;
     }
-    return resolveLane(n)?.Ne ?? n.Ne;
+    return resolveLane(n)?._e ?? n._e;
 }
 
 /**
  * Check if a node has an active optimistic override.
  */ function hasActiveOverride(n) {
-    return !!(n._e !== undefined && n._e !== NOT_PENDING);
+    const e = n.o;
+    return e !== null && e.De !== undefined && e.De !== NOT_PENDING;
 }
 
 /**
@@ -113,28 +117,31 @@ 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.Ke;
-    if (r) {
+    const t = n.o?.Be;
+    if (t) {
         // 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.Ke = e;
+        if (t.tn) {
+            ext(n).Be = e;
+            n.T |= CONFIG_HAS_LANE;
             return;
         }
-        const t = findLane(r);
-        if (activeLanes.has(t)) {
-            if (t !== i && !hasActiveOverride(n)) {
+        const r = findLane(t);
+        if (activeLanes.has(r)) {
+            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.an && findLane(i.an) === t) {
-                    n.Ke = e;
-                } else if (t.an && findLane(t.an) === i) ; else mergeLanes(i, t);
+                if (i.rn && findLane(i.rn) === r) {
+                    ext(n).Be = e;
+                    n.T |= CONFIG_HAS_LANE;
+                } else if (r.rn && findLane(r.rn) === i) ; else mergeLanes(i, r);
             }
             return;
         }
     }
-    n.Ke = e;
+    ext(n).Be = e;
+    n.T |= CONFIG_HAS_LANE;
 }
 
 export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane, resolveTransition, signalLanes };

package/dist/prod/core/optimistic.js

@@ -1,6 +1,6 @@
-import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, OVERRIDE_UNDEFINED, STATUS_PENDING, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_RENDER, EFFECT_USER } from "./constants.js";
+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 { latestReadActive, currentOptimisticLane, stale } from "./core.js";
+import { ext, latestReadActive, currentOptimisticLane, stale } from "./core.js";
 
 import { NotReadyError } from "./error.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.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.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.
@@ -41,22 +41,24 @@ 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.Me.push(e);
+     else globalQueue.k.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).
-        e.sn = activeTransition;
-    const r = getOrCreateLane(e);
-    e.Ke = r;
+        ext(e).Et = activeTransition;
+    const l = getOrCreateLane(e);
+    ext(e).Be = l;
+    e.T |= CONFIG_HAS_LANE;
     // 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;
+        ext(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.de = clock;
-    insertSubs(e, true);
+        (e.o?.Ge !== undefined || e.o?.ge !== undefined) && GlobalQueue.Oe !== null && GlobalQueue.Oe(e, n);
+    if (e.Se !== undefined) e.Te = clock;
+ // §12e: computed-only slot
+        insertSubs(e, true);
     schedule();
     return n;
 }
@@ -66,9 +68,9 @@ 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.Me.length; n++) {
-        const t = e.Me[n];
-        if (hasActiveOverride(t) && "S" in t && t.S & STATUS_PENDING && t._ instanceof NotReadyError) {
+    for (let n = 0; n < e.Ke.length; n++) {
+        const t = e.Ke[n];
+        if (hasActiveOverride(t) && "S" in t && t.S & STATUS_PENDING && t.o?._ instanceof NotReadyError) {
             return true;
         }
     }
@@ -82,25 +84,25 @@ function resolveOptimisticNodes(e) {
     const n = e.length;
     for (let t = 0; t < n; t++) {
         const n = e[t];
-        n.Ke = undefined;
+        if (n.o !== null) n.o.Be = 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._e;
-        n._e = NOT_PENDING;
-        if (i !== NOT_PENDING && n.Ue !== unwrapOverride(i)) insertSubs(n, true);
-        n.Ne = null;
-        n.sn = null;
+        const i = n.o?.De;
+        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;
     }
     // 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.ge || n.pe) GlobalQueue.un(n);
-        const i = n.nn;
-        if (i && (i.ge === n || i.pe === n)) GlobalQueue.un(i);
+        if (n.o?.Ge || n.o?.ge) GlobalQueue.un(n);
+        const i = n.o?.It;
+        if (i && (i.o?.Ge === n || i.o?.ge === n)) GlobalQueue.un(i);
     }
     e.splice(0, n);
 }
@@ -114,9 +116,9 @@ function runQueue(e, n) {
  */ function runLaneEffects(e) {
     for (const n of activeLanes) {
         if (n.tn || n.Ae.size > 0) continue;
-        const t = n.rn[e - 1];
+        const t = n.en[e - 1];
         if (t.length) {
-            n.rn[e - 1] = [];
+            n.en[e - 1] = [];
             runQueue(t, e);
         }
     }
@@ -124,18 +126,18 @@ function runQueue(e, n) {
 
 function cleanupCompletedLanes(e) {
     for (const n of activeLanes) {
-        const t = e ? n.Ne === e : !n.Ne;
+        const t = e ? n._e === e : !n._e;
         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[0].length) runQueue(n.en[0], EFFECT_RENDER);
+            if (n.en[1].length) runQueue(n.en[1], EFFECT_USER);
         }
-        if (n.en.Ke === n) n.en.Ke = undefined;
+        if (n.nn.o?.Be === n) if (n.nn.o !== null) n.nn.o.Be = undefined;
         n.Ae.clear();
-        n.rn[0].length = 0;
-        n.rn[1].length = 0;
+        n.en[0].length = 0;
+        n.en[1].length = 0;
         activeLanes.delete(n);
-        signalLanes.delete(n.en);
+        signalLanes.delete(n.nn);
     }
 }
 
@@ -143,7 +145,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.Ke;
+    const n = e.o?.Be;
     if (!n) return false;
     return findLane(n) === findLane(currentOptimisticLane) && !hasActiveOverride(e);
 }
@@ -153,7 +155,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.Pe === NOT_PENDING || e.Se || n !== e && !(n.ie & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
     activeTransition.ln.add(t);
@@ -164,8 +166,8 @@ 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 (n === e && stale && t.nn !== e) {
+    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
@@ -173,7 +175,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.Pe !== NOT_PENDING && activeTransition === null) globalQueue.k.ln.add(t);
         return true;
     }
     return false;
@@ -184,13 +186,30 @@ 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;
-    for (let n = e.tt; n; n = n.nt) {
-        const t = n.it;
-        if (t.se & REACTIVE_OPTIMISTIC_DIRTY) {
+    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.sn && !activeTransition && !n._e && n.nn.o?.It !== undefined && e.o?.De === undefined) {
+            if (e.o !== null) e.o.Be = undefined;
+            return false;
+        }
+        return n;
+    }
+    for (let n = e.nt; n; n = n.it) {
+        const t = n.ut;
+        if (t.ie & REACTIVE_OPTIMISTIC_DIRTY) {
             const n = resolveLane(t);
             if (n) {
-                e.se |= REACTIVE_OPTIMISTIC_DIRTY;
+                e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
                 assignOrMergeLane(e, n);
                 return n;
             }
@@ -201,10 +220,11 @@ 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) {
+    if (n.nn !== e) {
         n.Ae.add(e);
-        e.Ke = n;
-        GlobalQueue.Se !== null && GlobalQueue.Se(n.en);
+        ext(e).Be = n;
+        e.T |= CONFIG_HAS_LANE;
+        GlobalQueue.de !== null && GlobalQueue.de(n.nn);
     }
 }
 
@@ -212,13 +232,13 @@ function cleanupCompletedLanes(e) {
     const n = resolveLane(e);
     if (n) {
         n.Ae.delete(e);
-        GlobalQueue.Se !== null && GlobalQueue.Se(n.en);
+        GlobalQueue.de !== null && GlobalQueue.de(n.nn);
     }
 }
 
 function trackOptimisticStore(e) {
     // After initTransition, globalQueue._batch IS activeTransition (same reference)
-    globalQueue.m.cn.add(e);
+    globalQueue.k.cn.add(e);
     schedule();
 }
 
@@ -227,15 +247,15 @@ 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.Gt !== null) return;
-    GlobalQueue.Gt = optimisticWrite;
-    GlobalQueue.En = resolveOptimisticNodes;
-    GlobalQueue.Tn = transitionBlocked;
-    GlobalQueue.dn = cleanupCompletedLanes;
-    GlobalQueue.In = runLaneEffects;
-    GlobalQueue.Rt = gatedRead;
-    GlobalQueue.Ot = laneSuspends;
-    GlobalQueue.Pt = laneReadsCommitted;
+    if (GlobalQueue.vt !== null) return;
+    GlobalQueue.vt = optimisticWrite;
+    GlobalQueue.fn = resolveOptimisticNodes;
+    GlobalQueue.dn = transitionBlocked;
+    GlobalQueue.En = cleanupCompletedLanes;
+    GlobalQueue.Tn = runLaneEffects;
+    GlobalQueue.Ft = gatedRead;
+    GlobalQueue.ht = laneSuspends;
+    GlobalQueue.gt = laneReadsCommitted;
     GlobalQueue.je = recomputeLane;
     GlobalQueue.$e = laneAsyncPending;
     GlobalQueue.ze = laneAsyncSettled;