@solidjs/signals 2.0.0-beta.31 → 2.0.0-beta.33

package/dist/prod/core/async.js

@@ -1,4 +1,4 @@
-import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING } from "./constants.js";
+import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE } from "./constants.js";
 
 import { untrack, context, setSignal } from "./core.js";
 
@@ -6,7 +6,7 @@ import "./invariants.js";
 
 import { NotReadyError, StatusError } from "./error.js";
 
-import { unobserved, trimStaleDeps } from "./graph.js";
+import { trimStaleDeps, unobserved } from "./graph.js";
 
 import { enqueueSub } from "./heap.js";
 
@@ -14,7 +14,7 @@ import { resolveTransition, hasActiveOverride, assignOrMergeLane, resolveLane }
 
 import { cleanup } from "./owner.js";
 
-import { globalQueue, GlobalQueue, clock, currentTransition, schedule, flush, queuePendingNode, insertSubs } from "./scheduler.js";
+import { globalQueue, GlobalQueue, schedule, flush, queuePendingNode, insertSubs, clock, currentTransition } from "./scheduler.js";
 
 // The lazily-created Set is the ONE container for pending sources. Its
 // predecessor — a singular slot promoted to a Set on the second source —
@@ -38,6 +38,22 @@ function clearPendingSources(e) {
     e.oe = undefined;
 }
 
