@solidjs/signals 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/prod/core/verdict.js

@@ -1,12 +1,12 @@
-import { NOT_PENDING, REACTIVE_DISPOSED, REACTIVE_DIRTY, REACTIVE_CHECK, unwrapOverride, STATUS_UNINITIALIZED, STATUS_PENDING, REACTIVE_MANUAL_WRITE } from "./constants.js";
+import { NOT_PENDING, REACTIVE_DISPOSED, REACTIVE_DIRTY, REACTIVE_CHECK, unwrapOverride, REACTIVE_ZOMBIE, STATUS_UNINITIALIZED, STATUS_PENDING, REACTIVE_MANUAL_WRITE, STATUS_ERROR, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
 
-import { setSignal, read, context, stale, currentOptimisticLane, prepareComputed, tracking, setLatestReadActive, setContextInternal, optimisticComputed, setPendingCheckActive, latestReadActive, optimisticSignal, pendingCheckActive } from "./core.js";
+import { setSignal, prepareComputed, read, context, stale, currentOptimisticLane, tracking, setLatestReadActive, setContextInternal, optimisticComputed, setPendingCheckActive, latestReadActive, optimisticSignal, pendingCheckActive } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
 import { link } from "./graph.js";
 
-import { insertIntoHeap, queueFor } from "./heap.js";
+import { insertIntoHeap, queueFor, markHeap } from "./heap.js";
 
 import "./invariants.js";
 
@@ -14,7 +14,7 @@ import { findLane, hasActiveOverride } from "./lanes.js";
 
 import { installOptimisticEngine } from "./optimistic.js";
 
-import { GlobalQueue, clock, insertSubs, schedule } from "./scheduler.js";
+import { GlobalQueue, clock, insertSubs, schedule, activeTransition, activeAffectsMarks } from "./scheduler.js";
 
 /**
  * The isPending()/latest() verdict layer, moved out of core.ts. Importing this
@@ -32,21 +32,21 @@ let pendingProbe = null;
  * Get or create the pending signal for a node (lazy).
  * Used by isPending() to track pending state reactively.
  */ function getPendingSignal(e) {
-    if (!e.ye) {
+    if (!e.ge) {
         // Start false, write true if pending - ensures reversion returns to false
-        e.ye = optimisticSignal(false, {
+        e.ge = optimisticSignal(false, {
             ownedWrite: true
         });
-        e.ye.en = e;
-        if (computePendingState(e)) setSignal(e.ye, true);
+        e.ge.nn = e;
+        if (computePendingState(e)) setSignal(e.ge, true);
     }
-    return e.ye;
+    return e.ge;
 }
 
 function collectPendingSources(e) {
     if (!pendingProbe) return;
     pendingProbe.sources.add(e);
-    const t = e.rt || e;
+    const t = e.nt || e;
     if (t !== e) pendingProbe.sources.add(t);
 }
 
@@ -60,65 +60,116 @@ function collectPendingSources(e) {
     pendingProbe?.sources.add(e);
 }
 
+/**
+ * The affects() coverage walk — the read half of the dedicated mark channel.
+ * A node is covered by a live mark iff it carries one (`_affectsCount`) or
+ * derives, through its CURRENT deps (hopping store firewalls), from a node
+ * that does. Pull-based coverage means graph rewires, mid-window recomputes,
+ * and probe-triggered recomputes can never strand or strip a mark — there is
+ * nothing stored downstream to corrupt. Probe-created links
+ * (`_pendingObserver`) are skipped so an `isPending` wrapper memo never
+ * inherits the coverage it reports on.
+ */ function markWalk(e, t) {
+    if (e.t) return true;
+    // A real error outranks an inherited mark (A16/A24c): an errored node
+    // answers probes with its error, not a coverage verdict, and coverage does
+    // not flow through it — matching the rails' behavior, where propagation
+    // stopped at errored nodes. A DIRECT mark on an errored node still reads
+    // pending (the count check above), also matching.
+        if (e.S & STATUS_ERROR) return false;
+    if (t.has(e)) return false;
+    t.add(e);
+    const n = e.nt;
+    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.se & REACTIVE_RECOMPUTING_DEPS ? i.qe : undefined;
+    if (r !== null) {
+        for (let e = i.Xe ?? null; e !== null; e = e.et) {
+            if (!e.De && markWalk(e.tt, t)) return true;
+            if (e === r) break;
+        }
+    }
+    return false;
+}
+
+/** Gated entry: apps with no live mark pay one integer compare. */ function markCovered(e) {
+    return activeAffectsMarks !== 0 && markWalk(e, new Set);
+}
+
 function quietPending(e) {
-    if (e.m) {
-        for (const t of e.m) if (!t.A) return false;
+    if (e.oe) {
+        for (const t of e.oe) if (!t.be) return false;
         return true;
     }
-    return e.A;
+    return e.be;
 }
 
 function newQuestionInFlight(e) {
-    return !!(e.i & STATUS_PENDING) && !(e.i & STATUS_UNINITIALIZED) && !quietPending(e);
+    return !!(e.S & STATUS_PENDING) && !(e.S & STATUS_UNINITIALIZED) && !quietPending(e);
 }
 
 function computePendingState(e) {
     const t = e;
-    if (t.u & REACTIVE_DISPOSED) return false;
-    if (e.M) return true;
-    const n = e.rt;
-    if (e.en) {
-        const t = e.en;
-        if (t.M) return true;
-        const n = t.rt || t;
+    if (t.se & REACTIVE_DISPOSED) return false;
+    // Mark coverage is transitive by dep-graph reachability: a latest() shadow
+    // 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.nt;
+    if (e.nn) {
+        const t = e.nn;
+        const n = t.nt || t;
         return newQuestionInFlight(n);
     }
-    if (n && e.ge !== NOT_PENDING && !hasActiveOverride(e)) {
-        return !!(n.u & REACTIVE_MANUAL_WRITE) || !n.Ae && !(n.i & STATUS_PENDING) || !!(n.i & STATUS_PENDING) && quietPending(n);
+    if (n && e.Ne !== NOT_PENDING && !hasActiveOverride(e)) {
+        return !!(n.se & REACTIVE_MANUAL_WRITE) || !n.Te && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
     }
-    if (e.ge !== NOT_PENDING && !(t.i & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.Ge || !e.Ge(e.ge, unwrapOverride(e.be));
+    if (e.Ne !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED)) {
+        if (hasActiveOverride(e)) return !e.Pe || !e.Pe(e.Ne, unwrapOverride(e.Ee));
         return true;
     }
     return newQuestionInFlight(t);
 }
 
 function syncCompanions(e, t) {
-    if (e.ye) updatePendingSignal(e);
-    if (e.pe) setSignal(e.pe, t);
+    if (e.ge) updatePendingSignal(e);
+    if (e.he) setSignal(e.he, t);
 }
 
 function updatePendingSignal(e) {
-    if (e.ye) {
-        setSignal(e.ye, computePendingState(e));
+    if (e.ge) {
+        setSignal(e.ge, computePendingState(e));
     }
-    if (e.pe) updatePendingSignal(e.pe);
+    if (e.he) updatePendingSignal(e.he);
 }
 
 function updateChildCompanions(e) {
-    for (let t = e.G; t !== null; t = t.Ne) {
-        if (t.ye || t.pe) updatePendingSignal(t);
+    for (let t = e.u; t !== null; t = t.fe) {
+        if (t.ge || t.he) updatePendingSignal(t);
     }
 }
 
-function repollDownstreamVerdicts(e) {
-    const t = new Set;
+/**
+ * Re-derive every verdict companion downstream of `el` (subs + firewall
+ * children, dedup'd). The affects() channel's poke walk: registration and
+ * re-ask flips use the live write path (companion setSignal — its own lane
+ * lets the wake escape an incomplete transition's effect stash, #2887);
+ * mark release passes `snap` because it runs inside queue finalization,
+ * where companion writes must land committed (a setSignal there would open
+ * a fresh override window that nothing settles).
+ */ function repollDownstreamVerdicts(e, t = false) {
+    const n = t ? snapCompanionsToState : updatePendingSignal;
+    const i = new Set;
     const visit = e => {
-        if (t.has(e)) return;
-        t.add(e);
-        if (e.ye || e.pe) updatePendingSignal(e);
-        for (let t = e.p; t !== null; t = t.de) visit(t.Ee);
-        for (let t = e.G ?? null; t !== null; t = t.Ne) {
+        if (i.has(e)) return;
+        i.add(e);
+        if (e.ge || e.he) n(e);
+        for (let t = e.o; t !== null; t = t.ue) visit(t.le);
+        for (let t = e.u ?? null; t !== null; t = t.fe) {
             visit(t);
         }
     };
@@ -126,21 +177,21 @@ function repollDownstreamVerdicts(e) {
 }
 
 function snapCompanionsToState(e) {
-    const t = e.ye;
-    if (t && (t.be === undefined || t.be === NOT_PENDING)) {
+    const t = e.ge;
+    if (t && (t.Ee === undefined || t.Ee === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.Ue !== n || t.ge !== NOT_PENDING) {
-            t.Ue = n;
-            t.ge = NOT_PENDING;
-            t.Ie = clock;
+        if (t.Re !== n || t.Ne !== NOT_PENDING) {
+            t.Re = n;
+            t.Ne = NOT_PENDING;
+            t.ce = clock;
             insertSubs(t);
             schedule();
         }
     }
-    const n = e.pe;
-    if (n && !(n.u & REACTIVE_DISPOSED)) {
-        if ((n.be === undefined || n.be === NOT_PENDING) && n.ge === NOT_PENDING && !Object.is(n.Ue, e.Ue) && !(n.u & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
-            n.u |= REACTIVE_DIRTY;
+    const n = e.he;
+    if (n && !(n.se & REACTIVE_DISPOSED)) {
+        if ((n.Ee === undefined || n.Ee === NOT_PENDING) && n.Ne === NOT_PENDING && !Object.is(n.Re, e.Re) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+            n.se |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
             schedule();
@@ -150,7 +201,7 @@ function snapCompanionsToState(e) {
 }
 
 function getLatestValueComputed(e) {
-    if (!e.pe) {
+    if (!e.he) {
         const t = latestReadActive;
         setLatestReadActive(false);
         const n = pendingCheckActive;
@@ -158,49 +209,64 @@ function getLatestValueComputed(e) {
         const i = context;
         setContextInternal(null);
  // Detach from owner so it isn't disposed with effects
-                e.pe = optimisticComputed(() => read(e));
-        e.pe.en = e;
+                e.he = optimisticComputed(() => read(e));
+        e.he.nn = e;
  // Parent-child lane relationship
                 setContextInternal(i);
         setPendingCheckActive(n);
         setLatestReadActive(t);
     }
-    return e.pe;
+    return e.he;
 }
 
 /** The latest()-mode read path, installed as GlobalQueue._latestRead. */ function latestRead(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e.be !== undefined && e.be !== NOT_PENDING ? unwrapOverride(e.be) : e.Ue;
+    const i = e.Ee !== undefined && e.Ee !== NOT_PENDING ? unwrapOverride(e.Ee) : e.Re;
     let r;
     try {
+        // An untracked latest() read has no reading context, so read() never
+        // performs its mid-tick pull — a plain write queued between two latest()
+        // calls left a still-subscribed shadow at its previous speculative value
+        // 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.He >= e.Fe && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+            markHeap(e);
+            prepareComputed(t, true);
+        }
         r = read(t);
     } catch (t) {
-        if (t instanceof NotReadyError && (!context || !(e.i & STATUS_UNINITIALIZED))) return i;
+        if (t instanceof NotReadyError && (!context || !(e.S & STATUS_UNINITIALIZED))) return i;
         throw t;
     } finally {
         setLatestReadActive(n);
     }
-    if (t.i & STATUS_PENDING) return i;
-    if (stale && currentOptimisticLane && t.Je) {
-        const e = findLane(t.Je);
+    if (t.S & STATUS_PENDING) return i;
+    if (stale && currentOptimisticLane && t.je) {
+        const e = findLane(t.je);
         const n = findLane(currentOptimisticLane);
-        if (e !== n && e.Pe.size > 0) {
+        if (e !== n && e.de.size > 0) {
             return i;
         }
     }
+    // A shadow recomputed by the pull above (not at creation) holds its fresh
+    // 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.Ne !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ue && activeTransition !== t.Ue)) return t.Ne;
     return r;
 }
 
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, i) {
     setPendingCheckActive(false);
-    if (typeof e.xe === "function") prepareComputed(e, true);
-    const r = n.i;
+    if (typeof e.ke === "function") prepareComputed(e, true);
+    const r = n.S;
     if (t && r & STATUS_PENDING && r & STATUS_UNINITIALIZED) {
         if (tracking && e !== t) link(e, t);
         setPendingCheckActive(true);
-        throw n.k;
+        throw n._;
     }
     collectPendingSources(e);
     if (i) collectPendingSources(i);
@@ -208,14 +274,14 @@ function getLatestValueComputed(e) {
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e.ge !== NOT_PENDING && t === e.ge) pendingProbe.freshReads.add(e);
+    if (pendingProbe !== null && e.Ne !== NOT_PENDING && t === e.Ne) pendingProbe.freshReads.add(e);
 }
 
 function applyReask(e, t) {
-    const n = !!(e.i & STATUS_PENDING);
-    const i = t && !(n && !e.A);
-    const r = n && e.A !== i;
-    e.A = i;
+    const n = !!(e.S & STATUS_PENDING);
+    const i = t && !(n && !e.be);
+    const r = n && e.be !== i;
+    e.be = i;
     return r;
 }
 
@@ -255,7 +321,7 @@ function isPending(e) {
     } catch (e) {
         collectPending();
         if (e instanceof NotReadyError) {
-            const t = !!(e.source?.i & STATUS_UNINITIALIZED);
+            const t = !!(e.source?.S & STATUS_UNINITIALIZED);
             if (i.found && !t) return true;
             if (context && t) throw e;
         }
@@ -269,24 +335,24 @@ 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._e = syncCompanions;
+GlobalQueue.Ie = syncCompanions;
 
-GlobalQueue.P = updatePendingSignal;
+GlobalQueue.ae = updatePendingSignal;
 
-GlobalQueue.me = updateChildCompanions;
+GlobalQueue._e = updateChildCompanions;
 
-GlobalQueue.R = snapCompanionsToState;
+GlobalQueue.un = snapCompanionsToState;
 
-GlobalQueue.Gt = latestRead;
+GlobalQueue.St = latestRead;
 
-GlobalQueue.Pt = pendingCheckRead;
+GlobalQueue.dt = pendingCheckRead;
 
-GlobalQueue.kt = recordFreshRead;
+GlobalQueue.Rt = recordFreshRead;
 
-GlobalQueue.tt = applyReask;
+GlobalQueue.ze = applyReask;
 
-GlobalQueue.nt = repollDownstreamVerdicts;
+GlobalQueue.k = repollDownstreamVerdicts;
 
-GlobalQueue.wt = witnessAffects;
+GlobalQueue.Lt = witnessAffects;
 
 export { isPending, latest };