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

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_DESC, STORE_HAS, symbolKeyedRecords, getKeys, $DELETED, getStoreSymbols } 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, rawValuesUsed, isRawValue, wrap, 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
@@ -17,9 +17,9 @@ import { $TARGET, STORE_OVERRIDE, STORE_OPTIMISTIC_OVERRIDE, STORE_VALUE, STORE_
 function nodeKeys(e) {
     const t = Object.keys(e);
     if (symbolKeyedRecords.has(e)) {
-        const r = Object.getOwnPropertySymbols(e);
-        for (let e = 0, n = r.length; e < n; e++) {
-            if (r[e] !== $TRACK) t.push(r[e]);
+        const n = Object.getOwnPropertySymbols(e);
+        for (let e = 0, a = n.length; e < a; e++) {
+            if (n[e] !== $TRACK) t.push(n[e]);
         }
     }
     return t;
@@ -32,56 +32,56 @@ function unwrap(e) {
     return e[$TARGET]?.[STORE_VALUE] ?? e;
 }
 
-function getOverrideValue(e, t, r, n) {
-    if (n && r in n) return n[r];
-    return t && r in t ? t[r] : e[r];
+function getOverrideValue(e, t, n, a) {
+    if (a && n in a) return a[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, r) {
-    for (let n = 0, a = t.length; n < a; n++) {
-        if (Object.prototype.propertyIsEnumerable.call(e, t[n])) r.add(t[n]);
+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]);
     }
 }
 
-function getAllKeys(e, 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 n = getKeys(e, t);
-    const a = Object.keys(r);
+    const a = getKeys(e, t);
+    const r = 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 o = Object.getOwnPropertySymbols(r);
+    const s = 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 && o.length === 0) {
-        if (n.length === a.length) {
+        if (i.length === 0 && s.length === 0) {
+        if (a.length === r.length) {
             let e = true;
-            for (let t = 0; t < n.length; t++) {
-                if (n[t] !== a[t]) {
+            for (let t = 0; t < a.length; t++) {
+                if (a[t] !== r[t]) {
                     e = false;
                     break;
                 }
             }
-            if (e) return n;
+            if (e) return a;
         }
-        const e = new Set(n);
-        for (let t = 0; t < a.length; t++) e.add(a[t]);
+        const e = new Set(a);
+        for (let t = 0; t < r.length; t++) e.add(r[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(n);
+        const l = new Set(a);
     addEnumSymbols(e, i, l);
     if (t) {
         for (const e of Reflect.ownKeys(t)) {
             t[e] === $DELETED ? l.delete(e) : l.add(e);
         }
     }
-    for (let e = 0; e < a.length; e++) l.add(a[e]);
-    addEnumSymbols(r, o, l);
+    for (let e = 0; e < r.length; e++) l.add(r[e]);
+    addEnumSymbols(n, s, l);
     return Array.from(l);
 }
 
@@ -96,8 +96,8 @@ function itemKey(e, t) {
     return isWrappable(e) ? t(e) : e;
 }
 
-function keyedMatch(e, t, r) {
-    return e === t || isWrappable(e) && isWrappable(t) && r(e) === r(t);
+function keyedMatch(e, t, n) {
+    return e === t || isWrappable(e) && isWrappable(t) && n(e) === n(t);
 }
 
 // Array reconciliation updates the slots it visits, then swaps STORE_VALUE.
@@ -105,32 +105,72 @@ function keyedMatch(e, t, r) {
 // 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 r = e[STORE_NODE];
-    if (r) {
-        const e = nodeKeys(r);
-        for (let n = 0, a = e.length; n < a; n++) {
-            const a = e[n];
-            a in t || setSignal(r[a], undefined);
+    let n = e[STORE_NODE];
+    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);
+            }
+        } else {
+            for (const e in n) {
+                e in t || setSignal(n[e], undefined);
+            }
         }
     }
-    if (r = e[STORE_HAS]) {
-        const e = nodeKeys(r);
-        for (let n = 0, a = e.length; n < a; n++) {
-            const a = e[n];
-            setSignal(r[a], a in 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);
+            }
+        } 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, a) {
+    if (n[STORE_WRAP] !== undefined) {
+        applyState(e, wrap(t, n), a);
+        return;
+    }
+    const r = t[$TARGET] ?? storeLookup.get(t);
+    if (r === 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);
+    } else {
+        applyStateFast(e, r, a);
+    }
+}
+
 // 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, r, n, a) {
-    if (isWrappable(e) && isWrappable(t)) {
-        const i = wrap(t, r);
-        n && setSignal(n, i);
-        applyState(e, i, a);
-    } else n && setSignal(n, wrapValue(e, r));
+function applyArrayItem(e, t, n, a, r) {
+    if (isWrappable(e) && isWrappable(t) && !(rawValuesUsed && (isRawValue(t) || isRawValue(e)))) {
+        const i = wrap(t, n);
+        a && setSignal(a, i);
+        applyState(e, i, r);
+    } else a && setSignal(a, wrapValue(e, n));
 }
 
 /**
@@ -144,20 +184,53 @@ function applyArrayItem(e, t, r, n, a) {
  * 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;
+ */ function applyDescendants(e, t, n, a, r, i, s) {
+    const l = 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;
  // 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 y = unwrap(t[f]);
-        if (c === y || !isWrappable(y) || Array.isArray(c) !== Array.isArray(y) || a(c) != null && a(c) !== a(y)) continue;
-        applyState(y, wrap(c, r), a);
+                        const p = unwrap(getOverrideValue(e, i, f, s));
+            if (!isWrappable(p)) continue;
+            descendInto(p, t[f], l, r);
+        }
+        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 (a?.[n]) continue;
+ // main loop already diffed this slot
+                const i = unwrap(e[n]);
+        if (!isWrappable(i)) continue;
+        descendInto(i, t[n], l, r);
+    }
+    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;
+            const i = unwrap(e[o[n]]);
+            if (!isWrappable(i)) continue;
+            descendInto(i, t[o[n]], l, r);
+        }
+    }
+}
+
+function descendInto(e, t, n, a) {
+    const r = lookupTarget(e, n);
+    if (!r?.[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);
+    } else {
+        applyStateFast(i, r, a);
     }
 }
 
@@ -166,242 +239,363 @@ function applyArrayItem(e, t, r, n, a) {
 // 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, r) {
+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 n = t?.[$TARGET];
-    if (!n) return;
-    if (n[STORE_OVERRIDE] || n[STORE_OPTIMISTIC_OVERRIDE]) {
-        applyStateSlow(e, n, r);
+    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);
     } else {
-        applyStateFast(e, n, r);
+        applyStateFast(e, a, n);
     }
 }
 
-function applyStateFast(e, t, r) {
-    const n = t[STORE_VALUE];
-    if (e === n) return;
-    const a = t[STORE_NODE];
+// 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, a) {
+    let r = false;
+    for (const i in e) {
+        if (a && i === "length") continue;
+        if (i in t) {
+            const a = t[i];
+            if (a !== n(i)) {
+                r = true;
+                setSignal(e[i], a);
+            }
+        } else {
+            r = true;
+            setSignal(e[i], undefined);
+        }
+    }
+    return r;
+}
+
+function applyStateShallow(e, t, n) {
+    const a = t[STORE_VALUE];
+    const r = t[STORE_OVERRIDE];
+    const i = t[STORE_OPTIMISTIC_OVERRIDE];
+    if (e === a && !r && !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);
+        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);
+    t[STORE_VALUE] = e;
+    markRawIngest(e);
+    const l = t[STORE_NODE];
+    const o = l && l[$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 (!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 (l) {
+            f = shallowDiffNodes(l, 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);
+        }
+    }
+    f && notifySelf(t);
+}
+
+function applyStateFast(e, t, n) {
+    const a = t[STORE_VALUE];
+    if (e === a) return;
+    const r = t[STORE_NODE];
     // swap
-        (t[STORE_LOOKUP] || storeLookup).set(e, t[$PROXY]);
+        {
+        const n = t[STORE_LOOKUP];
+        n !== undefined ? n.set(e, t[$PROXY]) : storeLookup.set(e, t);
+    }
     t[STORE_VALUE] = e;
     // merge
-        if (Array.isArray(n)) {
+        if (Array.isArray(a)) {
         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;
-            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);
+        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++) {
+                // 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));
+                    } 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 === s) return;
             const E = new Array(e.length), O = new Map;
-            for (f = o - 1, c = e.length - 1; f >= p && c >= p && keyedMatch(u = n[f], e[c], r); f--, 
-            c--) {
-                E[c] = u;
+            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 (p > c || p > f) {
-                for (s = p; s <= c; s++) {
+            if (f > u || f > p) {
+                for (o = f; o <= u; o++) {
                     i = true;
-                    a?.[s] && setSignal(a[s], wrapValue(e[s], t));
+                    r?.[o] && setSignal(r[o], wrapValue(e[o], t));
                 }
-                for (;s < e.length; s++) {
+                for (;o < e.length; o++) {
                     i = true;
-                    applyArrayItem(e[s], E[s], t, a?.[s], r);
+                    applyArrayItem(e[o], E[o], t, r?.[o], n);
                 }
                 syncArrayNodeMembership(t, e);
-                (i || o !== e.length) && notifySelf(t);
-                o !== e.length && a?.length && setSignal(a.length, e.length);
+                (i || s !== e.length) && notifySelf(t);
+                s !== e.length && r?.length && setSignal(r.length, e.length);
                 return;
             }
-            y = 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);
+            S = new Array(u + 1);
+            for (o = u; o >= f; o--) {
+                c = e[o];
+                R = itemKey(c, n);
+                l = O.get(R);
+                S[o] = l === undefined ? -1 : l;
+                O.set(R, o);
             }
-            for (l = p; l <= f; l++) {
-                u = n[l];
-                S = itemKey(u, r);
-                s = O.get(S);
-                if (s !== undefined && s !== -1) {
-                    E[s] = u;
-                    s = y[s];
-                    O.set(S, s);
+            for (l = f; l <= p; l++) {
+                c = a[l];
+                R = itemKey(c, n);
+                o = O.get(R);
+                if (o !== undefined && o !== -1) {
+                    E[o] = c;
+                    o = S[o];
+                    O.set(R, o);
                 }
             }
-            for (s = p; s < e.length; s++) {
-                if (s in E) {
-                    applyArrayItem(e[s], E[s], t, a?.[s], r);
-                } else a?.[s] && setSignal(a[s], wrapValue(e[s], t));
+            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 (p < e.length) i = true;
+            if (f < e.length) i = true;
         } else if (e.length) {
-            for (let o = 0, l = e.length; o < l; o++) {
-                const l = n[o];
-                if (isWrappable(l) && isWrappable(e[o])) applyState(e[o], wrap(l, t), r); else {
-                    if (l !== e[o]) i = true;
-                    a?.[o] && setSignal(a[o], wrapValue(e[o], t));
+            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);
+                } else {
+                    if (l !== e[s]) i = true;
+                    r?.[s] && setSignal(r[s], wrapValue(e[s], t));
                 }
             }
         }
         syncArrayNodeMembership(t, e);
-        if (o !== e.length) {
+        if (s !== e.length) {
             i = true;
-            a?.length && setSignal(a.length, e.length);
+            r?.length && setSignal(r.length, e.length);
         }
         i && notifySelf(t);
         return;
     }
     // values
         let i = t[STORE_NODE];
-    let o;
+    let s;
     if (i) {
-        o = i[$TRACK];
-        if (o || symbolKeyedRecords.has(i)) {
-            const a = o ? getAllKeys(n, undefined, e) : nodeKeys(i);
-            for (let l = 0, s = a.length; l < s; l++) {
-                diffNodeKey(a[l], i, n, e, t, o, r);
+        s = 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];
+                const f = i[o];
+                const p = unwrap(a[o]);
+                const u = unwrap(e[o]);
+                if (p === u) continue;
+                if (!p || !isWrappable(p) || !isWrappable(u) || 
+                // 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);
             }
         } 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) {
-                diffNodeKey(a, i, n, e, t, o, r);
+            for (const r in i) {
+                const l = i[r];
+                const o = unwrap(a[r]);
+                const f = unwrap(e[r]);
+                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);
+                } else applyStateChild(f, o, t, n);
             }
         }
     }
-    if (!o && t[STORE_DESC]) applyDescendants(n, e, t, i, r);
+    if (!s && t[STORE_DESC]) applyDescendants(a, e, t, i, n);
     // has
         if (i = t[STORE_HAS]) {
         const t = nodeKeys(i);
-        for (let r = 0, n = t.length; r < n; r++) {
-            const n = t[r];
-            setSignal(i[n], n in e);
+        for (let n = 0, a = t.length; n < a; n++) {
+            const a = t[n];
+            setSignal(i[a], a in e);
         }
     }
 }
 
-// One node-key step of the fast object diff — shared by the array-iterating
-// (tracked / symbol-keyed) and for-in (plain) loops in applyStateFast.
-function diffNodeKey(e, t, r, n, a, i, o) {
-    const l = t[e];
-    const s = unwrap(r[e]);
-    let p = unwrap(n[e]);
-    if (s === p) return;
-    if (!s || !isWrappable(s) || !isWrappable(p) || Array.isArray(s) !== Array.isArray(p) || o(s) != null && o(s) !== o(p)) {
-        i && setSignal(i, void 0);
-        l && setSignal(l, isWrappable(p) ? wrap(p, a) : p);
-    } else applyState(p, wrap(s, a), o);
-}
-
-function applyStateSlow(e, t, r) {
-    const n = t[STORE_VALUE];
-    const a = t[STORE_OVERRIDE];
+function applyStateSlow(e, t, n) {
+    const a = t[STORE_VALUE];
+    const r = t[STORE_OVERRIDE];
     const i = t[STORE_OPTIMISTIC_OVERRIDE];
-    let o = t[STORE_NODE];
+    let s = t[STORE_NODE];
     // swap
-        (t[STORE_LOOKUP] || storeLookup).set(e, t[$PROXY]);
+        {
+        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(n)) {
+        if (Array.isArray(a)) {
         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);
+        const o = getOverrideValue(a, r, "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);
+                }
             }
-            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 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--, 
+            S--) {
+                y[S] = R;
             }
-            if (c > y || c > u) {
-                for (f = c; f <= y; f++) {
+            if (u > S || u > c) {
+                for (p = u; p <= S; p++) {
                     l = true;
-                    o?.[f] && setSignal(o[f], wrapValue(e[f], t));
+                    s?.[p] && setSignal(s[p], wrapValue(e[p], t));
                 }
-                for (;f < e.length; f++) {
+                for (;p < e.length; p++) {
                     l = true;
-                    applyArrayItem(e[f], d[f], t, o?.[f], r);
+                    applyArrayItem(e[p], y[p], t, s?.[p], n);
                 }
-                const n = e.length;
+                const a = e.length;
                 syncArrayNodeMembership(t, e);
-                (l || s !== n) && notifySelf(t);
-                s !== n && o?.length && setSignal(o.length, n);
+                (l || o !== a) && notifySelf(t);
+                o !== a && s?.length && setSignal(s.length, a);
                 return;
             }
-            E = new Array(y + 1);
-            for (f = y; f >= c; f--) {
-                S = e[f];
-                O = itemKey(S, r);
-                p = R.get(O);
-                E[f] = p === undefined ? -1 : p;
-                R.set(O, f);
+            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);
             }
-            for (p = c; p <= u; p++) {
-                S = getOverrideValue(n, a, p, i);
-                O = itemKey(S, r);
-                f = R.get(O);
-                if (f !== undefined && f !== -1) {
-                    d[f] = S;
-                    f = E[f];
-                    R.set(O, f);
+            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 = c; f < e.length; f++) {
-                if (f in d) {
-                    applyArrayItem(e[f], d[f], t, o?.[f], r);
-                } else o?.[f] && setSignal(o[f], wrapValue(e[f], t));
+            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));
             }
-            if (c < e.length) l = true;
+            if (u < e.length) l = true;
         } else if (e.length) {
-            for (let s = 0, p = e.length; s < p; s++) {
-                const p = getOverrideValue(n, a, s, i);
-                if (isWrappable(p) && isWrappable(e[s])) applyState(e[s], wrap(p, t), r); else {
-                    if (p !== e[s]) l = true;
-                    o?.[s] && setSignal(o[s], wrapValue(e[s], t));
+            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])))) {
+                    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));
                 }
             }
         }
