@solidjs/signals 2.0.0-beta.25 → 2.0.0-beta.27

package/dist/prod/core/action.js

@@ -1,4 +1,4 @@
-import { globalQueue, activeTransition, currentTransition, setActiveTransition, schedule, flush } from "./scheduler.js";
+import { globalQueue, activeTransition, currentTransition, schedule, flush } from "./scheduler.js";
 
 import { isThenable } from "./async.js";
 
@@ -79,13 +79,18 @@ function restoreTransition(e, r) {
         globalQueue.initTransition();
         let o = activeTransition;
         o.ie.push(i);
-        const done = (e, r, s = false) => {
+        const done = (e, r, u = false) => {
             o = currentTransition(o);
-            const u = o.ie.indexOf(i);
-            if (u >= 0) o.ie.splice(u, 1);
-            setActiveTransition(o);
+            const s = o.ie.indexOf(i);
+            if (s >= 0) o.ie.splice(s, 1);
+            // Re-adopt through initTransition like every other resumption site:
+            // a bare setActiveTransition leaves globalQueue._batch as a detached
+            // ambient batch, and anything registered before the scheduled flush
+            // (held writes on a merging transition, optimistic overrides,
+            // affects() marks) lands there with nothing to ever finalize it.
+                        globalQueue.initTransition(o);
             schedule();
-            s ? n(r) : t(e);
+            u ? n(r) : t(e);
         };
         const step = (e, r) => {
             let t;

package/dist/prod/core/async.js

@@ -1,4 +1,4 @@
-import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE } from "./constants.js";
+import { STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING } from "./constants.js";
 
 import { untrack, context, setSignal } from "./core.js";
 
@@ -6,7 +6,7 @@ import "./invariants.js";
 
 import { NotReadyError, StatusError } from "./error.js";
 
-import { trimStaleDeps, unobserved } from "./graph.js";
+import { unobserved, trimStaleDeps } 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, schedule, flush, queuePendingNode, insertSubs } from "./scheduler.js";
+import { globalQueue, GlobalQueue, clock, currentTransition, schedule, flush, queuePendingNode, insertSubs } 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,58 +38,125 @@ function clearPendingSources(e) {
     e.oe = undefined;
 }
 
-function setPendingError(e, n, r) {
+function setPendingError(e, n, t) {
     if (!n) {
         e._ = null;
         return;
     }
-    if (r instanceof NotReadyError && r.source === n) {
-        e._ = r;
+    if (t instanceof NotReadyError && t.source === n) {
+        e._ = t;
         return;
     }
-    const t = e._;
-    if (!(t instanceof NotReadyError) || t.source !== n) {
+    const r = e._;
+    if (!(r instanceof NotReadyError) || r.source !== n) {
         e._ = new NotReadyError(n);
     }
 }
 
 function forEachDependent(e, n) {
-    for (let r = e.o; r !== null; r = r.ue) n(r.le, r);
+    for (let t = e.o; t !== null; t = t.ue) n(t.le, t);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-        for (let r = e.u ?? null; r !== null; r = r.fe) {
-        for (let e = r.o; e !== null; e = e.ue) n(e.le, e);
+        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);
     }
 }
 
 // Queue a node to re-run on the next flush (used both when a pending source
 // settles and when an `isPending` observer must re-evaluate after a real error):
 // shared scheduling helper in heap.ts (tracked effects bypass the heap).
+// Settle-time counterpart of unlinkSubs' last-one-out check. A lazy node that
+// loses its last subscriber while STATUS_PENDING is exempt from autodispose
+// (the in-flight work is an observer), so whatever CLEARS that pending state
+// must run the release — otherwise the node stays linked and recomputes
+// forever with zero subscribers (#2934). The node's own promise/iterator
+// 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);
+}
+
+// Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
+// sources through its own recursion (no per-node settle callback), so after
+// the propagation completes, walk the same graph for stranded lazy nodes.
+// Collect-then-release so unobserved() never unlinks under the walk.
+function releaseSettledDependents(e) {
+    let n;
+    const t = new Set;
+    const visit = e => {
+        if (t.has(e)) return;
+        t.add(e);
+        if (!e.o && e.T & CONFIG_AUTO_DISPOSE) (n ??= []).push(e);
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+    if (n) for (const e of n) releaseIfSettledUnobserved(e);
+}
+
+// Error-dimension twin of settlePendingSource's blocked re-enqueue (#2949):
+// a node in STATUS_ERROR that recovers by recomputing to an UNCHANGED value
+// fires no value notification — the recovery is completely silent. But a
+// dependent that re-ran during the error window consumed its dirty flag and
+// committed nothing (the fresh sibling values it read were absorbed into an
+// errored run), so its committed value is stale. The propagated error is one
+// object identity down the whole dependent tree, and holding it is exactly
+// the "blocked on this error" marker — re-enqueue those holders so they
+// re-run: fresh values commit and flow, and a dependent with another
+// still-broken source simply re-errors. The async dimension needs no twin of
+// its own: recovery there passes through a pending window whose re-runners
+// set _blocked and ride settlePendingSource. Walks the full dependent graph
+// (releaseSettledDependents shape): identity holders can sit below an
+// intermediate whose own error state has since been scrubbed or replaced
+// (e.g. an error boundary's tree node).
+function settleErroredDependents(e, n) {
+    let t = false;
+    const r = new Set;
+    const visit = e => {
+        if (r.has(e)) return;
+        r.add(e);
+        if (e._ === n) {
+            enqueueSub(e);
+            t = true;
+        }
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+    if (t) schedule();
+}
+
 function settlePendingSource(e) {
     let n = false;
+    let t;
     const r = new Set;
     // Companion updates no-op without the verdict layer (null hook).
-        const t = GlobalQueue.ae;
-    const settle = o => {
-        if (r.has(o) || !removePendingSource(o, e)) return;
-        r.add(o);
-        o.ce = clock;
-        const u = o.oe?.values().next().value;
-        if (u) {
-            setPendingError(o, u);
-            t !== null && t(o);
+        const o = GlobalQueue.ce;
+    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);
+            o !== null && o(u);
         } else {
-            o.S &= ~STATUS_PENDING;
-            setPendingError(o);
-            t !== null && t(o);
-            if (o.Se) {
-                enqueueSub(o);
+            u.S &= ~STATUS_PENDING;
+            setPendingError(u);
+            o !== null && o(u);
+            if (u.de) {
+                enqueueSub(u);
                 n = true;
             }
-            o.Se = false;
+            u.de = 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);
         }
-        forEachDependent(o, settle);
+        forEachDependent(u, settle);
     };
     forEachDependent(e, settle);
+    // Release before the flush schedule below: unobserved() pulls the node back
+    // out of the heap, so the enqueueSub above never recomputes a released node.
+        if (t) for (const e of t) releaseIfSettledUnobserved(e);
     if (n) schedule();
 }
 
@@ -98,44 +165,69 @@ function isThenable(e) {
     return e != null && typeof e === "object" && typeof e.then === "function";
 }
 
-function handleAsync(e, n, r) {
-    let t = false;
+function handleAsync(e, n, t) {
+    let r = false;
     let o = false;
     if (typeof n === "object" && n !== null) {
         untrack(() => {
-            t = n[Symbol.asyncIterator];
-            o = !t && isThenable(n);
+            r = n[Symbol.asyncIterator];
+            o = !r && isThenable(n);
         });
     }
-    if (!o && !t) {
+    if (!o && !r) {
         e.Te = null;
         return n;
     }
     e.Te = n;
     let u;
-    const handleError = r => {
+    // 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
+    // reveal — must flow ambiently. The node can still carry a `_transition`
+    // stamp (pending-node bookkeeping rides through the stamping sites), and
+    // blindly re-entering that stamped, still-incomplete transaction stashed
+    // the reveal with it — a deadlock when the transaction's completion
+    // depended on the reveal (#2937). An ESCAPED first load did register and
+    // keeps transition scheduling; initialized (value-holding) pending settles
+    // 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)) {
+            // 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;
+            return;
+        }
+        globalQueue.initTransition(n);
+    };
+    const handleError = t => {
         if (e.Te !== n) return;
-        globalQueue.initTransition(resolveTransition(e));
+        settleTransition();
         // NotReadyError from rejected promises should be treated as pending, not error
-                notifyStatus(e, r instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, r);
-        e.ce = clock;
+                const r = t instanceof NotReadyError;
+        notifyStatus(e, r ? STATUS_PENDING : STATUS_ERROR, t);
+        e.Se = 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).
+                if (!r) releaseSettledDependents(e);
     };
-    const asyncWrite = (t, o) => {
+    const asyncWrite = (r, o) => {
         if (e.Te !== n) return;
         // If the node was dirtied by a newer write (optimistic override or regular),
         // skip this stale async result — the upcoming flush will recompute the node
         // with the new value, creating a fresh Promise that supersedes this one.
                 if (e.se & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-        globalQueue.initTransition(resolveTransition(e));
+        settleTransition();
         const u = !!(e.S & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
         const l = resolveLane(e);
-        if (l) l.de.delete(e);
-        if (r) {
-            r(t);
+        if (l) l.Ne.delete(e);
+        if (t) {
+            t(r);
             if (u) clearStatus(e, true);
-        } else if (e.Ee !== undefined) {
+        } else if (e.Ae !== 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
@@ -145,8 +237,8 @@ function handleAsync(e, n, r) {
             // (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.Ne === NOT_PENDING) queuePendingNode(e);
-            e.Ne = t;
+            if (e.De === NOT_PENDING) queuePendingNode(e);
+            e.De = 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)
@@ -154,22 +246,22 @@ function handleAsync(e, n, r) {
             // 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.Ie !== null && GlobalQueue.Ie(e, t);
+                        GlobalQueue._e !== null && GlobalQueue._e(e, r);
             if (!hasActiveOverride(e)) insertSubs(e);
-            e.ce = clock;
+            e.Se = clock;
         } else if (l) {
             // Route through lane's effect queue for independent flushing
-            const n = e.Ae;
-            const r = e.Pe;
-            const o = e.Re;
+            const n = e.Pe;
+            const t = e.Ue;
+            const o = e.be;
             try {
-                if (!n && u || !o || !o(t, r)) {
-                    e.Pe = t;
-                    e.ce = clock;
+                if (!n && u || !o || !o(r, t)) {
+                    e.Ue = r;
+                    e.Se = 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.Ie !== null && GlobalQueue.Ie(e, t);
+                                        GlobalQueue._e !== null && GlobalQueue._e(e, r);
                     insertSubs(e, true);
                 }
             } catch (n) {
@@ -181,7 +273,7 @@ function handleAsync(e, n, r) {
             }
         } else {
             try {
-                setSignal(e, () => t);
+                setSignal(e, () => r);
             } catch (n) {
                 // Same containment as above: setSignal's comparator throw is the only
                 // pre-commit failure here, and there is no user callsite to throw to.
@@ -198,17 +290,21 @@ function handleAsync(e, n, r) {
     // work (a lazy async memo would otherwise tear down and re-execute — one
     // fetch per suspended re-read). Settling is that observer's release, so
     // it runs the same last-one-out check the other release sites run.
+    // Returns whether the node released, so the iterator branch can stop
+    // pulling values instead of pumping an unobserved stream forever (#2935).
         const settleAutodispose = () => {
         if (e.T & CONFIG_AUTO_DISPOSE && !e.o && !(e.S & STATUS_PENDING)) {
             unobserved(e);
+            return true;
         }
+        return false;
     };
     if (o) {
-        let r = false, t = false, o, l = true;
+        let t = false, r = false, o, l = true;
         n.then(e => {
             if (l) {
                 u = e;
-                r = true;
+                t = true;
             } else {
                 asyncWrite(e);
                 settleAutodispose();
@@ -216,87 +312,95 @@ function handleAsync(e, n, r) {
         }, e => {
             if (l) {
                 o = e;
-                t = true;
+                r = true;
             } else {
                 handleError(e);
                 settleAutodispose();
             }
         });
         l = false;
-        if (t) {
+        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 (!r) {
+        } else if (!t) {
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
         }
     }
-    if (t) {
-        const r = n[Symbol.asyncIterator]();
-        let t = false;
+    if (r) {
+        const t = n[Symbol.asyncIterator]();
+        let r = false;
         let o = false;
         let l = true;
         cleanup(() => {
             if (o) return;
             o = true;
             try {
-                const e = r.return?.();
+                const e = t.return?.();
                 if (isThenable(e)) e.then(undefined, () => {});
             } catch {}
         });
+        // 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).
+                const iterateOrRelease = () => {
+            if (!settleAutodispose()) iterate();
+        };
         const iterate = () => {
-            let i, s, f = false, a = false, c = true;
-            r.next().then(r => {
+            let s, i, f = false, a = false, c = true;
+            t.next().then(t => {
                 if (c) {
-                    i = r;
+                    s = t;
                     f = true;
-                    if (r.done) o = true;
+                    if (t.done) o = true;
                 } else if (e.Te !== n) {
                     return;
-                } else if (!r.done) {
-                    t = true;
-                    asyncWrite(r.value, iterate);
+                } else if (!t.done) {
+                    r = true;
+                    asyncWrite(t.value, iterateOrRelease);
                 } else {
                     o = true;
-                    if (t) {
+                    if (r) {
                         schedule();
                         flush();
                     } else {
                         // Empty completion settles like the immediately-done sync path.
                         asyncWrite(undefined);
                     }
+                    settleAutodispose();
                 }
-            }, r => {
+            }, t => {
                 if (c) {
-                    s = r;
+                    i = t;
                     a = true;
                 } else if (e.Te === n) {
                     o = true;
-                    handleError(r);
+                    handleError(t);
+                    settleAutodispose();
                 }
             });
             c = false;
             if (a) {
                 // Match the promise branch, but only rethrow during the initial read.
                 o = true;
-                handleError(s);
-                if (l) throw s;
+                handleError(i);
+                if (l) throw i;
                 return true;
             }
-            if (f && !i.done) {
-                u = i.value;
-                t = true;
+            if (f && !s.done) {
+                u = s.value;
+                r = true;
                 return iterate();
             }
-            return f && i.done;
+            return f && s.done;
         };
-        const i = iterate();
+        const s = iterate();
         // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
                 l = false;
-        if (!t && !i) {
+        if (!r && !s) {
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
         }
@@ -306,75 +410,75 @@ function handleAsync(e, n, r) {
 
 function clearStatus(e, n = false) {
     if (e.oe) clearPendingSources(e);
-    if (e.Se) e.Se = false;
+    if (e.de) e.de = 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._e = false;
+        e.Re = 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.be || e.ge) GlobalQueue.ae(e);
-    if (e.u && GlobalQueue.he !== null) GlobalQueue.he(e);
+        if (e.he || e.pe) GlobalQueue.ce(e);
+    if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
     if (e.i) e.i();
 }
 
-function notifyStatus(e, n, r, t, o) {
+function notifyStatus(e, n, t, r, o) {
     // Wrap regular errors to track source node
-    if (n === STATUS_ERROR && !(r instanceof StatusError) && !(r instanceof NotReadyError)) r = new StatusError(e, r);
-    const u = n === STATUS_PENDING && r instanceof NotReadyError ? r.source : undefined;
+    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 i = n === STATUS_PENDING && e.Ee !== undefined && !l;
-    const s = i && hasActiveOverride(e);
-    if (!t) {
+    const s = n === STATUS_PENDING && e.Ae !== undefined && !l;
+    const i = s && hasActiveOverride(e);
+    if (!r) {
         if (n === STATUS_PENDING && u) {
             addPendingSource(e, u);
             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, r);
+                        setPendingError(e, u, t);
         } else {
             clearPendingSources(e);
             e.S = n | (n !== STATUS_ERROR ? e.S & STATUS_UNINITIALIZED : 0);
-            e._ = r;
+            e._ = t;
         }
-        GlobalQueue.ae !== null && GlobalQueue.ae(e);
-        if (e.u && GlobalQueue.he !== null) GlobalQueue.he(e);
+        GlobalQueue.ce !== null && GlobalQueue.ce(e);
+        if (e.u && GlobalQueue.Ge !== null) GlobalQueue.Ge(e);
     }
-    if (o && !t) {
+    if (o && !r) {
         assignOrMergeLane(e, o);
     }
-    const f = t || s;
-    const a = t || i ? undefined : o;
+    const f = r || i;
+    const a = r || s ? undefined : o;
     if (e.i) {
-        if (t && n === STATUS_PENDING) {
+        if (r && n === STATUS_PENDING) {
             return;
         }
         if (f) {
-            e.i(n, r);
+            e.i(n, t);
         } else {
             e.i();
         }
         return;
     }
-    forEachDependent(e, (e, t) => {
-        e.ce = clock;
-        if (n === STATUS_PENDING && u && !e.oe?.has(u) || n !== STATUS_PENDING && (e._ !== r || e.oe)) {
+    forEachDependent(e, (e, r) => {
+        e.Se = 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 (t.De && n !== STATUS_PENDING && !(r instanceof NotReadyError)) {
+            if (r.Oe && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
             }
-            if (!f && !e.Ue) queuePendingNode(e);
-            notifyStatus(e, n, r, f, a);
+            if (!f && !e.Ie) queuePendingNode(e);
+            notifyStatus(e, n, t, f, a);
         }
     });
 }
 
-export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, setPendingError, settlePendingSource };
+export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource };