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

package/dist/prod/store/reconcile.js

@@ -8,7 +8,7 @@ import "../core/verdict.js";
 
 import "../core/effect.js";
 
-import { $TARGET, STORE_SHALLOW, STORE_OVERRIDE, STORE_OPTIMISTIC_OVERRIDE, STORE_VALUE, STORE_LOOKUP, $PROXY, storeLookup, markRawIngest, STORE_NODE, $TRACK, STORE_HAS, notifySelf, isWrappable, wrap, rawValuesUsed, STORE_DESC, symbolKeyedRecords, $DELETED, isRawValue, getKeys, getStoreSymbols, STORE_WRAP, lookupTarget } from "./store.js";
+import { $TARGET, STORE_SHALLOW, STORE_OVERRIDE, STORE_OPTIMISTIC_OVERRIDE, STORE_VALUE, STORE_LOOKUP, $PROXY, storeLookup, markRawIngest, STORE_NODE, $TRACK, STORE_HAS, notifySelf, isWrappable, wrap, rawValuesUsed, isRawValue, STORE_DESC, symbolKeyedRecords, $DELETED, getKeys, getStoreSymbols, STORE_WRAP, lookupTarget } 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
@@ -18,7 +18,7 @@ function nodeKeys(e) {
     const t = Object.keys(e);
     if (symbolKeyedRecords.has(e)) {
         const n = Object.getOwnPropertySymbols(e);
-        for (let e = 0, a = n.length; e < a; e++) {
+        for (let e = 0, r = n.length; e < r; e++) {
             if (n[e] !== $TRACK) t.push(n[e]);
         }
     }
@@ -32,57 +32,57 @@ function unwrap(e) {
     return e[$TARGET]?.[STORE_VALUE] ?? e;
 }
 
-function getOverrideValue(e, t, n, a) {
-    if (a && n in a) return a[n];
+function getOverrideValue(e, t, n, r) {
+    if (r && n in r) return r[n];
     return t && n in t ? t[n] : e[n];
 }
 
 // Append `o`'s *enumerable* own symbol keys from a pre-fetched symbol list.
 function addEnumSymbols(e, t, n) {
-    for (let a = 0, r = t.length; a < r; a++) {
-        if (Object.prototype.propertyIsEnumerable.call(e, t[a])) n.add(t[a]);
+    for (let r = 0, a = t.length; r < a; r++) {
+        if (Object.prototype.propertyIsEnumerable.call(e, t[r])) n.add(t[r]);
     }
 }
 
 function getAllKeys(e, t, n) {
     // Symbols are merged explicitly below; keep the common string-key path on
     // Object.keys() and avoid reflecting the base symbols twice.
-    const a = getKeys(e, t);
-    const r = Object.keys(n);
+    const r = getKeys(e, t);
+    const a = Object.keys(n);
     // `value` can be a wrapped store (store-in-store) whose ownKeys trap tracks;
     // mirror `getKeys` and enumerate its symbols untracked in that case.
         const i = e[$TARGET] ? untrack(() => Object.getOwnPropertySymbols(e)) : Object.getOwnPropertySymbols(e);
-    const s = Object.getOwnPropertySymbols(n);
+    const l = Object.getOwnPropertySymbols(n);
     // Symbol-free diff (the overwhelmingly common case) stays on the exact
     // pre-#2851 path, including the identical-key-sets fast path from #2756.
-        if (i.length === 0 && s.length === 0) {
-        if (a.length === r.length) {
+        if (i.length === 0 && l.length === 0) {
+        if (r.length === a.length) {
             let e = true;
-            for (let t = 0; t < a.length; t++) {
-                if (a[t] !== r[t]) {
+            for (let t = 0; t < r.length; t++) {
+                if (r[t] !== a[t]) {
                     e = false;
                     break;
                 }
             }
-            if (e) return a;
+            if (e) return r;
         }
-        const e = new Set(a);
-        for (let t = 0; t < r.length; t++) e.add(r[t]);
+        const e = new Set(r);
+        for (let t = 0; t < a.length; t++) e.add(a[t]);
         return Array.from(e);
     }
     // Symbol-aware diff (#2851): base symbols join the set, then override
     // adds/deletes are re-applied so a `$DELETED` symbol stays deleted, then
     // `next`'s keys (a key present in next is never deleted by the diff).
-        const l = new Set(a);
-    addEnumSymbols(e, i, l);
+        const s = new Set(r);
+    addEnumSymbols(e, i, s);
     if (t) {
         for (const e of Reflect.ownKeys(t)) {
-            t[e] === $DELETED ? l.delete(e) : l.add(e);
+            t[e] === $DELETED ? s.delete(e) : s.add(e);
         }
     }
-    for (let e = 0; e < r.length; e++) l.add(r[e]);
-    addEnumSymbols(n, s, l);
-    return Array.from(l);
+    for (let e = 0; e < a.length; e++) s.add(a[e]);
+    addEnumSymbols(n, l, s);
+    return Array.from(s);
 }
 
 // Array entries can be `null`/`undefined`/primitives, not just keyed objects.
@@ -100,6 +100,17 @@ function keyedMatch(e, t, n) {
     return e === t || isWrappable(e) && isWrappable(t) && n(e) === n(t);
 }
 
+// A pair of array slots may only be merged into when both sides are real store
+// children of the SAME container kind. An array and an object are different
+// shapes, and merging one into the other leaves the slot's proxy permanently
+// mismatched with its value (an array target holding an object, so
+// `Array.isArray`/spread/`map` lie). The object diff has always applied this
+// rule; the array paths reach the same recursion through `keyedMatch` /
+// positional pairing, where two keyless wrappables "match" regardless of kind.
+function recursablePair(e, t) {
+    return isWrappable(e) && isWrappable(t) && !(rawValuesUsed && (isRawValue(e) || isRawValue(t))) && Array.isArray(e) === Array.isArray(t);
+}
+
 // Array reconciliation updates the slots it visits, then swaps STORE_VALUE.
 // Previously tracked keys that are absent from `next` still need invalidating,
 // and `in` dependencies should follow the new value's membership. Use
@@ -114,8 +125,8 @@ function syncArrayNodeMembership(e, t) {
     if (n) {
         if (symbolKeyedRecords.has(n)) {
             const e = nodeKeys(n);
-            for (let a = 0, r = e.length; a < r; a++) {
-                e[a] in t || setSignal(n[e[a]], undefined);
+            for (let r = 0, a = e.length; r < a; r++) {
+                e[r] in t || setSignal(n[e[r]], undefined);
             }
         } else {
             for (const e in n) {
@@ -126,8 +137,8 @@ function syncArrayNodeMembership(e, t) {
     if (n = e[STORE_HAS]) {
         if (symbolKeyedRecords.has(n)) {
             const e = nodeKeys(n);
-            for (let a = 0, r = e.length; a < r; a++) {
-                setSignal(n[e[a]], e[a] in t);
+            for (let r = 0, a = e.length; r < a; r++) {
+                setSignal(n[e[r]], e[r] in t);
             }
         } else {
             for (const e in n) {
@@ -146,31 +157,31 @@ function syncArrayNodeMembership(e, t) {
 // and drops the wrap()/$PROXY/$TARGET round-trip per visited child.
 // Wrap-family stores (projections/optimistic) own child proxy creation and
 // keep the proxy-based recursion.
-function applyStateChild(e, t, n, a) {
+function applyStateChild(e, t, n, r) {
     if (n[STORE_WRAP] !== undefined) {
-        applyState(e, wrap(t, n), a);
+        applyState(e, wrap(t, n), r);
         return;
     }
-    const r = t[$TARGET] ?? storeLookup.get(t);
-    if (r === undefined) return;
+    const a = t[$TARGET] ?? storeLookup.get(t);
+    if (a === undefined) return;
     e = unwrap(e);
-    if (r[STORE_SHALLOW]) {
-        applyStateShallow(e, r);
-    } else if (r[STORE_OVERRIDE] || r[STORE_OPTIMISTIC_OVERRIDE]) {
-        applyStateSlow(e, r, a);
+    if (a[STORE_SHALLOW]) {
+        applyStateShallow(e, a);
+    } else if (a[STORE_OVERRIDE] || a[STORE_OPTIMISTIC_OVERRIDE]) {
+        applyStateSlow(e, a, r);
     } else {
-        applyStateFast(e, r, a);
+        applyStateFast(e, a, r);
     }
 }
 
 // Reconcile a single array slot: recurse into a wrappable pair, otherwise replace
 // the node's value outright (covers object→primitive and primitive→object).
-function applyArrayItem(e, t, n, a, r) {
-    if (isWrappable(e) && isWrappable(t) && !(rawValuesUsed && (isRawValue(t) || isRawValue(e)))) {
+function applyArrayItem(e, t, n, r, a) {
+    if (recursablePair(t, e)) {
         const i = wrap(t, n);
-        a && setSignal(a, i);
-        applyState(e, i, r);
-    } else a && setSignal(a, wrapValue(e, n));
+        r && setSignal(r, i);
+        applyState(e, i, a);
+    } else r && setSignal(r, wrapValue(e, n));
 }
 
 /**
@@ -184,17 +195,17 @@ function applyArrayItem(e, t, n, a, r) {
  * 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, n, a, r, i, s) {
-    const l = n[STORE_LOOKUP] || storeLookup;
+ */ function applyDescendants(e, t, n, r, a, i, l) {
+    const s = n[STORE_LOOKUP] || storeLookup;
     if (i) {
         const n = getKeys(e, i).concat(getStoreSymbols(e, i));
         for (let o = 0, f = n.length; o < f; o++) {
             const f = n[o];
-            if (a?.[f]) continue;
+            if (r?.[f]) continue;
  // main loop already diffed this slot
-                        const p = unwrap(getOverrideValue(e, i, f, s));
-            if (!isWrappable(p)) continue;
-            descendInto(p, t[f], l, r);
+                        const u = unwrap(getOverrideValue(e, i, f, l));
+            if (!isWrappable(u)) continue;
+            descendInto(u, t[f], s, a);
         }
         return;
     }
@@ -203,34 +214,34 @@ function applyArrayItem(e, t, n, a, r) {
     // bails (noded key, primitive value) stay inline — only genuine descent
     // candidates pay a call.
         for (const n in e) {
-        if (a?.[n]) continue;
+        if (r?.[n]) continue;
  // main loop already diffed this slot
                 const i = unwrap(e[n]);
         if (!isWrappable(i)) continue;
-        descendInto(i, t[n], l, r);
+        descendInto(i, t[n], s, a);
     }
     const o = Object.getOwnPropertySymbols(e);
     for (let n = 0, i = o.length; n < i; n++) {
         if (Object.prototype.propertyIsEnumerable.call(e, o[n])) {
-            if (a?.[o[n]]) continue;
+            if (r?.[o[n]]) continue;
             const i = unwrap(e[o[n]]);
             if (!isWrappable(i)) continue;
-            descendInto(i, t[o[n]], l, r);
+            descendInto(i, t[o[n]], s, a);
         }
     }
 }
 
-function descendInto(e, t, n, a) {
-    const r = lookupTarget(e, n);
-    if (!r?.[STORE_DESC]) return;
+function descendInto(e, t, n, r) {
+    const a = lookupTarget(e, n);
+    if (!a?.[STORE_DESC]) return;
     const i = unwrap(t);
-    if (e === i || !isWrappable(i) || Array.isArray(e) !== Array.isArray(i) || a(e) != null && a(e) !== a(i)) return;
-    if (r[STORE_SHALLOW]) {
-        applyStateShallow(i, r);
-    } else if (r[STORE_OVERRIDE] || r[STORE_OPTIMISTIC_OVERRIDE]) {
-        applyStateSlow(i, r, a);
+    if (e === i || !isWrappable(i) || Array.isArray(e) !== Array.isArray(i) || r(e) != null && r(e) !== r(i)) return;
+    if (a[STORE_SHALLOW]) {
+        applyStateShallow(i, a);
+    } else if (a[STORE_OVERRIDE] || a[STORE_OPTIMISTIC_OVERRIDE]) {
+        applyStateSlow(i, a, r);
     } else {
-        applyStateFast(i, r, a);
+        applyStateFast(i, a, r);
     }
 }
 
@@ -243,14 +254,14 @@ function applyState(e, t, n) {
     // Array items and root calls can pass a store proxy as `next`; normalize to
     // its raw value or the swap would set a store's STORE_VALUE to its own proxy.
     e = unwrap(e);
-    const a = t?.[$TARGET];
-    if (!a) return;
-    if (a[STORE_SHALLOW]) {
-        applyStateShallow(e, a);
-    } else if (a[STORE_OVERRIDE] || a[STORE_OPTIMISTIC_OVERRIDE]) {
-        applyStateSlow(e, a, n);
+    const r = t?.[$TARGET];
+    if (!r) return;
+    if (r[STORE_SHALLOW]) {
+        applyStateShallow(e, r);
+    } else if (r[STORE_OVERRIDE] || r[STORE_OPTIMISTIC_OVERRIDE]) {
+        applyStateSlow(e, r, n);
     } else {
-        applyStateFast(e, a, n);
+        applyStateFast(e, r, n);
     }
 }
 
@@ -262,50 +273,50 @@ function applyState(e, t, n) {
 // One pass over a shallow target's node record: replace changed slots with
 // raw next values, null out slots absent from next. Returns whether anything
 // differed.
-function shallowDiffNodes(e, t, n, a) {
-    let r = false;
+function shallowDiffNodes(e, t, n, r) {
+    let a = false;
     for (const i in e) {
-        if (a && i === "length") continue;
+        if (r && i === "length") continue;
         if (i in t) {
-            const a = t[i];
-            if (a !== n(i)) {
-                r = true;
-                setSignal(e[i], a);
+            const r = t[i];
+            if (r !== n(i)) {
+                a = true;
+                setSignal(e[i], r);
             }
         } else {
-            r = true;
+            a = true;
             setSignal(e[i], undefined);
         }
     }
-    return r;
+    return a;
 }
 
 function applyStateShallow(e, t, n) {
-    const a = t[STORE_VALUE];
-    const r = t[STORE_OVERRIDE];
+    const r = t[STORE_VALUE];
+    const a = t[STORE_OVERRIDE];
     const i = t[STORE_OPTIMISTIC_OVERRIDE];
-    if (e === a && !r && !i) return;
+    if (e === r && !a && !i) return;
     // Setter-staged writes fold into the diff: previous values resolve through
     // the override layers (so a replaced slot compares against what readers
     // saw), and the regular override clears with the swap — reconcile makes
     // `next` the authoritative base, same as the deep slow path.
         const prevAt = e => {
-        const t = getOverrideValue(a, r, e, i);
+        const t = getOverrideValue(r, a, e, i);
         return t === $DELETED ? undefined : t;
     };
     t[STORE_OVERRIDE] = undefined;
-    const s = t[STORE_LOOKUP];
-    s !== undefined ? s.set(e, t[$PROXY]) : storeLookup.set(e, t);
+    const l = t[STORE_LOOKUP];
+    l !== undefined ? l.set(e, t[$PROXY]) : storeLookup.set(e, t);
     t[STORE_VALUE] = e;
     markRawIngest(e);
-    const l = t[STORE_NODE];
-    const o = l && l[$TRACK];
+    const s = t[STORE_NODE];
+    const o = s && s[$TRACK];
     let f = false;
-    if (Array.isArray(a)) {
-        const n = r?.length ?? i?.length ?? a.length;
-        if (l) {
-            f = shallowDiffNodes(l, e, prevAt, true);
-            if (l.length && n !== e.length) setSignal(l.length, e.length);
+    if (Array.isArray(r)) {
+        const n = a?.length ?? i?.length ?? r.length;
+        if (s) {
+            f = shallowDiffNodes(s, e, prevAt, true);
+            if (s.length && n !== e.length) setSignal(s.length, e.length);
         }
         if (!f && (o || t[STORE_HAS])) {
             // Slots without nodes still feed $TRACK enumerators / `in` probes.
@@ -319,24 +330,24 @@ function applyStateShallow(e, t, n) {
             }
         }
     } else {
-        if (l) {
-            f = shallowDiffNodes(l, e, prevAt, false);
+        if (s) {
+            f = shallowDiffNodes(s, e, prevAt, false);
         }
         if (!f && (o || t[STORE_HAS])) f = true;
     }
-    let p = t[STORE_HAS];
-    if (p) {
-        for (const t in p) {
-            setSignal(p[t], t in e);
+    let u = t[STORE_HAS];
+    if (u) {
+        for (const t in u) {
+            setSignal(u[t], t in e);
         }
     }
     f && notifySelf(t);
 }
 
 function applyStateFast(e, t, n) {
-    const a = t[STORE_VALUE];
-    if (e === a) return;
-    const r = t[STORE_NODE];
+    const r = t[STORE_VALUE];
+    if (e === r) return;
+    const a = t[STORE_NODE];
     // swap
         {
         const n = t[STORE_LOOKUP];
@@ -344,20 +355,20 @@ function applyStateFast(e, t, n) {
     }
     t[STORE_VALUE] = e;
     // merge
-        if (Array.isArray(a)) {
+        if (Array.isArray(r)) {
         let i = false;
-        const s = a.length;
-        if (e.length && s && isWrappable(e[0]) && n(e[0]) != null) {
-            let l, o, f, p, u, c, S, R;
-            for (f = 0, p = Math.min(s, e.length); f < p && keyedMatch(c = a[f], e[f], n); f++) {
+        const l = r.length;
+        if (e.length && l && isWrappable(e[0]) && n(e[0]) != null) {
+            let s, o, f, u, p, c, S, E;
+            for (f = 0, u = Math.min(l, e.length); f < u && keyedMatch(c = r[f], e[f], n); f++) {
                 // keyedMatch established both sides wrappable unless they're the
                 // SAME reference — and an identical slot is a guaranteed no-op
                 // (the child's STORE_VALUE tracks the previous graph), so skip
                 // the recursion dispatch entirely. Raw-marked values are leaves:
                 // replace the slot node instead of recursing.
                 if (c !== e[f]) {
-                    if (rawValuesUsed && (isRawValue(c) || isRawValue(e[f]))) {
-                        r?.[f] && setSignal(r[f], wrapValue(e[f], t));
+                    if (!recursablePair(c, e[f])) {
+                        a?.[f] && setSignal(a[f], wrapValue(e[f], t));
                     } else applyStateChild(e[f], c, t, n);
                 }
             }
@@ -365,129 +376,129 @@ function applyStateFast(e, t, n) {
             // of a polling tick): membership, length, and order are unchanged —
             // nothing below could do observable work, so skip the staging
             // allocations and membership sync outright.
-                        if (f === e.length && f === s) return;
-            const E = new Array(e.length), O = new Map;
-            for (p = s - 1, u = e.length - 1; p >= f && u >= f && keyedMatch(c = a[p], e[u], n); p--, 
-            u--) {
-                E[u] = c;
+                        if (f === e.length && f === l) return;
+            const O = new Array(e.length), R = new Map;
+            for (u = l - 1, p = e.length - 1; u >= f && p >= f && keyedMatch(c = r[u], e[p], n); u--, 
+            p--) {
+                O[p] = c;
             }
-            if (f > u || f > p) {
-                for (o = f; o <= u; o++) {
+            if (f > p || f > u) {
+                for (o = f; o <= p; o++) {
                     i = true;
-                    r?.[o] && setSignal(r[o], wrapValue(e[o], t));
+                    a?.[o] && setSignal(a[o], wrapValue(e[o], t));
                 }
                 for (;o < e.length; o++) {
                     i = true;
-                    applyArrayItem(e[o], E[o], t, r?.[o], n);
+                    applyArrayItem(e[o], O[o], t, a?.[o], n);
                 }
                 syncArrayNodeMembership(t, e);
-                (i || s !== e.length) && notifySelf(t);
-                s !== e.length && r?.length && setSignal(r.length, e.length);
+                (i || l !== e.length) && notifySelf(t);
+                l !== e.length && a?.length && setSignal(a.length, e.length);
                 return;
             }
-            S = new Array(u + 1);
-            for (o = u; o >= f; o--) {
+            S = new Array(p + 1);
+            for (o = p; o >= f; o--) {
                 c = e[o];
-                R = itemKey(c, n);
-                l = O.get(R);
-                S[o] = l === undefined ? -1 : l;
-                O.set(R, o);
+                E = itemKey(c, n);
+                s = R.get(E);
+                S[o] = s === undefined ? -1 : s;
+                R.set(E, o);
             }
-            for (l = f; l <= p; l++) {
-                c = a[l];
-                R = itemKey(c, n);
-                o = O.get(R);
+            for (s = f; s <= u; s++) {
+                c = r[s];
+                E = itemKey(c, n);
+                o = R.get(E);
                 if (o !== undefined && o !== -1) {
-                    E[o] = c;
+                    O[o] = c;
                     o = S[o];
-                    O.set(R, o);
+                    R.set(E, o);
                 }
             }
             for (o = f; o < e.length; o++) {
-                if (o in E) {
-                    applyArrayItem(e[o], E[o], t, r?.[o], n);
-                } else r?.[o] && setSignal(r[o], wrapValue(e[o], t));
+                if (o in O) {
+                    applyArrayItem(e[o], O[o], t, a?.[o], n);
+                } else a?.[o] && setSignal(a[o], wrapValue(e[o], t));
             }
             if (f < e.length) i = true;
         } else if (e.length) {
-            for (let s = 0, l = e.length; s < l; s++) {
-                const l = a[s];
-                if (isWrappable(l) && isWrappable(e[s]) && !(rawValuesUsed && (isRawValue(l) || isRawValue(e[s])))) {
-                    if (l !== e[s]) applyStateChild(e[s], l, t, n);
+            for (let l = 0, s = e.length; l < s; l++) {
+                const s = r[l];
+                if (recursablePair(s, e[l])) {
+                    if (s !== e[l]) applyStateChild(e[l], s, t, n);
                 } else {
-                    if (l !== e[s]) i = true;
-                    r?.[s] && setSignal(r[s], wrapValue(e[s], t));
+                    if (s !== e[l]) i = true;
+                    a?.[l] && setSignal(a[l], wrapValue(e[l], t));
                 }
             }
         }
         syncArrayNodeMembership(t, e);
-        if (s !== e.length) {
+        if (l !== e.length) {
             i = true;
-            r?.length && setSignal(r.length, e.length);
+            a?.length && setSignal(a.length, e.length);
         }
         i && notifySelf(t);
         return;
     }
     // values
         let i = t[STORE_NODE];
-    let s;
+    let l;
     if (i) {
-        s = i[$TRACK];
+        l = i[$TRACK];
         // The per-key body is duplicated across both loops on purpose: this is
         // the hottest object-diff site and a shared helper costs a per-key call
         // in instruction counts (CodSpeed regressed ~7% on deep-tree reconciles
         // with the extracted form).
-                if (s || symbolKeyedRecords.has(i)) {
-            const r = s ? getAllKeys(a, undefined, e) : nodeKeys(i);
-            for (let l = 0, o = r.length; l < o; l++) {
-                const o = r[l];
+                if (l || symbolKeyedRecords.has(i)) {
+            const a = l ? getAllKeys(r, undefined, e) : nodeKeys(i);
+            for (let s = 0, o = a.length; s < o; s++) {
+                const o = a[s];
                 const f = i[o];
-                const p = unwrap(a[o]);
-                const u = unwrap(e[o]);
-                if (p === u) continue;
-                if (!p || !isWrappable(p) || !isWrappable(u) || 
+                const u = unwrap(r[o]);
+                const p = unwrap(e[o]);
+                if (u === p) continue;
+                if (!u || !isWrappable(u) || !isWrappable(p) || 
                 // Raw-marked values are leaves replaced by reference — a "wrappable
                 // pair" is only recursable when both sides are actual store children.
-                rawValuesUsed && (isRawValue(p) || isRawValue(u)) || Array.isArray(p) !== Array.isArray(u) || n(p) != null && n(p) !== n(u)) {
-                    s && setSignal(s, void 0);
-                    f && setSignal(f, isWrappable(u) ? wrap(u, t) : u);
-                } else applyStateChild(u, p, t, n);
+                rawValuesUsed && (isRawValue(u) || isRawValue(p)) || Array.isArray(u) !== Array.isArray(p) || n(u) != null && n(u) !== n(p)) {
+                    l && setSignal(l, void 0);
+                    f && setSignal(f, isWrappable(p) ? wrap(p, t) : p);
+                } else applyStateChild(p, u, t, n);
             }
         } else {
             // Untracked, string-only node records (the overwhelmingly common case)
             // iterate in place — nodeKeys() allocated a fresh key array per object
             // per pass, which dominates allocation on large-graph reconciles.
-            for (const r in i) {
-                const l = i[r];
-                const o = unwrap(a[r]);
-                const f = unwrap(e[r]);
+            for (const a in i) {
+                const s = i[a];
+                const o = unwrap(r[a]);
+                const f = unwrap(e[a]);
                 if (o === f) continue;
                 if (!o || !isWrappable(o) || !isWrappable(f) || 
                 // Raw-marked values are leaves replaced by reference — a "wrappable
                 // pair" is only recursable when both sides are actual store children.
                 rawValuesUsed && (isRawValue(o) || isRawValue(f)) || Array.isArray(o) !== Array.isArray(f) || n(o) != null && n(o) !== n(f)) {
-                    s && setSignal(s, void 0);
-                    l && setSignal(l, isWrappable(f) ? wrap(f, t) : f);
+                    l && setSignal(l, void 0);
+                    s && setSignal(s, isWrappable(f) ? wrap(f, t) : f);
                 } else applyStateChild(f, o, t, n);
             }
         }
     }
-    if (!s && t[STORE_DESC]) applyDescendants(a, e, t, i, n);
+    if (!l && t[STORE_DESC]) applyDescendants(r, e, t, i, n);
     // has
         if (i = t[STORE_HAS]) {
         const t = nodeKeys(i);
-        for (let n = 0, a = t.length; n < a; n++) {
-            const a = t[n];
-            setSignal(i[a], a in e);
+        for (let n = 0, r = t.length; n < r; n++) {
+            const r = t[n];
+            setSignal(i[r], r in e);
         }
     }
 }
 
 function applyStateSlow(e, t, n) {
-    const a = t[STORE_VALUE];
-    const r = t[STORE_OVERRIDE];
+    const r = t[STORE_VALUE];
+    const a = t[STORE_OVERRIDE];
     const i = t[STORE_OPTIMISTIC_OVERRIDE];
-    let s = t[STORE_NODE];
+    let l = t[STORE_NODE];
     // swap
         {
         const n = t[STORE_LOOKUP];
@@ -496,106 +507,106 @@ function applyStateSlow(e, t, n) {
     t[STORE_VALUE] = e;
     t[STORE_OVERRIDE] = undefined;
     // merge
-        if (Array.isArray(a)) {
-        let l = false;
-        const o = getOverrideValue(a, r, "length", i);
+        if (Array.isArray(r)) {
+        let s = false;
+        const o = getOverrideValue(r, a, "length", i);
         if (e.length && o && isWrappable(e[0]) && n(e[0]) != null) {
-            let f, p, u, c, S, R, E, O;
-            for (u = 0, c = Math.min(o, e.length); u < c && keyedMatch(R = getOverrideValue(a, r, u, i), e[u], n); u++) {
-                if (isWrappable(R) && isWrappable(e[u]) && R !== e[u]) {
-                    if (rawValuesUsed && (isRawValue(R) || isRawValue(e[u]))) {
-                        s?.[u] && setSignal(s[u], wrapValue(e[u], t));
-                    } else applyState(e[u], wrap(R, t), n);
+            let f, u, p, c, S, E, O, R;
+            for (p = 0, c = Math.min(o, e.length); p < c && keyedMatch(E = getOverrideValue(r, a, p, i), e[p], n); p++) {
+                if (E !== e[p] && isWrappable(E) && isWrappable(e[p])) {
+                    if (!recursablePair(E, e[p])) {
+                        l?.[p] && setSignal(l[p], wrapValue(e[p], t));
+                    } else applyState(e[p], wrap(E, t), n);
                 }
             }
-            const y = new Array(e.length), d = new Map;
-            for (c = o - 1, S = e.length - 1; c >= u && S >= u && keyedMatch(R = getOverrideValue(a, r, c, i), e[S], n); c--, 
+            const d = new Array(e.length), y = new Map;
+            for (c = o - 1, S = e.length - 1; c >= p && S >= p && keyedMatch(E = getOverrideValue(r, a, c, i), e[S], n); c--, 
             S--) {
-                y[S] = R;
+                d[S] = E;
             }
-            if (u > S || u > c) {
-                for (p = u; p <= S; p++) {
-                    l = true;
-                    s?.[p] && setSignal(s[p], wrapValue(e[p], t));
+            if (p > S || p > c) {
+                for (u = p; u <= S; u++) {
+                    s = true;
+                    l?.[u] && setSignal(l[u], wrapValue(e[u], t));
                 }
-                for (;p < e.length; p++) {
-                    l = true;
-                    applyArrayItem(e[p], y[p], t, s?.[p], n);
+                for (;u < e.length; u++) {
+                    s = true;
+                    applyArrayItem(e[u], d[u], t, l?.[u], n);
                 }
-                const a = e.length;
+                const r = e.length;
                 syncArrayNodeMembership(t, e);
-                (l || o !== a) && notifySelf(t);
-                o !== a && s?.length && setSignal(s.length, a);
+                (s || o !== r) && notifySelf(t);
+                o !== r && l?.length && setSignal(l.length, r);
                 return;
             }
-            E = new Array(S + 1);
-            for (p = S; p >= u; p--) {
-                R = e[p];
-                O = itemKey(R, n);
-                f = d.get(O);
-                E[p] = f === undefined ? -1 : f;
-                d.set(O, p);
+            O = new Array(S + 1);
+            for (u = S; u >= p; u--) {
+                E = e[u];
+                R = itemKey(E, n);
+                f = y.get(R);
+                O[u] = f === undefined ? -1 : f;
+                y.set(R, u);
             }
-            for (f = u; f <= c; f++) {
-                R = getOverrideValue(a, r, f, i);
-                O = itemKey(R, n);
-                p = d.get(O);
-                if (p !== undefined && p !== -1) {
-                    y[p] = R;
-                    p = E[p];
-                    d.set(O, p);
+            for (f = p; f <= c; f++) {
+                E = getOverrideValue(r, a, f, i);
+                R = itemKey(E, n);
+                u = y.get(R);
+                if (u !== undefined && u !== -1) {
+                    d[u] = E;
+                    u = O[u];
+                    y.set(R, u);
                 }
             }
-            for (p = u; p < e.length; p++) {
-                if (p in y) {
-                    applyArrayItem(e[p], y[p], t, s?.[p], n);
-                } else s?.[p] && setSignal(s[p], wrapValue(e[p], t));
+            for (u = p; u < e.length; u++) {
+                if (u in d) {
+                    applyArrayItem(e[u], d[u], t, l?.[u], n);
+                } else l?.[u] && setSignal(l[u], wrapValue(e[u], t));
             }
-            if (u < e.length) l = true;
+            if (p < e.length) s = true;
         } else if (e.length) {
             for (let o = 0, f = e.length; o < f; o++) {
-                const f = getOverrideValue(a, r, o, i);
-                if (isWrappable(f) && isWrappable(e[o]) && !(rawValuesUsed && (isRawValue(f) || isRawValue(e[o])))) {
+                const f = getOverrideValue(r, a, o, i);
+                if (recursablePair(f, e[o])) {
                     if (f !== e[o]) applyState(e[o], wrap(f, t), n);
                 } else {
-                    if (f !== e[o]) l = true;
-                    s?.[o] && setSignal(s[o], wrapValue(e[o], t));
+                    if (f !== e[o]) s = true;
+                    l?.[o] && setSignal(l[o], wrapValue(e[o], t));
                 }
             }
         }
         const f = e.length;
         syncArrayNodeMembership(t, e);
         if (o !== f) {
-            l = true;
-            s?.length && setSignal(s.length, f);
+            s = true;
+            l?.length && setSignal(l.length, f);
         }
-        l && notifySelf(t);
+        s && notifySelf(t);
         return;
     }
     // values
-        let l;
-    if (s) {
-        l = s[$TRACK];
-        const o = l ? getAllKeys(a, r, e) : nodeKeys(s);
-        for (let f = 0, p = o.length; f < p; f++) {
-            const p = o[f];
-            const u = s[p];
-            const c = unwrap(getOverrideValue(a, r, p, i));
-            let S = unwrap(e[p]);
+        let s;
+    if (l) {
+        s = l[$TRACK];
+        const o = s ? getAllKeys(r, a, e) : nodeKeys(l);
+        for (let f = 0, u = o.length; f < u; f++) {
+            const u = o[f];
+            const p = l[u];
+            const c = unwrap(getOverrideValue(r, a, u, i));
+            let S = unwrap(e[u]);
             if (c === S) continue;
             if (!c || !isWrappable(c) || !isWrappable(S) || rawValuesUsed && (isRawValue(c) || isRawValue(S)) || Array.isArray(c) !== Array.isArray(S) || n(c) != null && n(c) !== n(S)) {
-                l && setSignal(l, void 0);
-                u && setSignal(u, isWrappable(S) ? wrap(S, t) : S);
+                s && setSignal(s, void 0);
+                p && setSignal(p, isWrappable(S) ? wrap(S, t) : S);
             } else applyState(S, wrap(c, t), n);
         }
     }
-    if (!l && t[STORE_DESC]) applyDescendants(a, e, t, s, n, r, i);
+    if (!s && t[STORE_DESC]) applyDescendants(r, e, t, l, n, a, i);
     // has
-        if (s = t[STORE_HAS]) {
-        const t = nodeKeys(s);
-        for (let n = 0, a = t.length; n < a; n++) {
-            const a = t[n];
-            setSignal(s[a], a in e);
+        if (l = t[STORE_HAS]) {
+        const t = nodeKeys(l);
+        for (let n = 0, r = t.length; n < r; n++) {
+            const r = t[n];
+            setSignal(l[r], r in e);
         }
     }
 }
@@ -604,6 +615,58 @@ function applyStateSlow(e, t, n) {
 // the positional branch and object descent to plain per-property merging.
 const NOKEY = () => null;
 
+// Identity-as-key: distinct objects never match, so every slot takes the diff's
+// "not the same entity" branch and is replaced by reference rather than merged
+// into. Slots holding the same raw on both sides still keep their proxy.
+const IDENTITY = e => e;
+
+/**
+ * Shared body of `reconcile()` and the projection commit. `replace` is the
+ * only difference: a projection commit is a value swap, not a merge — its root
+ * proxy is a cell handed out by `createProjection` that can never change
+ * reference, so a derive returning a different entity is not the slot mistake
+ * `reconcile()` throws on. Nothing below the root survives that swap, which is
+ * the rule the keyed diff already applies at a nested slot on a key mismatch.
+ *
+ * @internal
+ */ function reconcileState(e, t, n, r) {
+    if (t == null) throw new Error("");
+    // A projection commit whose derive returns a foreign store adopts it as the
+    // live backing (store-in-store chain — the same shape as a store-proxy
+    // seed): reads route through the inner store's own graph, so its updates
+    // flow with no re-derive, and a derive with no dependencies never recomputes
+    // (#2941). The diff below still runs against raw values so THIS store's
+    // existing subscribers see the swap; the live proxy is installed after.
+    // Shallow projections keep their raw-ingest contract and never chain.
+        let a;
+    const i = r ? t[$TARGET] : undefined;
+    if (i !== undefined) {
+        if (e?.[$TARGET] !== undefined && e[$TARGET] !== i && !i[STORE_SHALLOW]) {
+            if (i[STORE_VALUE] === e) return;
+ // already chained to this store
+                        a = e;
+        }
+        // Re-diffing a previously chained backing goes through its raw — reads
+        // off the outgoing proxy would subscribe this computed to a store it is
+        // about to drop.
+                while (i[STORE_VALUE]?.[$TARGET] !== undefined) i[STORE_VALUE] = unwrap(i[STORE_VALUE]);
+    }
+    if (n === null) applyState(e, t, NOKEY); else {
+        let a = typeof n === "string" ? e => e[n] : n;
+        const i = a(t);
+        if (i !== undefined && a(e) !== i) {
+            if (!r) throw new Error("");
+            // Or the outgoing raw keeps resolving to this proxy and surfaces the
+            // incoming entity wherever it reappears in this family.
+                        const n = t[$TARGET];
+            if (n && n[STORE_VALUE] !== unwrap(e)) n[STORE_LOOKUP]?.delete(n[STORE_VALUE]);
+            a = IDENTITY;
+        }
+        applyState(e, t, a);
+    }
+    if (a !== undefined) i[STORE_VALUE] = a;
+}
+
 /**
  * Returns a draft-mutating function that smart-merges `value` into a store,
  * preserving fine-grained reactivity: only changed leaves trigger updates.
@@ -618,6 +681,9 @@ const NOKEY = () => null;
  * the classic pattern for fixed-shape data that churns in place (dashboards,
  * monitors), where no keyed diff pass is needed or wanted.
  *
+ * Merging into a slot that holds a *different* entity throws — the caller
+ * picked the slot, so a key mismatch there is a bug.
+ *
  * @param value the next state to merge in
  * @param key property name (string) or extractor function for stable
  * identity (default `"id"`); pass `null` for positional merging
@@ -635,17 +701,7 @@ const NOKEY = () => null;
  * setStats(reconcile(nextStats, null));
  * ```
  */ function reconcile(e, t = "id") {
-    return n => {
-        if (n == null) throw new Error("");
-        if (t === null) {
-            applyState(e, n, NOKEY);
-            return;
-        }
-        const a = typeof t === "string" ? e => e[t] : t;
-        const r = a(n);
-        if (r !== undefined && a(e) !== r) throw new Error("");
-        applyState(e, n, a);
-    };
+    return n => reconcileState(e, n, t, false);
 }
 
-export { reconcile };
+export { reconcile, reconcileState };