-        const p = e.length;
+        const f = e.length;
         syncArrayNodeMembership(t, e);
-        if (s !== p) {
+        if (o !== f) {
             l = true;
-            o?.length && setSignal(o.length, p);
+            s?.length && setSignal(s.length, f);
         }
         l && notifySelf(t);
         return;
     }
     // values
         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)) {
+    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]);
+            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);
-                c && setSignal(c, isWrappable(y) ? wrap(y, t) : y);
-            } else applyState(y, wrap(u, t), r);
+                u && setSignal(u, isWrappable(S) ? wrap(S, t) : S);
+            } else applyState(S, wrap(c, t), n);
         }
     }
-    if (!l && t[STORE_DESC]) applyDescendants(n, e, t, o, r, a, i);
+    if (!l && t[STORE_DESC]) applyDescendants(a, e, t, s, n, r, i);
     // has
-        if (o = t[STORE_HAS]) {
-        const t = nodeKeys(o);
-        for (let r = 0, n = t.length; r < n; r++) {
-            const n = t[r];
-            setSignal(o[n], n in e);
+        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);
         }
     }
 }
@@ -441,16 +635,16 @@ const NOKEY = () => null;
  * setStats(reconcile(nextStats, null));
  * ```
  */ function reconcile(e, t = "id") {
-    return r => {
-        if (r == null) throw new Error("");
+    return n => {
+        if (n == null) throw new Error("");
         if (t === null) {
-            applyState(e, r, NOKEY);
+            applyState(e, n, NOKEY);
             return;
         }
-        const n = typeof t === "string" ? e => e[t] : t;
-        const a = n(r);
-        if (a !== undefined && n(e) !== a) throw new Error("");
-        applyState(e, r, n);
+        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);
     };
 }