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

package/dist/prod/core/verdict.js

@@ -1,6 +1,6 @@
 import { NOT_PENDING, REACTIVE_DISPOSED, REACTIVE_DIRTY, REACTIVE_CHECK, unwrapOverride, REACTIVE_ZOMBIE, STATUS_UNINITIALIZED, STATUS_PENDING, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_MANUAL_WRITE, CONFIG_HAS_COMPANIONS, CONFIG_CHILD_COMPANIONS, STATUS_ERROR, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
 
-import { setSignal, prepareComputed, read, context, stale, currentOptimisticLane, tracking, ext, setLatestReadActive, setContextInternal, optimisticComputed, setPendingCheckActive, latestReadActive, optimisticSignal, pendingCheckActive } from "./core.js";
+import { setSignal, pendingCheckActive, setPendingCheckActive, prepareComputed, read, context, stale, currentOptimisticLane, tracking, ext, setLatestReadActive, setContextInternal, optimisticComputed, latestReadActive, optimisticSignal } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -47,23 +47,23 @@ let pendingProbe = null;
  * O(all-leaves-ever-read)-per-update pathology). Entries are permanent like
  * the companions themselves; a store with no leaf-level isPending()/latest()
  * reads never allocates the set or pays the walk. */ function markFirewallChildCompanions(e) {
-    const t = e.lt;
+    const t = e.st;
     if (!t) return;
     t.T |= CONFIG_CHILD_COMPANIONS;
-    (ext(t).It ??= new Set).add(e);
+    (ext(t).St ??= new Set).add(e);
 }
 
 function getPendingSignal(e) {
-    let t = e.o?.Ge;
+    let t = e.o?.ye;
     if (!t) {
         // Start false, write true if pending - ensures reversion returns to false
         t = optimisticSignal(false, {
             ownedWrite: true
         });
-        ext(e).Ge = t;
+        ext(e).ye = t;
         e.T |= CONFIG_HAS_COMPANIONS;
         markFirewallChildCompanions(e);
-        ext(t).Et = e;
+        ext(t).Tt = e;
         if (computePendingState(e)) setSignal(t, true);
     }
     return t;
@@ -72,7 +72,7 @@ function getPendingSignal(e) {
 function collectPendingSources(e) {
     if (!pendingProbe) return;
     pendingProbe.sources.add(e);
-    const t = e.lt || e;
+    const t = e.st || e;
     if (t !== e) pendingProbe.sources.add(t);
 }
 
@@ -105,17 +105,17 @@ function collectPendingSources(e) {
         if (e.S & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
-    const n = e.lt;
+    const n = e.st;
     if (n && markWalk(n, t)) return true;
     // Mid-recompute (the clearStatus companion poke runs before
     // trimStaleDeps), only the validated prefix [_deps.._depsTail] is this
     // pass's dependency set — walking past it would read dropped deps and
     // latch a stale verdict on the companion.
         const i = e;
-    const r = i.ie & REACTIVE_RECOMPUTING_DEPS ? i.Ye : undefined;
+    const r = i.ie & REACTIVE_RECOMPUTING_DEPS ? i.je : undefined;
     if (r !== null) {
-        for (let e = i.nt ?? null; e !== null; e = e.it) {
-            if (!e.me && markWalk(e.ut, t)) return true;
+        for (let e = i.ut ?? null; e !== null; e = e.lt) {
+            if (!e.ve && markWalk(e.ot, t)) return true;
             if (e === r) break;
         }
     }
@@ -128,10 +128,10 @@ function collectPendingSources(e) {
 
 function quietPending(e) {
     if (e.o?.le) {
-        for (const t of e.o.le) if (!t.o?.pe) return false;
+        for (const t of e.o.le) if (!t.o?.De) return false;
         return true;
     }
-    return e.o?.pe ?? false;
+    return e.o?.De ?? false;
 }
 
 // NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
@@ -152,40 +152,44 @@ function computePendingState(e) {
     // reaches its owner (and a store leaf its firewall) through its own deps,
     // so the one walk covers direct marks, derivation, and companion chains.
         if (markCovered(e)) return true;
-    const n = e.lt;
-    if (e.o?.Et) {
-        const t = e.o?.Et;
-        const n = t.lt || t;
+    const n = e.st;
+    if (e.o?.Tt) {
+        const t = e.o?.Tt;
+        const n = t.st || t;
         return newQuestionInFlight(n);
     }
-    if (n && e.Pe !== NOT_PENDING && !hasActiveOverride(e)) {
-        return !!(n.ie & REACTIVE_MANUAL_WRITE) || !n.o?.Ee && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
+    if (n && e.Re !== NOT_PENDING && !hasActiveOverride(e)) {
+        return !!(n.ie & REACTIVE_MANUAL_WRITE) || !n.o?.Ie && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
     }
     // `!comp._loading`: a hold created while the loading window is still open is
     // the window's own landing in flight to its commit — verdict-quiet like the
     // rest of the window (the UNINITIALIZED check suppresses exactly this frame
     // for windowless first loads; born-committed nodes need their own gate, #2990).
-        if (e.Pe !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ie) {
-        if (hasActiveOverride(e)) return !e.Ue || !e.Ue(e.Pe, unwrapOverride(e.o?.De));
-        return true;
+        if (e.Re !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ne) {
+        if (hasActiveOverride(e)) return !e.pe || !e.pe(e.Re, unwrapOverride(e.o?.Pe));
+        // A quiet re-ask's held landing still answers the same question: the
+        // classification survives the landing (asyncWrite) and dies with the
+        // commit (commitPendingNode) — verdict-quiet through the reveal, like
+        // the loading window above (#3178).
+                if (!t.o?.De) return true;
     }
     return newQuestionInFlight(t);
 }
 
 function syncCompanions(e, t) {
-    if (e.o?.Ge) updatePendingSignal(e);
-    if (e.o?.ge) setSignal(e.o?.ge, t);
+    if (e.o?.ye) updatePendingSignal(e);
+    if (e.o?.Ce) setSignal(e.o?.Ce, t);
 }
 
 function updatePendingSignal(e) {
-    if (e.o?.Ge) {
-        setSignal(e.o?.Ge, computePendingState(e));
+    if (e.o?.ye) {
+        setSignal(e.o?.ye, computePendingState(e));
     }
-    if (e.o?.ge) updatePendingSignal(e.o?.ge);
+    if (e.o?.Ce) updatePendingSignal(e.o?.Ce);
 }
 
 function updateChildCompanions(e) {
-    const t = e.o?.It;
+    const t = e.o?.St;
     if (t === undefined) return;
     for (const e of t) updatePendingSignal(e);
 }
@@ -204,7 +208,7 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (i.has(e)) return;
         i.add(e);
-        if (e.o?.Ge || e.o?.ge) n(e);
+        if (e.o?.ye || e.o?.Ce) n(e);
         for (let t = e.u; t !== null; t = t.ae) visit(t.ce);
         for (let t = e.o?.i ?? null; t !== null; t = t.Se) {
             visit(t);
@@ -227,7 +231,7 @@ function updateChildCompanions(e) {
     if (suppressedProbes.size === 0) return;
     let t = false;
     for (const [n, i] of suppressedProbes) {
-        const r = n._e;
+        const r = n.Ae;
         const s = r ? currentTransition(r) : null;
         if (!s) {
             suppressedProbes.delete(n);
@@ -235,11 +239,11 @@ function updateChildCompanions(e) {
         }
         if (s !== e) continue;
         suppressedProbes.delete(n);
-        const o = n.o?.Ge?.o?.Be;
+        const o = n.o?.ye?.o?.Je;
         for (const e of i) {
             if (e.ie & REACTIVE_DISPOSED) continue;
             e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
-            if (o) assignOrMergeLane(e, o); else if (e.o !== null) e.o.Be = undefined;
+            if (o) assignOrMergeLane(e, o); else if (e.o !== null) e.o.Je = undefined;
             enqueueSub(e);
             t = true;
         }
@@ -249,19 +253,19 @@ function updateChildCompanions(e) {
 
 function snapCompanionsToState(e) {
     suppressedProbes.size !== 0 && suppressedProbes.delete(e);
-    const t = e.o?.Ge;
-    if (t && (t.o?.De === undefined || t.o?.De === NOT_PENDING)) {
+    const t = e.o?.ye;
+    if (t && (t.o?.Pe === undefined || t.o?.Pe === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.be !== n || t.Pe !== NOT_PENDING) {
+        if (t.be !== n || t.Re !== NOT_PENDING) {
             t.be = n;
-            t.Pe = NOT_PENDING;
+            t.Re = NOT_PENDING;
             insertSubs(t);
             schedule();
         }
     }
-    const n = e.o?.ge;
+    const n = e.o?.Ce;
     if (n && !(n.ie & REACTIVE_DISPOSED)) {
-        if ((n.o?.De === undefined || n.o?.De === NOT_PENDING) && n.Pe === NOT_PENDING && !Object.is(n.be, e.be) && !(n.ie & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n.o?.Pe === undefined || n.o?.Pe === NOT_PENDING) && n.Re === NOT_PENDING && !Object.is(n.be, e.be) && !(n.ie & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
             n.ie |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
@@ -272,7 +276,7 @@ function snapCompanionsToState(e) {
 }
 
 function getLatestValueComputed(e) {
-    let t = e.o?.ge;
+    let t = e.o?.Ce;
     // A shadow disposed while unobserved (its gated reader unmounted at a
     // landing) is a corpse: sync writes into it equality-swallow against its
     // frozen _value, and a later read revives it via recompute — clearing
@@ -289,16 +293,16 @@ function getLatestValueComputed(e) {
         setContextInternal(null);
  // Detach from owner so it isn't disposed with effects
                 t = optimisticComputed(() => read(e));
-        ext(e).ge = t;
+        ext(e).Ce = t;
         e.T |= CONFIG_HAS_COMPANIONS;
         markFirewallChildCompanions(e);
-        ext(t).Et = e;
+        ext(t).Tt = e;
  // Parent-child lane relationship
         // Backfill an in-flight write (mirrors getPendingSignal): the companion is
         // created lazily, possibly after the write was processed — syncCompanions
         // only pushes into companions that already exist, so the first latest()
         // read inside a held transition showed the committed value (#3041).
-                if (e.Pe !== NOT_PENDING && !hasActiveOverride(e)) setSignal(t, e.Pe);
+                if (e.Re !== NOT_PENDING && !hasActiveOverride(e)) setSignal(t, e.Re);
         setContextInternal(r);
         setPendingCheckActive(i);
         setLatestReadActive(n);
@@ -310,7 +314,7 @@ function getLatestValueComputed(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e.o?.De !== undefined && e.o?.De !== NOT_PENDING ? unwrapOverride(e.o?.De) : e.be;
+    const i = e.o?.Pe !== undefined && e.o?.Pe !== NOT_PENDING ? unwrapOverride(e.o?.Pe) : e.be;
     let r;
     try {
         // An untracked latest() read has no reading context, so read() never
@@ -319,9 +323,24 @@ function getLatestValueComputed(e) {
         // until the flush (#2922). Mirror the tracked-read pull here: mark the
         // queued staleness through the graph, then bring the shadow up to date.
         const e = queueFor(t);
-        if (t.Le >= e.xe && !(t.ie & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.Me >= e.Qe && !(t.ie & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
-            prepareComputed(t, true);
+            // Suspend probe collection during the pull (mirrors pendingCheckRead's
+            // prepare): a probe through latest() answers for the SHADOW — the
+            // read() dispatch collects it deliberately, so the verdict reflects
+            // async still in flight for the latest view, not the parent's held
+            // write. A stale shadow recomputing HERE ran its `read(parent)` with
+            // the probe still live and collected the parent too, so the verdict
+            // depended on whether anything had pulled the shadow current earlier
+            // in the tick (#3104: reading latest(m) flipped a later
+            // latest(() => isPending(x)) from true to false).
+                        const n = pendingCheckActive;
+            setPendingCheckActive(false);
+            try {
+                prepareComputed(t, true);
+            } finally {
+                setPendingCheckActive(n);
+            }
         }
         r = read(t);
     } catch (t) {
@@ -331,10 +350,10 @@ function getLatestValueComputed(e) {
         setLatestReadActive(n);
     }
     if (t.S & STATUS_PENDING) return i;
-    if (stale && currentOptimisticLane && t.o?.Be) {
-        const e = findLane(t.o?.Be);
+    if (stale && currentOptimisticLane && t.o?.Je) {
+        const e = findLane(t.o?.Je);
         const n = findLane(currentOptimisticLane);
-        if (e !== n && e.Ae.size > 0) {
+        if (e !== n && e.Oe.size > 0) {
             return i;
         }
     }
@@ -342,15 +361,41 @@ function getLatestValueComputed(e) {
     // speculative value in _pendingValue; a contextless read() only surfaces
     // _value. Overrides stay authoritative (A17), and stale readers keep the
     // other transition's committed view, matching read()'s own selection.
-        if (t.Pe !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t._e && activeTransition !== t._e)) return t.Pe;
+        if (t.Re !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ae && activeTransition !== t.Ae)) return t.Re;
     return r;
 }
 
+/**
+ * A latest() shadow that is uninitialized only because it was CREATED during
+ * an active flight — its parent source already has a committed value, so
+ * latest() serves that as the visible value and a tracked reader has
+ * something to pair a verdict with (#3166). Same parent resolution as
+ * computePendingState. The pending signal companion also carries
+ * `_parentSource` but is a plain signal (no `_fn`) that never goes pending,
+ * so the `_fn` check is belt-and-braces for this call site.
+ */ function latestShadowWithInitializedParent(e) {
+    if (typeof e.oe !== "function") return false;
+    const t = e.o?.Tt;
+    if (t === undefined) return false;
+    const n = t.st || t;
+    return !(n.S & STATUS_UNINITIALIZED);
+}
+
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, i) {
     setPendingCheckActive(false);
     if (typeof e.oe === "function") prepareComputed(e, true);
     const r = n.S;
-    if (t && r & STATUS_PENDING && r & STATUS_UNINITIALIZED) {
+    if (t && r & STATUS_PENDING && r & STATUS_UNINITIALIZED && 
+    // The suspend-throw is for a genuinely-first-load source: the tracked
+    // reader has nothing to pair a verdict with, so it parks on the source.
+    // A latest() SHADOW created lazily mid-flight is born uninitialized even
+    // though its parent has a committed value latest() will serve — throwing
+    // here (swallowed by latestRead's fallback) dropped the shadow from the
+    // probe, so a tracked latest(isPending()) probe created during a
+    // new-question flight cached `false` for that whole flight (#3166).
+    // Defer to the PARENT's initialization state and fall through to normal
+    // collection; the plain pending throw downstream still links the reader.
+    !latestShadowWithInitializedParent(n)) {
         if (tracking && e !== t) link(e, t);
         setPendingCheckActive(true);
         throw n.o?._;
@@ -368,9 +413,9 @@ function getLatestValueComputed(e) {
  * reader saw is an input, and pending remains the truth for every reader
  * (#3028).
  */ function heldAwaitingAsync(e) {
-    const t = e._e;
+    const t = e.Ae;
     const n = t ? currentTransition(t) : activeTransition;
-    if (!n || n.fn) return false;
+    if (!n || n.sn) return false;
     // A plain staged write (a signal/store leaf — no _fn) held while an action
     // is still running is an INPUT to a computation still in flight (#3078):
     // the pairing rule must not suppress the verdict, or a memo recomputing
@@ -385,14 +430,14 @@ function getLatestValueComputed(e) {
     // action check above; the reporter scan below is for transition-held
     // writes whose source async is still computing.
         if (!t) return false;
-    for (const [e, t] of n.Ne) {
+    for (const [e, t] of n._e) {
         if (t.size && e.S & STATUS_PENDING && e.o?._?.source === e) return true;
     }
     return false;
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e.Pe !== NOT_PENDING && t === e.Pe) {
+    if (pendingProbe !== null && e.Re !== NOT_PENDING && t === e.Re) {
         if (heldAwaitingAsync(e)) return;
         pendingProbe.freshReads.add(e);
     }
@@ -400,10 +445,10 @@ function recordFreshRead(e, t) {
 
 function applyReask(e, t) {
     const n = !!(e.S & STATUS_PENDING);
-    const i = t && !(n && !e.o?.pe);
-    const r = n && (e.o?.pe ?? false) !== i;
+    const i = t && !(n && !e.o?.De);
+    const r = n && (e.o?.De ?? false) !== i;
     // Allocation-free for the quiet case: false is the extension default.
-        if (i) ext(e).pe = true; else if (e.o !== null) e.o.pe = false;
+        if (i) ext(e).De = true; else if (e.o !== null) e.o.De = false;
     return r;
 }
 
@@ -429,6 +474,17 @@ function isPending(e) {
     };
     const collectPending = () => {
         setPendingCheckActive(false);
+        // Companion reads are mode-neutral plumbing: under an outer latest()
+        // (isPending inside a latest window — #3104's memo shape) leaving latest
+        // mode active dispatched these reads through latestRead, which built a
+        // SHADOW OF THE PENDING SIGNAL itself. The next updatePendingSignal then
+        // wrote that companion-on-companion from inside a recompute
+        // (syncCompanions → setSignal on a shadow created without ownedWrite)
+        // and halted dev with the owned-scope write guard. The creation paths
+        // (getLatestValueComputed / getPendingSignal) already suspend both
+        // modes; this read site must too.
+                const e = latestReadActive;
+        setLatestReadActive(false);
         try {
             i.sources.forEach(e => {
                 if (read(getPendingSignal(e))) {
@@ -436,6 +492,7 @@ function isPending(e) {
                 }
             });
         } finally {
+            setLatestReadActive(e);
             setPendingCheckActive(true);
         }
         // A "not pending" verdict that exists only because this reader saw the
@@ -472,26 +529,26 @@ function isPending(e) {
 // Hook installation (same late-binding pattern as GlobalQueue._update /
 // _propagateAffects): core call sites fire these behind the same guards the
 // direct calls used, so behavior is identical once this module loads.
-GlobalQueue.Oe = syncCompanions;
+GlobalQueue.Ue = syncCompanions;
 
 GlobalQueue.de = updatePendingSignal;
 
-GlobalQueue.ye = updateChildCompanions;
+GlobalQueue.me = updateChildCompanions;
 
 GlobalQueue.un = snapCompanionsToState;
 
-GlobalQueue.Pt = latestRead;
+GlobalQueue.gt = latestRead;
 
-GlobalQueue.Dt = pendingCheckRead;
+GlobalQueue.Ht = pendingCheckRead;
 
-GlobalQueue.Ht = recordFreshRead;
+GlobalQueue.kt = recordFreshRead;
 
-GlobalQueue.Je = applyReask;
+GlobalQueue.et = applyReask;
 
 GlobalQueue.k = repollDownstreamVerdicts;
 
-GlobalQueue.wt = witnessAffects;
+GlobalQueue.Wt = witnessAffects;
 
-GlobalQueue.jt = wakeSuppressedProbes;
+GlobalQueue.zt = wakeSuppressedProbes;
 
 export { isPending, latest };

package/dist/prod/index.js

@@ -1,6 +1,6 @@
-export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./core/error.js";
+export { ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError } from "./core/error.js";
 
-export { clearSnapshots, isEqual, markSnapshotScope, refresh, releaseSnapshotScope, runWithOwner, setSnapshotCapture, untrack } from "./core/core.js";
+export { clearSnapshots, isEqual, markSnapshotScope, releaseSnapshotScope, runWithOwner, setSnapshotCapture, untrack } from "./core/core.js";
 
 export { enableExternalSource } from "./core/external.js";
 
@@ -20,7 +20,7 @@ import "./core/effect.js";
 
 export { action } from "./core/action.js";
 
-export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, resolve } from "./signals.js";
+export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, refresh, resolve, until } from "./signals.js";
 
 export { affects } from "./affects.js";