@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.7

package/dist/prod/core/optimistic.js

@@ -6,7 +6,7 @@ import { NotReadyError } from "./error.js";
 
 import "./invariants.js";
 
-import { resolveTransition, getOrCreateLane, hasActiveOverride, activeLanes, signalLanes, findLane, resolveLane, assignOrMergeLane } from "./lanes.js";
+import { resolveTransition, getOrCreateLane, hasActiveOverride, activeLanes, signalLanes, laneHeld, findLane, resolveLane, assignOrMergeLane } from "./lanes.js";
 
 import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule } from "./scheduler.js";
 
@@ -48,13 +48,13 @@ 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.Xe.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).Nt = activeTransition;
-    const l = getOrCreateLane(e);
-    ext(e).Je = l;
+        ext(e).Tt = activeTransition;
+    const r = getOrCreateLane(e);
+    ext(e).$e = r;
     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
@@ -75,8 +75,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.Xe.length; n++) {
+        const t = e.Xe[n];
         if (hasActiveOverride(t) && "S" in t && t.S & STATUS_PENDING && t.o?._ instanceof NotReadyError) {
             return true;
         }
@@ -91,7 +91,7 @@ function resolveOptimisticNodes(e) {
     const n = e.length;
     for (let t = 0; t < n; t++) {
         const n = e[t];
-        if (n.o !== null) n.o.Je = undefined;
+        if (n.o !== null) n.o.$e = 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).
@@ -100,7 +100,7 @@ function resolveOptimisticNodes(e) {
         ext(n).Pe = NOT_PENDING;
         if (i !== NOT_PENDING && n.be !== unwrapOverride(i)) insertSubs(n, true);
         n.Ae = null;
-        if (n.o !== null) n.o.Nt = null;
+        if (n.o !== null) n.o.Tt = 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
@@ -108,7 +108,7 @@ function resolveOptimisticNodes(e) {
         for (let t = 0; t < n; t++) {
         const n = e[t];
         if (n.o?.ye || n.o?.Ce) GlobalQueue.un(n);
-        const i = n.o?.Tt;
+        const i = n.o?.St;
         if (i && (i.o?.ye === n || i.o?.Ce === n)) GlobalQueue.un(i);
     }
     e.splice(0, n);
@@ -119,10 +119,11 @@ function runQueue(e, n) {
 }
 
 /**
- * Run effects from all lanes that are ready (no pending async).
+ * Run effects from all lanes that are ready (no OBSERVED pending async — see
+ * laneHeld).
  */ function runLaneEffects(e) {
     for (const n of activeLanes) {
-        if (n.rn || n.Oe.size > 0) continue;
+        if (n.rn || laneHeld(n)) continue;
         const t = n.tn[e - 1];
         if (t.length) {
             n.tn[e - 1] = [];
@@ -142,7 +143,7 @@ function cleanupCompletedLanes(e) {
             if (n.tn[0].length) runQueue(n.tn[0], EFFECT_RENDER);
             if (n.tn[1].length) runQueue(n.tn[1], EFFECT_USER);
         }
-        if (n.nn.o?.Je === n) if (n.nn.o !== null) n.nn.o.Je = undefined;
+        if (n.nn.o?.$e === n) if (n.nn.o !== null) n.nn.o.$e = undefined;
         n.Oe.clear();
         n.tn[0].length = 0;
         n.tn[1].length = 0;
@@ -152,10 +153,18 @@ function cleanupCompletedLanes(e) {
 }
 
 /** read()'s per-lane suspension test (pending-throw path, lane context). */ function laneSuspends(e) {
+    // An UNINITIALIZED async source suspends regardless of lane (#3276): a
+    // lane mismatch preserves an already-committed stale value, but a source
+    // with no committed truth has nothing to serve — the cross-lane read
+    // surfaced a fabricated `undefined` where latest() itself suspends
+    // (latestRead rethrows NotReady for tracked uninitialized reads). Lives
+    // here rather than read()'s throw path so the floor bundles don't pay:
+    // this is only reachable under a lane, which implies the engine.
+    if (e.S & STATUS_UNINITIALIZED) return true;
     // 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.o?.Je;
+        const n = e.o?.$e;
     if (!n) return false;
     return findLane(n) === findLane(currentOptimisticLane) && !hasActiveOverride(e);
 }
@@ -176,7 +185,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.o?.Pe !== undefined || !!e.o?.Je || !!(n.S & STATUS_PENDING)) {
+    if (e.o?.Pe !== undefined || !!e.o?.$e || !!(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
@@ -188,7 +197,7 @@ function cleanupCompletedLanes(e) {
         if (e.Re !== NOT_PENDING) (activeTransition ?? globalQueue.m).cn.add(t);
         return true;
     }
-    if (n === e && stale && t.o?.Tt !== e) {
+    if (n === e && stale && t.o?.St !== 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
@@ -223,14 +232,14 @@ 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.fn && !activeTransition && !n.Ae && n.nn.o?.Tt !== undefined && e.o?.Pe === undefined) {
-            if (e.o !== null) e.o.Je = undefined;
+                if (!globalQueue.fn && !activeTransition && !n.Ae && n.nn.o?.St !== undefined && e.o?.Pe === undefined) {
+            if (e.o !== null) e.o.$e = undefined;
             return false;
         }
         return n;
     }
-    for (let n = e.ut; n; n = n.lt) {
-        const t = n.ot;
+    for (let n = e.lt; n; n = n.ot) {
+        const t = n.st;
         if (t.ie & REACTIVE_OPTIMISTIC_DIRTY) {
             const n = resolveLane(t);
             if (n) {
@@ -243,13 +252,15 @@ function cleanupCompletedLanes(e) {
     return null;
 }
 
-/** recompute()'s catch path: track pending async in the current lane. */ function laneAsyncPending(e) {
+/** recompute()'s catch path: record the pending async as the current lane's
+ * (ownership — laneHeld decides the hold). The lane source's isPending
+ * companion is NOT refreshed here: its verdict never read _pendingAsync, and
+ * the source's own write/commit/settlement paths keep it current. */ function laneAsyncPending(e) {
     const n = findLane(currentOptimisticLane);
     if (n.nn !== e) {
         n.Oe.add(e);
-        ext(e).Je = n;
+        ext(e).$e = n;
         e.T |= CONFIG_HAS_LANE;
-        GlobalQueue.de !== null && GlobalQueue.de(n.nn);
     }
 }
 
@@ -257,7 +268,6 @@ function cleanupCompletedLanes(e) {
     const n = resolveLane(e);
     if (n) {
         n.Oe.delete(e);
-        GlobalQueue.de !== null && GlobalQueue.de(n.nn);
     }
 }
 
@@ -272,18 +282,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.xt !== null) return;
-    GlobalQueue.xt = optimisticWrite;
+    if (GlobalQueue.yt !== null) return;
+    GlobalQueue.yt = optimisticWrite;
     GlobalQueue.Tn = resolveOptimisticNodes;
     GlobalQueue.dn = transitionBlocked;
     GlobalQueue.In = cleanupCompletedLanes;
     GlobalQueue.Nn = runLaneEffects;
-    GlobalQueue.vt = gatedRead;
-    GlobalQueue.Vt = laneSuspends;
-    GlobalQueue.bt = laneReadsCommitted;
-    GlobalQueue.Be = recomputeLane;
-    GlobalQueue.$e = laneAsyncPending;
-    GlobalQueue.Xe = laneAsyncSettled;
+    GlobalQueue.Ut = gatedRead;
+    GlobalQueue.kt = laneSuspends;
+    GlobalQueue.xt = laneReadsCommitted;
+    GlobalQueue.Je = recomputeLane;
+    GlobalQueue.tt = laneAsyncPending;
+    GlobalQueue.et = laneAsyncSettled;
     GlobalQueue._n = trackOptimisticStore;
 }
 

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 t = e.xe;
+    let t = e.Qe;
     while (t) {
         const e = t.ie;
         t.ie = e | REACTIVE_ZOMBIE;
@@ -26,7 +26,7 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(t, zombieQueue); else insertIntoHeapHeight(t, zombieQueue);
         }
         markDisposal(t);
-        t = t.Le;
+        t = t.We;
     }
 }
 
@@ -55,9 +55,9 @@ function disposeChildren(e, t = false, n) {
         if (t.o?.ye || t.o?.Ce) GlobalQueue.un(t);
     }
     if (t && e.oe && e.o !== null) e.o.Ie = null;
-    let o = n ? e.o?.Ye ?? null : e.xe;
+    let o = n ? e.o?.Ke ?? null : e.Qe;
     while (o) {
-        const e = o.Le;
+        const e = o.We;
         const t = o;
         // Owner teardown is death regardless of the child's own lifecycle
         // (#3024): strip AUTO_DISPOSE so a post-disposal read freezes at the
@@ -80,34 +80,34 @@ function disposeChildren(e, t = false, n) {
         o = e;
     }
     if (n) {
-        if (e.o !== null) e.o.Ye = null;
+        if (e.o !== null) e.o.Ke = null;
     } else {
-        e.xe = null;
-        e.Ze = 0;
+        e.Qe = null;
+        e.je = 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.ke !== null && !(e.ke.ie & REACTIVE_DISPOSED)) {
-        const t = e.ft;
-        const n = e.Le;
-        if (t !== null) t.Le = n; else e.ke.xe = n;
-        if (n !== null) n.ft = t;
-        e.ft = null;
+        if (t && !n && !(i & REACTIVE_ZOMBIE) && e.Le !== null && !(e.Le.ie & REACTIVE_DISPOSED)) {
+        const t = e.It;
+        const n = e.We;
+        if (t !== null) t.We = n; else e.Le.Qe = n;
+        if (n !== null) n.It = t;
+        e.It = null;
     }
     runDisposal(e, n);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (t && e.Rt) {
-        const t = e.Rt;
-        e.Rt = undefined;
+        if (t && e.Gt) {
+        const t = e.Gt;
+        e.Gt = undefined;
         t();
     }
 }
 
 function runDisposal(e, t) {
-    let n = t ? e.o?.qe : e.Ge;
+    let n = t ? e.o?.Ze : e.Ge;
     if (!n) return;
     if (Array.isArray(n)) {
         for (let e = 0; e < n.length; e++) {
@@ -118,14 +118,14 @@ function runDisposal(e, t) {
         n.call(n);
     }
     if (t) {
-        if (e.o !== null) e.o.qe = null;
+        if (e.o !== null) e.o.Ze = null;
     } else e.Ge = null;
 }
 
 function childId(e, t) {
     let n = e;
-    while (n.T & CONFIG_TRANSPARENT && n.ke) n = n.ke;
-    if (n.id != null) return formatId(n.id, t ? n.Ze++ : n.Ze);
+    while (n.T & CONFIG_TRANSPARENT && n.Le) n = n.Le;
+    if (n.id != null) return formatId(n.id, t ? n.je++ : n.je);
     throw new Error("");
 }
 
@@ -246,27 +246,27 @@ function disposeRootSelf(e = true) {
     const i = {
         id: inheritId(e, n, t),
         T: n ? CONFIG_TRANSPARENT : 0,
-        Gt: true,
-        Dt: t?.Gt ? t.Dt : t,
-        xe: null,
-        Le: null,
-        ft: null,
+        Dt: true,
+        Pt: t?.Dt ? t.Pt : t,
+        Qe: null,
+        We: null,
+        It: null,
         Ge: null,
         C: t?.C ?? globalQueue,
         we: t?.we || defaultContext,
-        Ze: 0,
+        je: 0,
         o: null,
-        ke: t,
+        Le: t,
         dispose: disposeRootSelf
     };
     if (t) {
-        const e = t.xe;
+        const e = t.Qe;
         if (e === null) {
-            t.xe = i;
+            t.Qe = i;
         } else {
-            i.Le = e;
-            e.ft = i;
-            t.xe = i;
+            i.We = e;
+            e.It = i;
+            t.Qe = i;
         }
     }
     return i;