@solidjs/signals 2.0.0-beta.8 → 2.0.0-rc.0

package/dist/prod/store/reconcile.js

@@ -0,0 +1,707 @@
+import { setSignal, untrack } from "../core/core.js";
+
+import "../core/scheduler.js";
+
+import "../core/invariants.js";
+
+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, 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
+// (marked by `getNode`) pay for symbol enumeration. `$TRACK` is the only
+// internal symbol a node record can hold and callers handle it separately.
+function nodeKeys(e) {
+    const t = Object.keys(e);
+    if (symbolKeyedRecords.has(e)) {
+        const n = Object.getOwnPropertySymbols(e);
+        for (let e = 0, r = n.length; e < r; e++) {
+            if (n[e] !== $TRACK) t.push(n[e]);
+        }
+    }
+    return t;
+}
+
+function unwrap(e) {
+    // Primitives can't be store proxies; skip the symbol lookups (which box the
+    // primitive) for the common leaf case.
+    if (e === null || typeof e !== "object") return e;
+    return e[$TARGET]?.[STORE_VALUE] ?? e;
+}
+
+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 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 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 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 && l.length === 0) {
+        if (r.length === a.length) {
+            let e = true;
+            for (let t = 0; t < r.length; t++) {
+                if (r[t] !== a[t]) {
+                    e = false;
+                    break;
+                }
+            }
+            if (e) return r;
+        }
+        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 s = new Set(r);
+    addEnumSymbols(e, i, s);
+    if (t) {
+        for (const e of Reflect.ownKeys(t)) {
+            t[e] === $DELETED ? s.delete(e) : s.add(e);
+        }
+    }
+    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.
+// These helpers keep the keyed paths from passing a non-object to `keyFn` (which
+// assumes an object) or to `wrap()` (which assumes a wrappable value).
+function wrapValue(e, t) {
+    return isWrappable(e) ? wrap(e, t) : e;
+}
+
+function itemKey(e, t) {
+    return isWrappable(e) ? t(e) : e;
+}
+
+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
+// membership rather than length arithmetic so sparse arrays and named array
+// props behave like normal property reads.
+// Inline key iteration on purpose: these loops run per array target per
+// reconcile pass, and a shared helper means a closure + per-key call in
+// instruction counts. String-only records (the common case) iterate in
+// place; symbol-bearing records take the nodeKeys array path.
+function syncArrayNodeMembership(e, t) {
+    let n = e[STORE_NODE];
+    if (n) {
+        if (symbolKeyedRecords.has(n)) {
+            const e = nodeKeys(n);
+            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) {
+                e in t || setSignal(n[e], undefined);
+            }
+        }
+    }
+    if (n = e[STORE_HAS]) {
+        if (symbolKeyedRecords.has(n)) {
+            const e = nodeKeys(n);
+            for (let r = 0, a = e.length; r < a; r++) {
+                setSignal(n[e[r]], e[r] in t);
+            }
+        } else {
+            for (const e in n) {
+                setSignal(n[e], e in t);
+            }
+        }
+    }
+}
+
+// Recurse into a matched wrappable child pair without manufacturing a proxy:
+// resolve the child's target through the lookup and dispatch directly. A
+// lookup miss means the child was never observed — no proxy, no nodes, no
+// subscribers anywhere below — so the parent's swap making `next`
+// authoritative IS the whole update; a later read wraps next's child on
+// demand. This turns the diff from O(previous graph) into O(observed graph)
+// 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, r) {
+    if (n[STORE_WRAP] !== undefined) {
+        applyState(e, wrap(t, n), r);
+        return;
+    }
+    const a = t[$TARGET] ?? storeLookup.get(t);
+    if (a === undefined) return;
+    e = unwrap(e);
+    if (a[STORE_SHALLOW]) {
+        applyStateShallow(e, a);
+    } else if (a[STORE_OVERRIDE] || a[STORE_OPTIMISTIC_OVERRIDE]) {
+        applyStateSlow(e, a, r);
+    } else {
+        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, r, a) {
+    if (recursablePair(t, e)) {
+        const i = wrap(t, n);
+        r && setSignal(r, i);
+        applyState(e, i, a);
+    } else r && setSignal(r, wrapValue(e, n));
+}
+
+/**
+ * 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, 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 (r?.[f]) continue;
+ // main loop already diffed this slot
+                        const u = unwrap(getOverrideValue(e, i, f, l));
+            if (!isWrappable(u)) continue;
+            descendInto(u, t[f], s, a);
+        }
+        return;
+    }
+    // No-override path (every applyStateFast call): iterate in place instead of
+    // building keys + symbols + concat arrays per object per pass. The cheap
+    // bails (noded key, primitive value) stay inline — only genuine descent
+    // candidates pay a call.
+        for (const n in e) {
+        if (r?.[n]) continue;
+ // main loop already diffed this slot
+                const i = unwrap(e[n]);
+        if (!isWrappable(i)) continue;
+        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 (r?.[o[n]]) continue;
+            const i = unwrap(e[o[n]]);
+            if (!isWrappable(i)) continue;
+            descendInto(i, t[o[n]], s, a);
+        }
+    }
+}
+
+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) || 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, a, r);
+    }
+}
+
+// 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
+// branches on a `fastPath` boolean, so V8 sees a tighter, more inlinable
+// shape for the overwhelmingly common case of plain stores.
+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 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, r, n);
+    }
+}
+
+// Shallow boundary diff: the target's own keys are reactive, its values are
+// raw records replaced by reference — no recursion, no wrapping. Arrays merge
+// positionally (below a shallow boundary the VALUE is the identity; keyed
+// row identity belongs to the consumer, e.g. <For keyed>). Incoming
+// wrappables are sticky-marked raw so they present raw through every store.
+// 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, r) {
+    let a = false;
+    for (const i in e) {
+        if (r && i === "length") continue;
+        if (i in t) {
+            const r = t[i];
+            if (r !== n(i)) {
+                a = true;
+                setSignal(e[i], r);
+            }
+        } else {
+            a = true;
+            setSignal(e[i], undefined);
+        }
+    }
+    return a;
+}
+
+function applyStateShallow(e, t, n) {
+    const r = t[STORE_VALUE];
+    const a = t[STORE_OVERRIDE];
+    const i = t[STORE_OPTIMISTIC_OVERRIDE];
+    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(r, a, e, i);
+        return t === $DELETED ? undefined : t;
+    };
+    t[STORE_OVERRIDE] = undefined;
+    const l = t[STORE_LOOKUP];
+    l !== undefined ? l.set(e, t[$PROXY]) : storeLookup.set(e, t);
+    t[STORE_VALUE] = e;
+    markRawIngest(e);
+    const s = t[STORE_NODE];
+    const o = s && s[$TRACK];
+    let f = false;
+    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.
+            if (n !== e.length) f = true; else {
+                for (let t = 0, n = e.length; t < n; t++) {
+                    if (prevAt(t) !== e[t]) {
+                        f = true;
+                        break;
+                    }
+                }
+            }
+        }
+    } else {
+        if (s) {
+            f = shallowDiffNodes(s, e, prevAt, false);
+        }
+        if (!f && (o || t[STORE_HAS])) f = true;
+    }
+    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 r = t[STORE_VALUE];
+    if (e === r) return;
+    const a = t[STORE_NODE];
+    // swap
+        {
+        const n = t[STORE_LOOKUP];
+        n !== undefined ? n.set(e, t[$PROXY]) : storeLookup.set(e, t);
+    }
+    t[STORE_VALUE] = e;
+    // merge
+        if (Array.isArray(r)) {
+        let i = false;
+        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 (!recursablePair(c, e[f])) {
+                        a?.[f] && setSignal(a[f], wrapValue(e[f], t));
+                    } else applyStateChild(e[f], c, t, n);
+                }
+            }
+            // Every position key-matched at equal length (the steady-state shape
+            // 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 === 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 > p || f > u) {
+                for (o = f; o <= p; o++) {
+                    i = true;
+                    a?.[o] && setSignal(a[o], wrapValue(e[o], t));
+                }
+                for (;o < e.length; o++) {
+                    i = true;
+                    applyArrayItem(e[o], O[o], t, a?.[o], n);
+                }
+                syncArrayNodeMembership(t, e);
+                (i || l !== e.length) && notifySelf(t);
+                l !== e.length && a?.length && setSignal(a.length, e.length);
+                return;
+            }
+            S = new Array(p + 1);
+            for (o = p; o >= f; o--) {
+                c = e[o];
+                E = itemKey(c, n);
+                s = R.get(E);
+                S[o] = s === undefined ? -1 : s;
+                R.set(E, o);
+            }
+            for (s = f; s <= u; s++) {
+                c = r[s];
+                E = itemKey(c, n);
+                o = R.get(E);
+                if (o !== undefined && o !== -1) {
+                    O[o] = c;
+                    o = S[o];
+                    R.set(E, o);
+                }
+            }
+            for (o = f; o < e.length; o++) {
+                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 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 (s !== e[l]) i = true;
+                    a?.[l] && setSignal(a[l], wrapValue(e[l], t));
+                }
+            }
+        }
+        syncArrayNodeMembership(t, e);
+        if (l !== e.length) {
+            i = true;
+            a?.length && setSignal(a.length, e.length);
+        }
+        i && notifySelf(t);
+        return;
+    }
+    // values
+        let i = t[STORE_NODE];
+    let l;
+    if (i) {
+        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 (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 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(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 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)) {
+                    l && setSignal(l, void 0);
+                    s && setSignal(s, isWrappable(f) ? wrap(f, t) : f);
+                } else applyStateChild(f, o, t, 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, r = t.length; n < r; n++) {
+            const r = t[n];
+            setSignal(i[r], r in e);
+        }
+    }
+}
+
+function applyStateSlow(e, t, n) {
+    const r = t[STORE_VALUE];
+    const a = t[STORE_OVERRIDE];
+    const i = t[STORE_OPTIMISTIC_OVERRIDE];
+    let l = t[STORE_NODE];
+    // swap
+        {
+        const n = t[STORE_LOOKUP];
+        n !== undefined ? n.set(e, t[$PROXY]) : storeLookup.set(e, t);
+    }
+    t[STORE_VALUE] = e;
+    t[STORE_OVERRIDE] = undefined;
+    // merge
+        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, 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 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--) {
+                d[S] = E;
+            }
+            if (p > S || p > c) {
+                for (u = p; u <= S; u++) {
+                    s = true;
+                    l?.[u] && setSignal(l[u], wrapValue(e[u], t));
+                }
+                for (;u < e.length; u++) {
+                    s = true;
+                    applyArrayItem(e[u], d[u], t, l?.[u], n);
+                }
+                const r = e.length;
+                syncArrayNodeMembership(t, e);
+                (s || o !== r) && notifySelf(t);
+                o !== r && l?.length && setSignal(l.length, r);
+                return;
+            }
+            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 = 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 (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 (p < e.length) s = true;
+        } else if (e.length) {
+            for (let o = 0, f = e.length; o < f; 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]) s = true;
+                    l?.[o] && setSignal(l[o], wrapValue(e[o], t));
+                }
+            }
+        }
+        const f = e.length;
+        syncArrayNodeMembership(t, e);
+        if (o !== f) {
+            s = true;
+            l?.length && setSignal(l.length, f);
+        }
+        s && notifySelf(t);
+        return;
+    }
+    // values
+        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)) {
+                s && setSignal(s, void 0);
+                p && setSignal(p, isWrappable(S) ? wrap(S, t) : S);
+            } else applyState(S, wrap(c, t), n);
+        }
+    }
+    if (!s && t[STORE_DESC]) applyDescendants(r, e, t, l, n, a, i);
+    // has
+        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);
+        }
+    }
+}
+
+// No-key reconcile: every item reports "no key", which routes array diffs to
+// 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.
+ *
+ * With a `key` (default `"id"`), array items whose key matches between old
+ * and new states keep their identity (updated in place, moves and removals
+ * update the corresponding signals) — the shape for keyed server payloads.
+ * Items without the key field fall back to positional matching.
+ *
+ * With `key: null`, matching is purely positional: index N of the new array
+ * merges into index N of the old, and object properties merge recursively —
+ * 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
+ *
+ * @example
+ * ```ts
+ * const [todos, setTodos] = createStore<Todo[]>([]);
+ *
+ * async function refresh() {
+ *   const fresh = await api.getTodos();
+ *   setTodos(reconcile(fresh)); // diff-merge by `id`
+ * }
+ *
+ * // fixed-shape polling data — positional merge
+ * setStats(reconcile(nextStats, null));
+ * ```
+ */ function reconcile(e, t = "id") {
+    return n => reconcileState(e, n, t, false);
+}
+
+export { reconcile, reconcileState };