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

package/dist/prod/store/optimistic.js

@@ -2,7 +2,7 @@ import { computed } from "../core/core.js";
 
 import { CONFIG_AUTO_DISPOSE, NOT_PENDING } from "../core/constants.js";
 
-import { GlobalQueue, schedule, setProjectionWriteActive, insertSubs, projectionWriteActive } from "../core/scheduler.js";
+import { GlobalQueue, schedule, currentTransition, insertSubs, setProjectionWriteActive, projectionWriteActive } from "../core/scheduler.js";
 
 import "../core/invariants.js";
 
@@ -14,126 +14,161 @@ import { installOptimisticEngine } from "../core/optimistic.js";
 
 import { runProjectionComputed } from "./projection.js";
 
-import { storeSetter, $TARGET, STORE_OPTIMISTIC_OVERRIDE, STORE_NODE, getOverlayLayer, STORE_VALUE, $DELETED, isWrappable, wrap, visibleNodeValue, $TRACK, notifySelf, STORE_WRAP, createStoreProxy, storeTraps, STORE_LOOKUP, STORE_OPTIMISTIC, STORE_FIREWALL } from "./store.js";
+import { storeSetter, $TARGET, STORE_OPTIMISTIC_OVERRIDE, STORE_NODE, STORE_OPTIMISTIC_OWNERS, getOverlayLayer, STORE_VALUE, $DELETED, isWrappable, wrap, visibleNodeValue, $TRACK, notifySelf, STORE_WRAP, createStoreProxy, storeTraps, STORE_LOOKUP, STORE_OPTIMISTIC, STORE_FIREWALL } from "./store.js";
 
-function createOptimisticStore(t, e, r) {
+function createOptimisticStore(e, t, r) {
     // Register clear function with scheduler; store nodes marked
     // STORE_OPTIMISTIC take the engine's write path, so install it before any
     // node can be created.
     installOptimisticEngine();
-    GlobalQueue.Kt ||= clearOptimisticStores;
-    const i = typeof t === "function";
-    const o = i ? e : t;
-    const c = i ? t : undefined;
+    GlobalQueue.Vt ||= clearOptimisticStores;
+    const i = typeof e === "function";
+    const o = i ? t : e;
+    const n = i ? e : undefined;
     // Create optimistic projection store
-        const {store: n} = createOptimisticProjectionInternal(c, o, r);
-    return [ n, t => storeSetter(n, t) ];
+        const {store: c} = createOptimisticProjectionInternal(n, o, r);
+    return [ c, e => storeSetter(c, e) ];
 }
 
 // Clear the optimistic overrides of a settling batch of stores and notify
 // signals. Owns the whole batch (iterate + clear + reschedule) so the
-// scheduler's flush tail carries only a size-guarded hook call.
-function clearOptimisticStores(t) {
-    for (const e of t) {
-        const t = e[$TARGET];
-        if (t?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(t);
+// scheduler's flush tail carries only a size-guarded hook call. The
+// completing transition scopes each clear to its own layer keys (#2899).
+function clearOptimisticStores(e, t) {
+    for (const r of e) {
+        const e = r[$TARGET];
+        if (e?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(e, t);
     }
-    t.clear();
+    e.clear();
     schedule();
 }
 
-function clearOptimisticOverride(t) {
-    const e = t[STORE_OPTIMISTIC_OVERRIDE];
-    if (!e) return;
-    const r = t[STORE_NODE];
-    delete t[STORE_OPTIMISTIC_OVERRIDE];
-    // Notify signals for all overridden properties
+/**
+ * Consume optimistic layer entries and reset their backing nodes to base.
+ * With `completing` (settle path, #2899) only entries the settling
+ * transaction owns are consumed — the layer is store-wide but concurrent
+ * actions revert independently, so keys stamped by a still-in-flight
+ * transition survive (node-level overrides already have this granularity via
+ * _optimisticNodes; this is the layer's half). `null` consumes ambient
+ * (transaction-less) entries at plain flush end. Omitted (projection landing:
+ * fresh authoritative data) consumes everything — the correction supersedes
+ * every tentative layer.
+ */ function clearOptimisticOverride(e, t) {
+    const r = e[STORE_OPTIMISTIC_OVERRIDE];
+    if (!r) return;
+    const i = e[STORE_NODE];
+    const o = e[STORE_OPTIMISTIC_OWNERS];
+    const n = t !== undefined;
+    let c = false;
+    let s = false;
     // Use projectionWriteActive to bypass optimistic signal behavior (no lane creation)
     // This ensures reversion effects go to regular queues, not lane queues
-        const i = projectionWriteActive;
+        const O = projectionWriteActive;
     setProjectionWriteActive(true);
     try {
-        if (r) {
-            for (const i of Reflect.ownKeys(e)) {
-                if (r[i]) {
-                    const e = r[i];
-                    // Clear lane association so effects go to regular queue
-                                        e.Je = undefined;
-                    // Re-read from base — the optimistic layer was deleted above, so the
-                    // overlay resolves to STORE_OVERRIDE or STORE_VALUE.
-                                        const o = getOverlayLayer(t, i);
-                    const c = o ? o[i] : t[STORE_VALUE][i];
-                    const n = c === $DELETED ? undefined : c;
-                    const s = isWrappable(n) ? wrap(n, t) : n;
-                    const O = visibleNodeValue(e);
-                    e.be = NOT_PENDING;
-                    e.ge = NOT_PENDING;
-                    e.Ue = s;
-                    if (!e.Ge || !e.Ge(O, s)) {
-                        insertSubs(e, true);
-                        schedule();
+        for (const O of Reflect.ownKeys(r)) {
+            if (n) {
+                let e = o?.[O] ?? null;
+                // Resolve merge chains (entangled actions settle as one); path-compress
+                // so later keys skip the walk. A dead owner (`_done === true`) settled
+                // through some other path — never strand its entry. A null owner is an
+                // ambient write: its batch belongs to whichever transaction adopted it
+                // (initTransition mid-batch) or to the plain flush, so it clears on
+                // whichever clear call reaches this store first.
+                                if (e) {
+                    if (typeof e.cn === "object") e = o[O] = currentTransition(e);
+                    if (e !== t && e.cn !== true) {
+                        s = true;
+                        continue;
                     }
                 }
             }
-            // Notify $TRACK
-                        if (r[$TRACK]) {
-                r[$TRACK].Je = undefined;
-                notifySelf(t);
+            delete r[O];
+            if (o) delete o[O];
+            c = true;
+            const T = i?.[O];
+            if (T) {
+                // Clear lane association so effects go to regular queue
+                T.Je = undefined;
+                // Re-read from base — this key left the optimistic layer above, so the
+                // overlay resolves to STORE_OVERRIDE or STORE_VALUE.
+                                const t = getOverlayLayer(e, O);
+                const r = t ? t[O] : e[STORE_VALUE][O];
+                const i = r === $DELETED ? undefined : r;
+                const o = isWrappable(i) ? wrap(i, e) : i;
+                const n = visibleNodeValue(T);
+                T.be = NOT_PENDING;
+                T.fn = null;
+                T.ge = NOT_PENDING;
+                T.Ue = o;
+                if (!T.Ge || !T.Ge(n, o)) {
+                    insertSubs(T, true);
+                    schedule();
+                }
             }
         }
+        if (!s) {
+            delete e[STORE_OPTIMISTIC_OVERRIDE];
+            delete e[STORE_OPTIMISTIC_OWNERS];
+        }
+        // Notify $TRACK
+                if (c && i?.[$TRACK]) {
+            i[$TRACK].Je = undefined;
+            notifySelf(e);
+        }
     } finally {
-        setProjectionWriteActive(i);
+        setProjectionWriteActive(O);
     }
 }
 
-function createOptimisticProjectionInternal(t, e, r) {
+function createOptimisticProjectionInternal(e, t, r) {
     let i;
     const o = new WeakMap;
-    const wrapper = t => {
-        t[STORE_WRAP] = wrapProjection;
-        t[STORE_LOOKUP] = o;
-        t[STORE_OPTIMISTIC] = true;
+    const wrapper = e => {
+        e[STORE_WRAP] = wrapProjection;
+        e[STORE_LOOKUP] = o;
+        e[STORE_OPTIMISTIC] = true;
  // Mark as optimistic store
-                Object.defineProperty(t, STORE_FIREWALL, {
+                Object.defineProperty(e, STORE_FIREWALL, {
             get() {
                 return i;
             },
             configurable: true
         });
     };
-    const wrapProjection = t => {
-        if (o.has(t)) return o.get(t);
-        if (t[$TARGET]?.[STORE_WRAP] === wrapProjection) return t;
-        const e = createStoreProxy(t, storeTraps, wrapper);
-        o.set(t, e);
-        return e;
+    const wrapProjection = e => {
+        if (o.has(e)) return o.get(e);
+        if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
+        const t = createStoreProxy(e, storeTraps, wrapper);
+        o.set(e, t);
+        return t;
     };
-    const c = wrapProjection(e);
+    const n = wrapProjection(t);
     // If there's a projection function, create a computed to drive it
-        if (t) {
+        if (e) {
         // All writes inside firewall recompute must go to STORE_OVERRIDE (base), not
         // STORE_OPTIMISTIC_OVERRIDE. The outer wrap covers the sync body (including
         // `fn(draft)` and the initial commit); `wrapCommit` re-applies the flag for
         // async yields because they fire outside any enclosing try/finally. It also
         // consumes stale optimistic overlays once fresh projected data lands.
         const clearProjectionOverride = () => {
-            const t = c[$TARGET];
-            if (t?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(t);
+            const e = n[$TARGET];
+            if (e?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(e);
         };
-        const wrapCommit = t => {
-            const e = projectionWriteActive;
+        const wrapCommit = e => {
+            const t = projectionWriteActive;
             setProjectionWriteActive(true);
             try {
-                t();
+                e();
                 clearProjectionOverride();
             } finally {
-                setProjectionWriteActive(e);
+                setProjectionWriteActive(t);
             }
         };
         i = computed(() => {
             setProjectionWriteActive(true);
             try {
-                runProjectionComputed(c, t, r?.key || "id", wrapCommit, clearProjectionOverride);
+                runProjectionComputed(n, e, r?.key || "id", wrapCommit, clearProjectionOverride);
             } finally {
                 setProjectionWriteActive(false);
             }
@@ -141,7 +176,7 @@ function createOptimisticProjectionInternal(t, e, r) {
         i.U &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
-        store: c,
+        store: n,
         node: i
     };
 }

package/dist/prod/store/reconcile.js

@@ -8,7 +8,7 @@ import "../core/verdict.js";
 
 import "../core/effect.js";
 
-import { $TARGET, STORE_OVERRIDE, STORE_OPTIMISTIC_OVERRIDE, STORE_VALUE, STORE_NODE, storeLookup, STORE_LOOKUP, $PROXY, isWrappable, wrap, notifySelf, $TRACK, STORE_HAS, getKeys, $DELETED, symbolKeyedRecords } from "./store.js";
+import { $TARGET, STORE_OVERRIDE, STORE_OPTIMISTIC_OVERRIDE, STORE_VALUE, STORE_NODE, storeLookup, STORE_LOOKUP, $PROXY, isWrappable, wrap, notifySelf, $TRACK, STORE_DESC, STORE_HAS, getKeys, $DELETED, symbolKeyedRecords, getStoreSymbols } from "./store.js";
 
 // Enumerate a node record's keys. Keeps the common string-key path on the
 // `Object.keys` fast path; only records currently holding a user symbol node
@@ -45,6 +45,8 @@ function addEnumSymbols(e, t, r) {
 }
 
 function getAllKeys(e, t, r) {
+    // Symbols are merged explicitly below; keep the common string-key path on
+    // Object.keys() and avoid reflecting the base symbols twice.
     const n = getKeys(e, t);
     const a = Object.keys(r);
     // `value` can be a wrapped store (store-in-store) whose ownKeys trap tracks;
@@ -131,6 +133,34 @@ function applyArrayItem(e, t, r, n, a) {
     } else n && setSignal(n, wrapValue(e, r));
 }
 
+/**
+ * The captured-proxy half of the object diff (#2902): descend into keyed-
+ * matching children that have NO node at this level but shelter subscribers
+ * somewhere below (their target's sticky `STORE_DESC` flag, bubbled up by
+ * `getNode`). Without this, a proxy captured through untracked reads — a
+ * `<For>` row handed to a child component — detaches from the diff the
+ * moment no intermediate level happens to be tracked, and its live
+ * subscribers go permanently stale. Never-subscribed branches have no flag
+ * and stay pruned exactly as before; keys the main loop already visited
+ * (node present) are skipped. Callers gate on the parent's own flag and on
+ * `$TRACK` absence (an enumeration-tracked record already diffs every key).
+ */ function applyDescendants(e, t, r, n, a, i, o) {
+    const l = r[STORE_LOOKUP] || storeLookup;
+    const s = (i ? getKeys(e, i) : Object.keys(e)).concat(getStoreSymbols(e, i));
+    for (let p = 0, f = s.length; p < f; p++) {
+        const f = s[p];
+        if (n?.[f]) continue;
+ // main loop already diffed this slot
+                const c = unwrap(i ? getOverrideValue(e, i, f, o) : e[f]);
+        if (!isWrappable(c)) continue;
+        const u = (l.get(c) ?? storeLookup.get(c))?.[$TARGET];
+        if (!u?.[STORE_DESC]) continue;
+        const S = unwrap(t[f]);
+        if (c === S || !isWrappable(S) || Array.isArray(c) !== Array.isArray(S) || a(c) != null && a(c) !== a(S)) continue;
+        applyState(S, wrap(c, r), a);
+    }
+}
+
 // Dispatcher: every applyState call (including recursion) checks for the
 // presence of override / optimistic-override slots once and routes to the
 // appropriate body. The fast body never calls `getOverrideValue` and never
@@ -161,7 +191,7 @@ function applyStateFast(e, t, r) {
         let i = false;
         const o = n.length;
         if (e.length && o && isWrappable(e[0]) && r(e[0]) != null) {
-            let l, s, p, f, c, u, y, S;
+            let l, s, p, f, c, u, S, y;
             for (p = 0, f = Math.min(o, e.length); p < f && keyedMatch(u = n[p], e[p], r); p++) {
                 isWrappable(u) && isWrappable(e[p]) && applyState(e[p], wrap(u, t), r);
             }
@@ -184,22 +214,22 @@ function applyStateFast(e, t, r) {
                 o !== e.length && a?.length && setSignal(a.length, e.length);
                 return;
             }
-            y = new Array(c + 1);
+            S = new Array(c + 1);
             for (s = c; s >= p; s--) {
                 u = e[s];
-                S = itemKey(u, r);
-                l = O.get(S);
-                y[s] = l === undefined ? -1 : l;
-                O.set(S, s);
+                y = itemKey(u, r);
+                l = O.get(y);
+                S[s] = l === undefined ? -1 : l;
+                O.set(y, s);
             }
             for (l = p; l <= f; l++) {
                 u = n[l];
-                S = itemKey(u, r);
-                s = O.get(S);
+                y = itemKey(u, r);
+                s = O.get(y);
                 if (s !== undefined && s !== -1) {
                     E[s] = u;
-                    s = y[s];
-                    O.set(S, s);
+                    s = S[s];
+                    O.set(y, s);
                 }
             }
             for (s = p; s < e.length; s++) {
@@ -227,21 +257,23 @@ function applyStateFast(e, t, r) {
     }
     // values
         let i = t[STORE_NODE];
+    let o;
     if (i) {
-        const a = i[$TRACK];
-        const o = a ? getAllKeys(n, undefined, e) : nodeKeys(i);
-        for (let l = 0, s = o.length; l < s; l++) {
-            const s = o[l];
+        o = i[$TRACK];
+        const a = o ? getAllKeys(n, undefined, e) : nodeKeys(i);
+        for (let l = 0, s = a.length; l < s; l++) {
+            const s = a[l];
             const p = i[s];
             const f = unwrap(n[s]);
             let c = unwrap(e[s]);
             if (f === c) continue;
             if (!f || !isWrappable(f) || !isWrappable(c) || Array.isArray(f) !== Array.isArray(c) || r(f) != null && r(f) !== r(c)) {
-                a && setSignal(a, void 0);
+                o && setSignal(o, void 0);
                 p && setSignal(p, isWrappable(c) ? wrap(c, t) : c);
             } else applyState(c, wrap(f, t), r);
         }
     }
+    if (!o && t[STORE_DESC]) applyDescendants(n, e, t, i, r);
     // has
         if (i = t[STORE_HAS]) {
         const t = nodeKeys(i);
@@ -266,23 +298,23 @@ function applyStateSlow(e, t, r) {
         let l = false;
         const s = getOverrideValue(n, a, "length", i);
         if (e.length && s && isWrappable(e[0]) && r(e[0]) != null) {
-            let p, f, c, u, y, S, E, O;
-            for (c = 0, u = Math.min(s, e.length); c < u && keyedMatch(S = getOverrideValue(n, a, c, i), e[c], r); c++) {
-                isWrappable(S) && isWrappable(e[c]) && applyState(e[c], wrap(S, t), r);
+            let p, f, c, u, S, y, E, O;
+            for (c = 0, u = Math.min(s, e.length); c < u && keyedMatch(y = getOverrideValue(n, a, c, i), e[c], r); c++) {
+                isWrappable(y) && isWrappable(e[c]) && applyState(e[c], wrap(y, t), r);
             }
-            const d = new Array(e.length), R = new Map;
-            for (u = s - 1, y = e.length - 1; u >= c && y >= c && keyedMatch(S = getOverrideValue(n, a, u, i), e[y], r); u--, 
-            y--) {
-                d[y] = S;
+            const R = new Array(e.length), d = new Map;
+            for (u = s - 1, S = e.length - 1; u >= c && S >= c && keyedMatch(y = getOverrideValue(n, a, u, i), e[S], r); u--, 
+            S--) {
+                R[S] = y;
             }
-            if (c > y || c > u) {
-                for (f = c; f <= y; f++) {
+            if (c > S || c > u) {
+                for (f = c; f <= S; f++) {
                     l = true;
                     o?.[f] && setSignal(o[f], wrapValue(e[f], t));
                 }
                 for (;f < e.length; f++) {
                     l = true;
-                    applyArrayItem(e[f], d[f], t, o?.[f], r);
+                    applyArrayItem(e[f], R[f], t, o?.[f], r);
                 }
                 const n = e.length;
                 syncArrayNodeMembership(t, e);
@@ -290,27 +322,27 @@ function applyStateSlow(e, t, r) {
                 s !== n && o?.length && setSignal(o.length, n);
                 return;
             }
-            E = new Array(y + 1);
-            for (f = y; f >= c; f--) {
-                S = e[f];
-                O = itemKey(S, r);
-                p = R.get(O);
+            E = new Array(S + 1);
+            for (f = S; f >= c; f--) {
+                y = e[f];
+                O = itemKey(y, r);
+                p = d.get(O);
                 E[f] = p === undefined ? -1 : p;
-                R.set(O, f);
+                d.set(O, f);
             }
             for (p = c; p <= u; p++) {
-                S = getOverrideValue(n, a, p, i);
-                O = itemKey(S, r);
-                f = R.get(O);
+                y = getOverrideValue(n, a, p, i);
+                O = itemKey(y, r);
+                f = d.get(O);
                 if (f !== undefined && f !== -1) {
-                    d[f] = S;
+                    R[f] = y;
                     f = E[f];
-                    R.set(O, f);
+                    d.set(O, f);
                 }
             }
             for (f = c; f < e.length; f++) {
-                if (f in d) {
-                    applyArrayItem(e[f], d[f], t, o?.[f], r);
+                if (f in R) {
+                    applyArrayItem(e[f], R[f], t, o?.[f], r);
                 } else o?.[f] && setSignal(o[f], wrapValue(e[f], t));
             }
             if (c < e.length) l = true;
@@ -333,21 +365,23 @@ function applyStateSlow(e, t, r) {
         return;
     }
     // values
-        if (o) {
-        const l = o[$TRACK];
+        let l;
+    if (o) {
+        l = o[$TRACK];
         const s = l ? getAllKeys(n, a, e) : nodeKeys(o);
         for (let p = 0, f = s.length; p < f; p++) {
             const f = s[p];
             const c = o[f];
             const u = unwrap(getOverrideValue(n, a, f, i));
-            let y = unwrap(e[f]);
-            if (u === y) continue;
-            if (!u || !isWrappable(u) || !isWrappable(y) || Array.isArray(u) !== Array.isArray(y) || r(u) != null && r(u) !== r(y)) {
+            let S = unwrap(e[f]);
+            if (u === S) continue;
+            if (!u || !isWrappable(u) || !isWrappable(S) || Array.isArray(u) !== Array.isArray(S) || r(u) != null && r(u) !== r(S)) {
                 l && setSignal(l, void 0);
-                c && setSignal(c, isWrappable(y) ? wrap(y, t) : y);
-            } else applyState(y, wrap(u, t), r);
+                c && setSignal(c, isWrappable(S) ? wrap(S, t) : S);
+            } else applyState(S, wrap(u, t), r);
         }
     }
+    if (!l && t[STORE_DESC]) applyDescendants(n, e, t, o, r, a, i);
     // has
         if (o = t[STORE_HAS]) {
         const t = nodeKeys(o);