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

package/dist/dev.js

@@ -1707,8 +1707,40 @@ function forEachDependent(el, fn) {
 // 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(node) {
+  node._fn &&
+    node._config & CONFIG_AUTO_DISPOSE &&
+    !node._subs &&
+    !(node._flags & REACTIVE_ZOMBIE) &&
+    !(node._statusFlags & STATUS_PENDING) &&
+    unobserved(node);
+}
+// 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(el) {
+  let candidates;
+  const visited = new Set();
+  const visit = node => {
+    if (visited.has(node)) return;
+    visited.add(node);
+    if (!node._subs && node._config & CONFIG_AUTO_DISPOSE) (candidates ??= []).push(node);
+    forEachDependent(node, visit);
+  };
+  forEachDependent(el, visit);
+  if (candidates) for (const node of candidates) releaseIfSettledUnobserved(node);
+}
 function settlePendingSource(el) {
   let scheduled = false;
+  let released;
   const visited = new Set();
   // Companion updates no-op without the verdict layer (null hook).
   const updateCompanions = GlobalQueue._updatePendingSignal;
@@ -1729,10 +1761,17 @@ function settlePendingSource(el) {
         scheduled = true;
       }
       node._blocked = 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 (!node._subs && node._config & CONFIG_AUTO_DISPOSE) (released ??= []).push(node);
     }
     forEachDependent(node, settle);
   };
   forEachDependent(el, 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 (released) for (const node of released) releaseIfSettledUnobserved(node);
   if (scheduled) schedule();
 }
 // Object-thenable detection (Promises/A+ shape).
@@ -1776,12 +1815,41 @@ function handleAsync(el, result, setter) {
   }
   el._inFlight = result;
   let syncValue;
+  // 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 transition = resolveTransition(el);
+    if (
+      transition &&
+      el._statusFlags & STATUS_UNINITIALIZED &&
+      !currentTransition(transition)._asyncReporters.has(el)
+    ) {
+      // Drop the stale stamp too: the plain settle write (setSignal) and the
+      // stash-path restamp both re-enter the transaction through it.
+      el._transition = null;
+      return;
+    }
+    globalQueue.initTransition(transition);
+  };
   const handleError = error => {
     if (el._inFlight !== result) return;
-    globalQueue.initTransition(resolveTransition(el));
+    settleTransition();
     // NotReadyError from rejected promises should be treated as pending, not error
-    notifyStatus(el, error instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, error);
+    const stillPending = error instanceof NotReadyError;
+    notifyStatus(el, stillPending ? STATUS_PENDING : STATUS_ERROR, error);
     el._time = 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 (!stillPending) releaseSettledDependents(el);
   };
   const asyncWrite = (value, then) => {
     if (el._inFlight !== result) return;
@@ -1789,7 +1857,7 @@ function handleAsync(el, result, setter) {
     // 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 (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-    globalQueue.initTransition(resolveTransition(el));
+    settleTransition();
     const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
     trimStaleDeps(el);
     clearStatus(el);
@@ -1861,10 +1929,14 @@ function handleAsync(el, result, setter) {
   // 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 (el._config & CONFIG_AUTO_DISPOSE && !el._subs && !(el._statusFlags & STATUS_PENDING)) {
       unobserved(el);
+      return true;
     }
+    return false;
   };
   if (thenable) {
     let resolved = false,
@@ -1916,6 +1988,12 @@ function handleAsync(el, result, setter) {
         if (isThenable(returned)) returned.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 syncResult,
         syncError,
@@ -1932,7 +2010,7 @@ function handleAsync(el, result, setter) {
             return;
           } else if (!r.done) {
             hadValue = true;
-            asyncWrite(r.value, iterate);
+            asyncWrite(r.value, iterateOrRelease);
           } else {
             completed = true;
             if (hadValue) {
@@ -1942,6 +2020,7 @@ function handleAsync(el, result, setter) {
               // Empty completion settles like the immediately-done sync path.
               asyncWrite(undefined);
             }
+            settleAutodispose();
           }
         },
         e => {
@@ -1951,6 +2030,7 @@ function handleAsync(el, result, setter) {
           } else if (el._inFlight === result) {
             completed = true;
             handleError(e);
+            settleAutodispose();
           }
         }
       );
@@ -5543,6 +5623,14 @@ function isRawValue(value) {
 }
 function markRawOne(v) {
   if (isWrappable(v)) {
+    // A store proxy is already tracked elsewhere: the shallow boundary passes
+    // it through by reference (replaced, never edited — same slot semantics
+    // as a raw) instead of claiming it raw. The sticky mark is global, so
+    // marking a live proxy would make wrap() serve it verbatim through every
+    // OTHER store too — downstream deep stores then captured it instead of
+    // wrapping it in their own family, and their writes landed in the
+    // upstream store's override layer (#2932).
+    if (v[$TARGET] !== undefined) return;
     if (storeLookup.has(v))
       throw new Error(
         "shallow store: an ingested record is already tracked as a deep store — one value cannot present both wrapped and raw"
@@ -6281,7 +6369,14 @@ const storeTraps = {
     }
     // Untracked fall-through (tracked reads already threw via their node in
     // read(); the dev strictRead error above wins first for memo parity).
-    if (!selfRead) throwIfUninitialized(target);
+    // Observer-present reads must NOT re-consult the flag here: during the
+    // settle flush the firewall has recomputed (first values live on the
+    // pending rail, served by read() above) but its UNINITIALIZED clear is
+    // deferred to batch commit — vetoing read()'s verdict with the stale flag
+    // threw a fresh NotReadyError for an already-settled source, which no
+    // sweep would ever release (#2938: projection over an async store wedged
+    // its Loading boundary on `undefined`).
+    if (!selfRead && !getObserver()) throwIfUninitialized(target);
     return isWrappable(value) ? wrap(value, target) : value;
   },
   has(target, property) {
@@ -6315,8 +6410,19 @@ const storeTraps = {
         const prevHas = prevLayer
           ? prevLayer[property] !== $DELETED
           : property in target[STORE_VALUE];
-        const value = unwrapStoreValue(rawValue);
-        if (target[STORE_SHALLOW] && isWrappable(value)) rawValues.add(value);
+        // Shallow slots hold store proxies verbatim (pass-through reference,
+        // never raw-marked — see markRawOne/#2932); everything else unwraps
+        // and marks as usual.
+        const passThrough = !!target[STORE_SHALLOW] && rawValue?.[$TARGET] !== undefined;
+        const value = passThrough ? rawValue : unwrapStoreValue(rawValue);
+        if (target[STORE_SHALLOW] && !passThrough && isWrappable(value)) {
+          // Flip the live gate too: a bare add was inert unless something else
+          // had already marked a raw somewhere (wrap() checks rawValuesUsed
+          // first), so the documented set-trap ingest mark silently no-oped in
+          // apps whose only shallow data arrived through writes.
+          rawValuesUsed = true;
+          rawValues.add(value);
+        }
         // Symbol-keyed writes on arrays are metadata, not index writes — never run
         // them through the numeric index/length machinery (`parseInt` on a symbol
         // throws). #2769

package/dist/node.cjs

@@ -1572,32 +1572,68 @@ function forEachDependent(e, t) {
 // 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.Ue && e.Ge & CONFIG_AUTO_DISPOSE && !e.G && !(e.Le & REACTIVE_ZOMBIE) && !(e.xe & 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 t;
+    const n = new Set;
+    const visit = e => {
+        if (n.has(e)) return;
+        n.add(e);
+        if (!e.G && e.Ge & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+    if (t) for (const e of t) releaseIfSettledUnobserved(e);
+}
+
 function settlePendingSource(e) {
     let t = false;
-    const n = new Set;
+    let n;
+    const r = new Set;
     // Companion updates no-op without the verdict layer (null hook).
-        const r = GlobalQueue.le;
-    const settle = i => {
-        if (n.has(i) || !removePendingSource(i, e)) return;
-        n.add(i);
-        i.F = clock;
-        const o = i.$e?.values().next().value;
-        if (o) {
-            setPendingError(i, o);
-            r !== null && r(i);
+        const i = GlobalQueue.le;
+    const settle = o => {
+        if (r.has(o) || !removePendingSource(o, e)) return;
+        r.add(o);
+        o.F = clock;
+        const s = o.$e?.values().next().value;
+        if (s) {
+            setPendingError(o, s);
+            i !== null && i(o);
         } else {
-            i.xe &= ~STATUS_PENDING;
-            setPendingError(i);
-            r !== null && r(i);
-            if (i.It) {
-                enqueueSub(i);
+            o.xe &= ~STATUS_PENDING;
+            setPendingError(o);
+            i !== null && i(o);
+            if (o.It) {
+                enqueueSub(o);
                 t = true;
             }
-            i.It = false;
+            o.It = 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 (!o.G && o.Ge & CONFIG_AUTO_DISPOSE) (n ??= []).push(o);
         }
-        forEachDependent(i, settle);
+        forEachDependent(o, 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 (n) for (const e of n) releaseIfSettledUnobserved(e);
     if (t) schedule();
 }
 
@@ -1621,12 +1657,37 @@ function handleAsync(e, t, n) {
     }
     e.ut = t;
     let o;
+    // 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 t = resolveTransition(e);
+        if (t && e.xe & STATUS_UNINITIALIZED && !currentTransition(t).M.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.T = null;
+            return;
+        }
+        globalQueue.initTransition(t);
+    };
     const handleError = n => {
         if (e.ut !== t) return;
-        globalQueue.initTransition(resolveTransition(e));
+        settleTransition();
         // NotReadyError from rejected promises should be treated as pending, not error
-                notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
+                const r = n instanceof NotReadyError;
+        notifyStatus(e, r ? STATUS_PENDING : STATUS_ERROR, n);
         e.F = 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 = (r, i) => {
         if (e.ut !== t) return;
@@ -1634,7 +1695,7 @@ function handleAsync(e, t, n) {
         // 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.Le & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-        globalQueue.initTransition(resolveTransition(e));
+        settleTransition();
         const o = !!(e.xe & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
@@ -1706,10 +1767,14 @@ function handleAsync(e, t, n) {
     // 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.Ge & CONFIG_AUTO_DISPOSE && !e.G && !(e.xe & STATUS_PENDING)) {
             unobserved(e);
+            return true;
         }
+        return false;
     };
     if (i) {
         let n = false, r = false, i, s = true;
@@ -1755,6 +1820,12 @@ function handleAsync(e, t, n) {
                 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 u, l, a = false, c = false, f = true;
             n.next().then(n => {
@@ -1766,7 +1837,7 @@ function handleAsync(e, t, n) {
                     return;
                 } else if (!n.done) {
                     r = true;
-                    asyncWrite(n.value, iterate);
+                    asyncWrite(n.value, iterateOrRelease);
                 } else {
                     i = true;
                     if (r) {
@@ -1776,6 +1847,7 @@ function handleAsync(e, t, n) {
                         // Empty completion settles like the immediately-done sync path.
                         asyncWrite(undefined);
                     }
+                    settleAutodispose();
                 }
             }, n => {
                 if (f) {
@@ -1784,6 +1856,7 @@ function handleAsync(e, t, n) {
                 } else if (e.ut === t) {
                     i = true;
                     handleError(n);
+                    settleAutodispose();
                 }
             });
             f = false;
@@ -4913,6 +4986,14 @@ function isRawValue(e) {
 
 function markRawOne(e) {
     if (isWrappable(e)) {
+        // A store proxy is already tracked elsewhere: the shallow boundary passes
+        // it through by reference (replaced, never edited — same slot semantics
+        // as a raw) instead of claiming it raw. The sticky mark is global, so
+        // marking a live proxy would make wrap() serve it verbatim through every
+        // OTHER store too — downstream deep stores then captured it instead of
+        // wrapping it in their own family, and their writes landed in the
+        // upstream store's override layer (#2932).
+        if (e[$TARGET] !== undefined) return;
         rawValuesUsed = true;
         rawValues.add(e);
     }
@@ -5559,7 +5640,14 @@ const storeTraps = {
         }
         // Untracked fall-through (tracked reads already threw via their node in
         // read(); the dev strictRead error above wins first for memo parity).
-                if (!r) throwIfUninitialized(e);
+        // Observer-present reads must NOT re-consult the flag here: during the
+        // settle flush the firewall has recomputed (first values live on the
+        // pending rail, served by read() above) but its UNINITIALIZED clear is
+        // deferred to batch commit — vetoing read()'s verdict with the stale flag
+        // threw a fresh NotReadyError for an already-settled source, which no
+        // sweep would ever release (#2938: projection over an async store wedged
+        // its Loading boundary on `undefined`).
+                if (!r && !getObserver()) throwIfUninitialized(e);
         return isWrappable(f) ? wrap(f, e) : f;
     },
     has(e, t) {
@@ -5591,37 +5679,48 @@ const storeTraps = {
                 const u = getOverlayLayer(e, t);
                 const l = u ? u[t] : i;
                 const a = u ? u[t] !== $DELETED : t in e[STORE_VALUE];
-                const c = unwrapStoreValue(n);
-                if (e[STORE_SHALLOW] && isWrappable(c)) rawValues.add(c);
+                // Shallow slots hold store proxies verbatim (pass-through reference,
+                // never raw-marked — see markRawOne/#2932); everything else unwraps
+                // and marks as usual.
+                                const c = !!e[STORE_SHALLOW] && n?.[$TARGET] !== undefined;
+                const f = c ? n : unwrapStoreValue(n);
+                if (e[STORE_SHALLOW] && !c && isWrappable(f)) {
+                    // Flip the live gate too: a bare add was inert unless something else
+                    // had already marked a raw somewhere (wrap() checks rawValuesUsed
+                    // first), so the documented set-trap ingest mark silently no-oped in
+                    // apps whose only shallow data arrived through writes.
+                    rawValuesUsed = true;
+                    rawValues.add(f);
+                }
                 // Symbol-keyed writes on arrays are metadata, not index writes — never run
                 // them through the numeric index/length machinery (`parseInt` on a symbol
                 // throws). #2769
-                                const f = typeof t === "string" ? Number(t) : -1;
-                const E = Array.isArray(s) && Number.isInteger(f) && f >= 0 && f < 4294967295 && String(f) === t;
-                const d = E ? f + 1 : 0;
-                const S = E && (getOverlayLayer(e, "length") ?? s).length;
-                const T = E && d > S ? d : undefined;
-                if (l === c && T === undefined) return true;
+                                const E = typeof t === "string" ? Number(t) : -1;
+                const d = Array.isArray(s) && Number.isInteger(E) && E >= 0 && E < 4294967295 && String(E) === t;
+                const S = d ? E + 1 : 0;
+                const T = d && (getOverlayLayer(e, "length") ?? s).length;
+                const O = d && S > T ? S : undefined;
+                if (l === f && O === undefined) return true;
                 armOptimisticStoreWrite(e, r);
-                if (c !== undefined && c === i && T === undefined) {
+                if (f !== undefined && f === i && O === undefined) {
                     delete e[o]?.[t];
                     if (o === STORE_OPTIMISTIC_OVERRIDE) delete e[STORE_OPTIMISTIC_OWNERS]?.[t];
                 } else {
                     const n = e[o] || (e[o] = Object.create(null));
-                    n[t] = c;
+                    n[t] = f;
                     stampOptimisticOwner(e, o, t);
-                    if (T !== undefined) {
-                        n.length = T;
+                    if (O !== undefined) {
+                        n.length = O;
                         stampOptimisticOwner(e, o, "length");
                     }
                 }
-                notifyStoreProperty(e, t, "set", c, l, a);
+                notifyStoreProperty(e, t, "set", f, l, a);
                 // Shrinking an array's length must remove the truncated indices, otherwise
                 // they leak through `has`, `ownKeys`, and (tracked) index reads from the
                 // underlying value. Mark each as deleted and notify so reactive reads update. #2768
-                                if (Array.isArray(s) && t === "length" && typeof c === "number" && typeof l === "number" && c < l) {
+                                if (Array.isArray(s) && t === "length" && typeof f === "number" && typeof l === "number" && f < l) {
                     const t = e[o] || (e[o] = Object.create(null));
-                    for (let n = c; n < l; n++) {
+                    for (let n = f; n < l; n++) {
                         if (t[n] === $DELETED) continue;
                         const r = n in t ? t[n] : s[n];
                         if (!(n in t) && !(n in s)) continue;
@@ -5631,13 +5730,13 @@ const storeTraps = {
                     }
                 }
                 // notify length change
-                                if (Array.isArray(s) && t !== "length" && T !== undefined) {
+                                if (Array.isArray(s) && t !== "length" && O !== undefined) {
                     const t = getNodes(e, STORE_NODE);
                     if (t.length) {
-                        setSignal(t.length, T);
+                        setSignal(t.length, O);
                     } else if (!projectionWriteActive && !e[STORE_OPTIMISTIC]) {
-                        const n = upsertStoreNode(e, t, "length", S, e[STORE_SNAPSHOT_PROPS]);
-                        setSignal(n, T);
+                        const n = upsertStoreNode(e, t, "length", T, e[STORE_SNAPSHOT_PROPS]);
+                        setSignal(n, O);
                     }
                 }
                 if (false) ;