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

package/dist/prod/core/async.js

@@ -1,20 +1,20 @@
-import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE } from "./constants.js";
+import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_DISPOSED } from "./constants.js";
 
-import { untrack, context, setSignal } from "./core.js";
+import { untrack, setSignal, context } from "./core.js";
 
 import "./invariants.js";
 
-import { NotReadyError, StatusError } from "./error.js";
+import { StatusError, NotReadyError } from "./error.js";
 
 import { trimStaleDeps, unobserved } from "./graph.js";
 
 import { enqueueSub } from "./heap.js";
 
-import { resolveTransition, hasActiveOverride, assignOrMergeLane, resolveLane } from "./lanes.js";
+import { hasActiveOverride, assignOrMergeLane, resolveLane, resolveTransition } from "./lanes.js";
 
 import { cleanup } from "./owner.js";
 
-import { globalQueue, GlobalQueue, schedule, flush, queuePendingNode, insertSubs, clock, currentTransition } from "./scheduler.js";
+import { GlobalQueue, schedule, flush, queuePendingNode, insertSubs, clock, currentTransition, globalQueue } 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 —
@@ -45,7 +45,7 @@ function clearPendingSources(e) {
  * 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;
+    e.le = 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
@@ -70,10 +70,10 @@ function setPendingError(e, n, t) {
 }
 
 function forEachDependent(e, n) {
-    for (let t = e.o; t !== null; t = t.le) n(t.fe, t);
+    for (let t = e.o; t !== null; t = t.ue) 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.ae) {
-        for (let e = t.o; e !== null; e = e.le) n(e.fe, e);
+        for (let e = t.o; e !== null; e = e.ue) n(e.fe, e);
     }
 }
 
@@ -145,35 +145,35 @@ function settlePendingSource(e) {
     const r = new Set;
     // Companion updates no-op without the verdict layer (null hook).
         const o = GlobalQueue.Se;
-    const settle = u => {
-        if (r.has(u) || !removePendingSource(u, e)) return;
-        r.add(u);
-        u.de = clock;
-        const i = u.oe?.values().next().value;
+    const settle = l => {
+        if (r.has(l) || !removePendingSource(l, e)) return;
+        r.add(l);
+        l.de = clock;
+        const u = l.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);
+                const i = l.S & STATUS_ERROR;
+        if (u) {
+            if (!i) setPendingError(l, u);
+            o !== null && o(l);
         } else {
-            u.S &= ~STATUS_PENDING;
-            if (!l) setPendingError(u);
-            o !== null && o(u);
-            if (u.ue) {
-                enqueueSub(u);
+            l.S &= ~STATUS_PENDING;
+            if (!i) setPendingError(l);
+            o !== null && o(l);
+            if (l.le) {
+                enqueueSub(l);
                 n = true;
             }
-            u.ue = false;
+            l.le = 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.
-                        if (!u.o && u.T & CONFIG_AUTO_DISPOSE) (t ??= []).push(u);
+                        if (!l.o && l.T & CONFIG_AUTO_DISPOSE) (t ??= []).push(l);
         }
-        forEachDependent(u, settle);
+        forEachDependent(l, settle);
     };
     forEachDependent(e, settle);
     // Release before the flush schedule below: unobserved() pulls the node back
@@ -203,7 +203,7 @@ function handleAsync(e, n, t) {
         return n;
     }
     e.Te = n;
-    let u;
+    let l;
     // Settle-time transition re-entry. The loading rail is invisible to
     // transactions (#2933): a boundary-caught first load never registers as an
     // async reporter, so its settle — the boundary's fallback -> content
@@ -253,15 +253,15 @@ function handleAsync(e, n, t) {
         // with the new value, creating a fresh Promise that supersedes this one.
                 if (e.se & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
         settleTransition();
-        const u = !!(e.S & STATUS_UNINITIALIZED);
+        const l = !!(e.S & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
-        const i = resolveLane(e);
-        if (i) i.Ae.delete(e);
+        const u = resolveLane(e);
+        if (u) u.Ae.delete(e);
         if (t) {
             t(r);
-            if (u) clearStatus(e, true);
-        } else if (e._e !== undefined) {
+            if (l) clearStatus(e, true);
+        } else if (e.De !== 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
@@ -271,8 +271,8 @@ function handleAsync(e, n, t) {
             // (A17 — every reader sees the override); the revert reveals whatever
             // has committed by then, so corrections reveal atomically with their
             // transition rather than escaping it.
-            if (e.De === NOT_PENDING) queuePendingNode(e);
-            e.De = r;
+            if (e._e === NOT_PENDING) queuePendingNode(e);
+            e._e = r;
             // The hold is a companion-visible write like any other (A13/A19): the
             // clearStatus() above computed its verdict before the hold existed, so
             // isPending must re-derive (the value is not final until commit — V1)
@@ -283,14 +283,14 @@ function handleAsync(e, n, t) {
                         GlobalQueue.Pe !== null && GlobalQueue.Pe(e, r);
             if (!hasActiveOverride(e)) insertSubs(e);
             e.de = clock;
-        } else if (i) {
+        } else if (u) {
             // Route through lane's effect queue for independent flushing
             const n = e.Re;
-            const t = e.Ue;
-            const o = e.be;
+            const t = e.be;
+            const o = e.Ue;
             try {
-                if (!n && u || !o || !o(r, t)) {
-                    e.Ue = r;
+                if (!n && l || !o || !o(r, t)) {
+                    e.be = r;
                     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
@@ -320,7 +320,7 @@ function handleAsync(e, n, t) {
         // 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;
+                if (e._e === NOT_PENDING) e.Ee = false;
         settlePendingSource(e);
         schedule();
         flush();
@@ -340,94 +340,68 @@ function handleAsync(e, n, t) {
         }
         return false;
     };
-    if (o) {
-        let t = false, r = false, o, i = true;
-        n.then(e => {
-            if (i) {
-                u = e;
-                t = true;
-            } else {
-                asyncWrite(e);
-                settleAutodispose();
-            }
-        }, e => {
-            if (i) {
-                o = e;
-                r = true;
-            } else {
-                handleError(e);
-                settleAutodispose();
-            }
-        });
-        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
-            // momentarily read as `undefined`.
-            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 i = true;
-        cleanup(() => {
-            if (o) return;
-            o = true;
+    // Consumes an AsyncIterable as this flight's value stream. Two postures:
+    // LIVE (called synchronously from this read — the compute returned an
+    // iterable directly, or a sync-settled thenable held one), where the
+    // initial drain may stash a sync first yield for the caller to return and
+    // close registration uses the ambient owner; and DEFERRED (the flattening
+    // path — a thenable resolved to an iterable in a later microtask), where
+    // there is no caller to serve and no ambient owner: sync-settled steps
+    // write through asyncWrite, and close registration goes through the slot
+    // the thenable branch pre-registered while it still owned the context.
+    // Returns whether a sync answer landed (first yield or empty completion) —
+    // meaningful only in the live posture.
+        const consumeIterator = (t, r) => {
+        const o = t[Symbol.asyncIterator]();
+        let u = false;
+        let i = false;
+        let s = !r;
+        const close = () => {
+            if (i) return;
+            i = true;
             try {
-                const e = t.return?.();
+                const e = o.return?.();
                 if (isThenable(e)) e.then(undefined, () => {});
             } catch {}
-        });
+        };
+        r ? r(close) : cleanup(close);
         // Release check before each next pull: an unobserved lazy node must tear
-        // down (its cleanup above closes the iterator) instead of pumping the
-        // stream forever with zero subscribers (#2935).
+        // down (its close above runs via disposal, closing the iterator) instead
+        // of pumping the stream forever with zero subscribers (#2935).
                 const iterateOrRelease = () => {
             if (!settleAutodispose()) iterate();
         };
         const iterate = () => {
-            let l, s, f = false, a = false, c = true;
+            let t, r, 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 S = o.next();
             const d = isThenable(S) ? S : {
                 then: e => void e(S)
             };
-            d.then(t => {
+            d.then(r => {
                 // 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;
+                // silently dropped. (The deferred posture never has a caller, so
+                // initialRead starts false there and everything writes through.)
+                if (c && s) {
+                    t = r;
                     f = true;
-                    if (t.done) o = true;
+                    if (r.done) i = true;
                 } else if (e.Te !== n) {
                     return;
-                } else if (!t.done) {
-                    r = true;
-                    asyncWrite(t.value, iterateOrRelease);
+                } else if (!r.done) {
+                    u = true;
+                    asyncWrite(r.value, iterateOrRelease);
                 } else {
-                    o = true;
-                    if (r) {
+                    i = true;
+                    if (u) {
                         schedule();
                         flush();
                     } else {
@@ -437,11 +411,11 @@ function handleAsync(e, n, t) {
                     settleAutodispose();
                 }
             }, t => {
-                if (c) {
-                    s = t;
+                if (c && s) {
+                    r = t;
                     a = true;
                 } else if (e.Te === n) {
-                    o = true;
+                    i = true;
                     handleError(t);
                     settleAutodispose();
                 }
@@ -449,24 +423,104 @@ function handleAsync(e, n, t) {
             c = false;
             if (a) {
                 // Match the promise branch, but only rethrow during the initial read.
-                o = true;
-                handleError(s);
-                if (i) throw s;
+                i = true;
+                handleError(r);
+                if (s) throw r;
                 return true;
             }
-            if (f && !l.done) {
-                u = l.value;
-                r = true;
+            if (f && !t.done) {
+                l = t.value;
+                u = true;
                 return iterate();
             }
-            return f && l.done;
+            return f && t.done;
         };
-        const l = iterate();
+        const f = iterate();
         // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
-                i = false;
-        if (!r && !l) {
+                s = false;
+        return u || f;
+    };
+    // Landed-synchronously verdict for a LIVE iterator drain; null when no live
+    // drain ran (plain promise flight, or a deferred flatten). Drives the
+    // shared NotReady/loading tail below.
+        let u = null;
+    // Flatten one async level: a thenable that RESOLVES to an AsyncIterable —
+    // the shape every async stub returning a stream produces — consumes as the
+    // stream itself rather than settling on the iterable object. One level
+    // only: A+ `then` already collapses nested thenables, so the resolved
+    // value is never itself a thenable.
+        const flattenIfIterable = (e, n) => {
+        let t = false;
+        if (typeof e === "object" && e !== null) {
+            untrack(() => {
+                t = e[Symbol.asyncIterator];
+            });
+        }
+        if (!t) return false;
+        const r = consumeIterator(e, n);
+        if (!n) u = r;
+        return true;
+    };
+    if (o) {
+        let t = false, r = false, o, u = true;
+        // Close registration for the flattening path. Consumption starts in a
+        // microtask where the ambient owner is gone (or worse, someone else's),
+        // so `cleanup()` can't be used — the close targets el's disposal list
+        // directly, exactly where a live cleanup() during this recompute would
+        // have put it. Deliberately NOT pre-registered at flight start: a
+        // non-null `_disposal` reclassifies the node into recompute's deferred
+        // (zombie) disposal path, and plain promise flights — the overwhelming
+        // majority — must not pay that. Only a flight that actually flattens
+        // becomes disposal-bearing, which is exactly the class a directly
+        // returned iterable already occupies.
+                const registerDeferredClose = n => {
+            if (!e.he) e.he = n; else if (Array.isArray(e.he)) e.he.push(n); else e.he = [ e.he, n ];
+        };
+        n.then(r => {
+            if (u) {
+                l = r;
+                t = true;
+            } else if (e.Te === n && !(e.se & REACTIVE_DISPOSED) && flattenIfIterable(r, registerDeferredClose)) ; else {
+                asyncWrite(r);
+                settleAutodispose();
+            }
+        }, e => {
+            if (u) {
+                o = e;
+                r = true;
+            } else {
+                handleError(e);
+                settleAutodispose();
+            }
+        });
+        u = 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
+            // momentarily read as `undefined`.
+            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.be;
+            globalQueue.initTransition(resolveTransition(e));
+            throw new NotReadyError(context);
+        } else if (!flattenIfIterable(l)) {
+            // Synchronously-resolved promise: the first real answer landed.
+            e.Ee = false;
+        }
+        // A sync-resolved promise holding an AsyncIterable flattened LIVE (we
+        // are still inside the synchronous read): full initial-drain semantics
+        // apply and the shared tail below settles the verdict.
+        }
+    if (r) flattenIfIterable(n);
+    if (u !== null) {
+        if (!u) {
             // Loading window: serve commit #0 (see the promise branch above).
-            if (e.Ee) return e.Ue;
+            if (e.Ee) return e.be;
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
         }
@@ -474,52 +528,52 @@ function handleAsync(e, n, t) {
         // answer; async yields clear inside asyncWrite.
                 e.Ee = false;
     }
-    return u;
+    return l;
 }
 
 function clearStatus(e, n = false) {
     if (e.oe) clearPendingSources(e);
-    if (e.ue) e.ue = false;
+    if (e.le) e.le = 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.he = false;
+        e.pe = 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.ge || e.pe) GlobalQueue.Se(e);
-    if (e.u && GlobalQueue.Oe !== null) GlobalQueue.Oe(e);
+        if (e.Oe || e.ge) GlobalQueue.Se(e);
+    if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
     if (e.i) e.i();
 }
 
 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 i = u === e;
-    const l = n === STATUS_PENDING && e._e !== undefined && !i;
-    const s = l && hasActiveOverride(e);
+    const l = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
+    const u = l === e;
+    const i = n === STATUS_PENDING && e.De !== undefined && !u;
+    const s = i && hasActiveOverride(e);
     if (!r) {
-        if (n === STATUS_PENDING && u) {
-            addPendingSource(e, u);
+        if (n === STATUS_PENDING && l) {
+            addPendingSource(e, l);
             e.S = STATUS_PENDING | e.S & STATUS_UNINITIALIZED;
             // Preserve the current source on this propagation so render-effect notification
             // can register every distinct pending source with the transition.
-                        setPendingError(e, u, t);
+                        setPendingError(e, l, t);
         } else {
             clearPendingSources(e);
             e.S = n | (n !== STATUS_ERROR ? e.S & STATUS_UNINITIALIZED : 0);
             e._ = t;
         }
         GlobalQueue.Se !== null && GlobalQueue.Se(e);
-        if (e.u && GlobalQueue.Oe !== null) GlobalQueue.Oe(e);
+        if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
     }
     if (o && !r) {
         assignOrMergeLane(e, o);
     }
     const f = r || s;
-    const a = r || l ? undefined : o;
+    const a = r || i ? undefined : o;
     if (e.i) {
         if (r && n === STATUS_PENDING) {
             return;
@@ -533,13 +587,13 @@ function notifyStatus(e, n, t, r, o) {
     }
     forEachDependent(e, (e, r) => {
         e.de = clock;
-        if (n === STATUS_PENDING && u && !e.oe?.has(u) || n !== STATUS_PENDING && (e._ !== t || e.oe)) {
+        if (n === STATUS_PENDING && l && !e.oe?.has(l) || 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.Ge && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
+            if (r.ye && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;