+/**
+ * A loading-window node hit an unready source (sync throw in recompute, or a
+ * NotReadyError-rejected flight): register for the source's settle — the
+ * settlePendingSource walk runs off `_pendingSources` + `_blocked` alone —
+ * with NO read-visible pending status, no downstream propagation, no
+ * transition, no lane registration. Commit #0 keeps serving.
+ */ function parkLoadingWindow(e, n) {
+    e.ue = true;
+    if (n.source) addPendingSource(e, n.source);
+    // A settled error is the node's answer ("the error stays the answer until
+    // this retry can actually run") — the park must not replace it: reads
+    // throw `_error` while STATUS_ERROR is set, and overwriting it here leaks
+    // a pending-class NotReadyError from a read-invisible park (#2989).
+        if (!(e.S & STATUS_ERROR)) setPendingError(e, n.source, n);
+}
+
 function setPendingError(e, n, t) {
     if (!n) {
         e._ = null;
@@ -54,10 +70,10 @@ function setPendingError(e, n, t) {
 }
 
 function forEachDependent(e, n) {
-    for (let t = e.o; t !== null; t = t.ue) n(t.le, t);
+    for (let t = e.o; t !== null; t = t.le) n(t.fe, t);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-        for (let t = e.u ?? null; t !== null; t = t.fe) {
-        for (let e = t.o; e !== null; e = e.ue) n(e.le, e);
+        for (let t = e.u ?? null; t !== null; t = t.ae) {
+        for (let e = t.o; e !== null; e = e.le) n(e.fe, e);
     }
 }
 
@@ -72,7 +88,7 @@ function forEachDependent(e, n) {
 // callbacks handle their own release (settleAutodispose in handleAsync); this
 // covers derivatively-pending dependents, which have no callbacks of their own.
 function releaseIfSettledUnobserved(e) {
-    e.ae && e.T & CONFIG_AUTO_DISPOSE && !e.o && !(e.se & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+    e.ce && e.T & CONFIG_AUTO_DISPOSE && !e.o && !(e.se & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
 }
 
 // Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
@@ -128,24 +144,30 @@ function settlePendingSource(e) {
     let t;
     const r = new Set;
     // Companion updates no-op without the verdict layer (null hook).
-        const o = GlobalQueue.ce;
+        const o = GlobalQueue.Se;
     const settle = u => {
         if (r.has(u) || !removePendingSource(u, e)) return;
         r.add(u);
-        u.Se = clock;
-        const l = u.oe?.values().next().value;
-        if (l) {
-            setPendingError(u, l);
+        u.de = clock;
+        const i = u.oe?.values().next().value;
+        // STATUS_ERROR + pending sources only coexist via an errored loading
+        // window's park (notifyStatus(STATUS_ERROR) clears pending sources
+        // otherwise): the settled error stays the answer through the settle —
+        // nulling it here would have reads throw `null` until the re-enqueued
+        // retry lands, or lose it entirely if that retry parks again (#2989).
+                const l = u.S & STATUS_ERROR;
+        if (i) {
+            if (!l) setPendingError(u, i);
             o !== null && o(u);
         } else {
             u.S &= ~STATUS_PENDING;
-            setPendingError(u);
+            if (!l) setPendingError(u);
             o !== null && o(u);
-            if (u.de) {
+            if (u.ue) {
                 enqueueSub(u);
                 n = true;
             }
-            u.de = false;
+            u.ue = false;
             // Fully settled with nobody watching: release candidate (#2934). Checked
             // again at release time — deferred so unobserved() can't unlink subs
             // lists this walk is still iterating.
@@ -176,6 +198,8 @@ function handleAsync(e, n, t) {
     }
     if (!o && !r) {
         e.Te = null;
+        // A sync landing is the first real answer for a loadingValue node.
+                e.Ee = false;
         return n;
     }
     e.Te = n;
@@ -192,21 +216,31 @@ function handleAsync(e, n, t) {
     // are the transaction's reveal machinery and always re-enter.
         const settleTransition = () => {
         const n = resolveTransition(e);
-        if (n && e.S & STATUS_UNINITIALIZED && !currentTransition(n).Ee.has(e)) {
+        if (n && e.S & STATUS_UNINITIALIZED && !currentTransition(n).Ie.has(e)) {
             // Drop the stale stamp too: the plain settle write (setSignal) and the
             // stash-path restamp both re-enter the transaction through it.
-            e.Ie = null;
+            e.Ne = null;
             return;
         }
         globalQueue.initTransition(n);
     };
     const handleError = t => {
         if (e.Te !== n) return;
-        settleTransition();
         // NotReadyError from rejected promises should be treated as pending, not error
-                const r = t instanceof NotReadyError;
+                let r = t instanceof NotReadyError;
+        if (r && e.Ee) {
+            // Loading window: the flight died waiting on an unready source. Keep
+            // serving commit #0 — same parking as recompute's catch for sync
+            // dependency throws. The dead flight is released so the clock-gated
+            // error-retry pull (updateIfNecessary) can also re-ask.
+            e.Te = null;
+            parkLoadingWindow(e, t);
+            e.de = clock;
+            return;
+        }
+        settleTransition();
         notifyStatus(e, r ? STATUS_PENDING : STATUS_ERROR, t);
-        e.Se = clock;
+        e.de = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
         // cleared their pending sources), so stranded lazy ones release here —
         // the error twin of settlePendingSource's release (#2934).
@@ -222,12 +256,12 @@ function handleAsync(e, n, t) {
         const u = !!(e.S & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
-        const l = resolveLane(e);
-        if (l) l.Ne.delete(e);
+        const i = resolveLane(e);
+        if (i) i.Ae.delete(e);
         if (t) {
             t(r);
             if (u) clearStatus(e, true);
-        } else if (e.Ae !== undefined) {
+        } else if (e._e !== undefined) {
             // Optimistic node — resting OR covered by an active override — holds
             // through the shared pending-node path, exactly like a plain async memo,
             // so the commit clears STATUS_UNINITIALIZED (#2806) and elevation to
@@ -246,22 +280,22 @@ function handleAsync(e, n, t) {
             // only notified when the hold is visible to them: under an active
             // override every reader sees the override (A17), so waking subs would
             // re-show an unchanged view — the revert is the notification point.
-                        GlobalQueue._e !== null && GlobalQueue._e(e, r);
+                        GlobalQueue.Pe !== null && GlobalQueue.Pe(e, r);
             if (!hasActiveOverride(e)) insertSubs(e);
-            e.Se = clock;
-        } else if (l) {
+            e.de = clock;
+        } else if (i) {
             // Route through lane's effect queue for independent flushing
-            const n = e.Pe;
+            const n = e.Re;
             const t = e.Ue;
             const o = e.be;
             try {
                 if (!n && u || !o || !o(r, t)) {
                     e.Ue = r;
-                    e.Se = clock;
+                    e.de = clock;
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
                     // (computePendingState doesn't read _value).
-                                        GlobalQueue._e !== null && GlobalQueue._e(e, r);
+                                        GlobalQueue.Pe !== null && GlobalQueue.Pe(e, r);
                     insertSubs(e, true);
                 }
             } catch (n) {
@@ -280,6 +314,13 @@ function handleAsync(e, n, t) {
                 notifyStatus(e, STATUS_ERROR, n);
             }
         }
+        // First real answer landing: the window closes when the answer becomes
+        // OBSERVABLE. A direct commit is observable now; a transition-held write
+        // (`_pendingValue` set above or inside setSignal) is not — the verdict's
+        // held-value branch is window-gated, and commitPendingNode closes the
+        // window when the hold commits, so no one-frame isPending pulse can leak
+        // to live observers between the landing and its commit (#2990).
+                if (e.De === NOT_PENDING) e.Ee = false;
         settlePendingSource(e);
         schedule();
         flush();
@@ -300,9 +341,9 @@ function handleAsync(e, n, t) {
         return false;
     };
     if (o) {
-        let t = false, r = false, o, l = true;
+        let t = false, r = false, o, i = true;
         n.then(e => {
-            if (l) {
+            if (i) {
                 u = e;
                 t = true;
             } else {
@@ -310,7 +351,7 @@ function handleAsync(e, n, t) {
                 settleAutodispose();
             }
         }, e => {
-            if (l) {
+            if (i) {
                 o = e;
                 r = true;
             } else {
@@ -318,7 +359,7 @@ function handleAsync(e, n, t) {
                 settleAutodispose();
             }
         });
-        l = false;
+        i = false;
         if (r) {
             // Settle through the same status path an async rejection uses, then
             // unwind the in-progress synchronous read so the errored node isn't
@@ -326,15 +367,23 @@ function handleAsync(e, n, t) {
             handleError(o);
             throw o;
         } else if (!t) {
+            // Loading window: serve commit #0 instead of suspending. No transition
+            // is opened — first-flight work on a loadingValue node is loading-class
+            // (invisible to boundaries and transitions); the flight itself is
+            // already registered in _inFlight and lands through asyncWrite.
+            if (e.Ee) return e.Ue;
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
+        } else {
+            // Synchronously-resolved promise: the first real answer landed.
+            e.Ee = false;
         }
     }
     if (r) {
         const t = n[Symbol.asyncIterator]();
         let r = false;
         let o = false;
-        let l = true;
+        let i = true;
         cleanup(() => {
             if (o) return;
             o = true;
@@ -350,10 +399,25 @@ function handleAsync(e, n, t) {
             if (!settleAutodispose()) iterate();
         };
         const iterate = () => {
-            let s, i, f = false, a = false, c = true;
-            t.next().then(t => {
-                if (c) {
-                    s = t;
+            let l, s, f = false, a = false, c = true;
+            // Protocol tolerance, matching `for await`: `await` unwraps whatever
+            // next() returns — a thenable OR a bare IteratorResult. Real producers
+            // use the bare form as a promise-free fast path when a value is already
+            // buffered (seroval's deserialized streams do), so a bare result is
+            // assimilated as an already-settled step instead of crashing on `.then`.
+                        const S = t.next();
+            const d = isThenable(S) ? S : {
+                then: e => void e(S)
+            };
+            d.then(t => {
+                // The sync stash only serves the INITIAL drain (handleAsync's caller
+                // consumes syncValue / throws NotReady from it). A sync-settled step
+                // after an async gap — seroval buffering values between pulls, a
+                // sync-thenable producer mid-stream — has no caller reading the
+                // stash: it must write through the async path or the value is
+                // silently dropped.
+                if (c && i) {
+                    l = t;
                     f = true;
                     if (t.done) o = true;
                 } else if (e.Te !== n) {
@@ -374,7 +438,7 @@ function handleAsync(e, n, t) {
                 }
             }, t => {
                 if (c) {
-                    i = t;
+                    s = t;
                     a = true;
                 } else if (e.Te === n) {
                     o = true;
@@ -386,41 +450,46 @@ function handleAsync(e, n, t) {
             if (a) {
                 // Match the promise branch, but only rethrow during the initial read.
                 o = true;
-                handleError(i);
-                if (l) throw i;
+                handleError(s);
+                if (i) throw s;
                 return true;
             }
-            if (f && !s.done) {
-                u = s.value;
+            if (f && !l.done) {
+                u = l.value;
                 r = true;
                 return iterate();
             }
-            return f && s.done;
+            return f && l.done;
         };
-        const s = iterate();
+        const l = iterate();
         // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
-                l = false;
-        if (!r && !s) {
+                i = false;
+        if (!r && !l) {
+            // Loading window: serve commit #0 (see the promise branch above).
+            if (e.Ee) return e.Ue;
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
         }
+        // A sync first yield (or immediate empty completion) is the first real
+        // answer; async yields clear inside asyncWrite.
+                e.Ee = false;
     }
     return u;
 }
 
 function clearStatus(e, n = false) {
     if (e.oe) clearPendingSources(e);
-    if (e.de) e.de = false;
+    if (e.ue) e.ue = false;
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
-        e.Re = false;
+        e.he = false;
     e.S = n ? 0 : e.S & STATUS_UNINITIALIZED;
     if (e._) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e.he || e.pe) GlobalQueue.ce(e);
-    if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
+        if (e.ge || e.pe) GlobalQueue.Se(e);
+    if (e.u && GlobalQueue.Oe !== null) GlobalQueue.Oe(e);
     if (e.i) e.i();
 }
 
@@ -428,9 +497,9 @@ function notifyStatus(e, n, t, r, o) {
     // Wrap regular errors to track source node
     if (n === STATUS_ERROR && !(t instanceof StatusError) && !(t instanceof NotReadyError)) t = new StatusError(e, t);
     const u = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
-    const l = u === e;
-    const s = n === STATUS_PENDING && e.Ae !== undefined && !l;
-    const i = s && hasActiveOverride(e);
+    const i = u === e;
+    const l = n === STATUS_PENDING && e._e !== undefined && !i;
+    const s = l && hasActiveOverride(e);
     if (!r) {
         if (n === STATUS_PENDING && u) {
             addPendingSource(e, u);
@@ -443,14 +512,14 @@ function notifyStatus(e, n, t, r, o) {
             e.S = n | (n !== STATUS_ERROR ? e.S & STATUS_UNINITIALIZED : 0);
             e._ = t;
         }
-        GlobalQueue.ce !== null && GlobalQueue.ce(e);
-        if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
+        GlobalQueue.Se !== null && GlobalQueue.Se(e);
+        if (e.u && GlobalQueue.Oe !== null) GlobalQueue.Oe(e);
     }
     if (o && !r) {
         assignOrMergeLane(e, o);
     }
-    const f = r || i;
-    const a = r || s ? undefined : o;
+    const f = r || s;
+    const a = r || l ? undefined : o;
     if (e.i) {
         if (r && n === STATUS_PENDING) {
             return;
@@ -463,22 +532,22 @@ function notifyStatus(e, n, t, r, o) {
         return;
     }
     forEachDependent(e, (e, r) => {
-        e.Se = clock;
+        e.de = clock;
         if (n === STATUS_PENDING && u && !e.oe?.has(u) || n !== STATUS_PENDING && (e._ !== t || e.oe)) {
             // A pending-observer link is the subscription an `isPending` read created.
             // It exists so the observer re-runs when the source settles, but it must
             // not carry a real (non-NotReadyError) error — the synchronous `isPending`
             // read swallows those, and the async path must match. Re-run the observer
             // so `isPending` re-evaluates (to not-pending) instead of forwarding.
-            if (r.Oe && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
+            if (r.Ge && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
             }
-            if (!f && !e.Ie) queuePendingNode(e);
+            if (!f && !e.Ne) queuePendingNode(e);
             notifyStatus(e, n, t, f, a);
         }
     });
 }
 
-export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource };
+export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, parkLoadingWindow, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource };