@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/prod/store/projection.js

@@ -0,0 +1,331 @@
+import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, STATUS_ERROR, STATUS_UNINITIALIZED } from "../core/constants.js";
+
+import { computed } from "../core/core.js";
+
+import { NotReadyError } from "../core/error.js";
+
+import { handleAsync, addPendingSource, propagateStatus, forEachDependent, settlePendingSource } from "../core/async.js";
+
+import { enqueueSub } from "../core/heap.js";
+
+import { getOwner, isDisposed } from "../core/owner.js";
+
+import { question, setQuestion, insertSubs, schedule } from "../core/scheduler.js";
+
+import { optHooks } from "./hooks.js";
+
+import { reconcileState } from "./reconcile.js";
+
+import { wrap, storeSetter, runDirect } from "./store.js";
+
+import { setLookup } from "./target.js";
+
+import { $TARGET, markRawIngest, isWrappable, setWriteOverride } from "./types.js";
+
+/**
+ * Store — projections (plan sec. 31, S3; INTERNALS §7/§7b).
+ *
+ * A projection is a computed store: the derive runs inside a computed — the
+ * **firewall** — whose pass writes the store through a draft; its output is
+ * adopted through the reconcile channel (replace-mode root: entity changes
+ * merge in place, the root proxy is stable for life). Children wrap into
+ * the projection's own FAMILY (writes land here, never in a source family).
+ *
+ * The firewall exists so writes from inside a computation are safe (the
+ * derive owns its leaves); the price is the ordering obligation: before any
+ * value is served through the projection, the derive is brought up to date
+ * — **without** the reader subscribing to it (that is the propagation
+ * barrier). The store's traps do that pull (`pullFamily`, store.ts): core's
+ * `read()` of the firewall with no link — freshness, the status gate
+ * (uninitialized / pending / errored) and the reader's height, by the
+ * rules a memo's read follows. No per-leaf back-pointer, nothing in core.
+ */
+/**
+ * Wrap a store proxy as a projection DRAFT: every operation carries the write
+ * override (the derive is the author — its ops must not hit the status gate,
+ * even in a continuation after an `await`/`yield` where the sync write scope
+ * has closed).
+ *
+ * FAKE TARGET, not the store proxy itself (#3060): after a proxy trap
+ * returns, the engine runs spec invariant validation against the proxy's
+ * TARGET — [[OwnPropertyKeys]] after ownKeys, [[GetOwnProperty]] after
+ * set/getOwnPropertyDescriptor/defineProperty. With the store proxy as
+ * target those checks re-enter the store's traps OUTSIDE the override
+ * bracket, so `Object.keys(state)` in a derive continuation fired the gate.
+ */ function wrapDraft(e, t, r, o, n, i) {
+    const mutate = e => {
+        if (!t()) return true;
+        setWriteOverride(true);
+        // A continuation's write is the flight's answer: it asks the flight's
+        // question (A18 provenance — a landing beneath a newer guess is held,
+        // not a correction; lanes.ts `laneWrite`).
+                const o = question;
+        if (i !== undefined) setQuestion(i());
+        try {
+            r ? r(e) : e();
+        } finally {
+            setWriteOverride(false);
+            setQuestion(o);
+        }
+        if (n) n();
+        return true;
+    };
+    const read = e => {
+        setWriteOverride(true);
+        try {
+            return e();
+        } finally {
+            setWriteOverride(false);
+        }
+    };
+    const s = {
+        get(s, c) {
+            const u = read(() => e[c]);
+            return !o && typeof u === "object" && u !== null && c !== $TARGET ? wrapDraft(u, t, r, false, n, i) : u;
+        },
+        has: (t, r) => read(() => r in e),
+        set: (t, r, o) => mutate(() => {
+            e[r] = o;
+        }),
+        deleteProperty: (t, r) => mutate(() => {
+            delete e[r];
+        }),
+        ownKeys: () => read(() => Reflect.ownKeys(e)),
+        getOwnPropertyDescriptor(t, r) {
+            const o = read(() => Reflect.getOwnPropertyDescriptor(e, r));
+            if (o) o.configurable = true;
+            return o;
+        },
+        defineProperty: (t, r, o) => mutate(() => {
+            Reflect.defineProperty(e, r, o);
+        })
+    };
+    const c = new Proxy(Array.isArray(e) ? [] : {}, s);
+    // The wrapper stands for its store proxy wherever the derive's result
+    // carries it (`wrap`, `unwrapValue`, reconcile's slot matching).
+        const u = e[$TARGET];
+    if (u !== undefined) setLookup(c, u);
+    return c;
+}
+
+function cloneState(e, t) {
+    return t ? Array.isArray(e) ? e.slice() : {
+        ...e
+    } : JSON.parse(JSON.stringify(e));
+}
+
+/** The derive's pass went pending (a new question in flight): every reader
+ * of a leaf learns it as a reader of the derive would (A9: any leaf reports
+ * the firewall's refetch) — core's own rule for a dependency going pending
+ * (`notifyStatus`): a verdict or re-derive reader re-runs, any other is
+ * pending derivatively on the derive (its readers hold; it re-runs at the
+ * landing). The leaves do not subscribe to the derive, so the family does
+ * the walk. */ function wakeFamily(e) {
+    const t = e.node;
+    // Pending on the derive itself, whatever source took it there (an upstream
+    // memo's flight reaches it as a NotReady of that memo, #4271): the leaves
+    // are not that source's dependents, so only the family's settle — which
+    // retires the derive (`settleFamily`) — reaches the readers parked here. A
+    // reader the landing leaves unchanged does not re-run to clear it (#4305).
+        const r = new NotReadyError(t);
+    e.woke = true;
+    optHooks?.ask(e);
+    forEachFamilyNode(e, e => {
+        if (e.o === null) return;
+        // The leaf carries the derive's pending as a propagated copy, as a memo
+        // between them would: a dependent recovering one branch stays pending
+        // through a leaf it still reads (core `retryReaches`), and the landing's
+        // walk retires the copy first (`settleFamily` → `settlePendingSource`).
+                addPendingSource(e, t);
+        // Its readers: core's propagation from the leaf — a verdict or re-derive
+        // reader re-runs, any other is pending derivatively on the derive and
+        // queued for the frame (held with it: the frame waits on the flight
+        // through them, `blocked`).
+                propagateStatus(e, STATUS_PENDING, r);
+    });
+}
+
+/** The derive's flight rejected: every live reader of the family
+ * re-derives (its pull throws the derive's error). */ function errorFamily(e) {
+    forEachFamilyNode(e, e => {
+        if (e.o === null) return;
+        forEachDependent(e, e => {
+            enqueueSub(e);
+        });
+    });
+    schedule();
+}
+
+/** The flight landed: the readers the wake left pending on the derive
+ * settle — core's walk, from each leaf (the leaves are not the derive's
+ * dependents, so its own settle walk does not reach them). */ function settleFamily(e) {
+    if (!e.woke) return;
+    e.woke = false;
+    const t = e.node;
+    forEachFamilyNode(e, e => {
+        if (e.o !== null) settlePendingSource(e, t);
+    });
+    // The landing is the derive's change for a reader parked on the derive
+    // itself, whatever status the landing pass began from (an errored derive
+    // re-asked: a reader that met the error has no leaf to learn it from).
+        insertSubs(t);
+}
+
+/** A source's status reached the derive by propagation (core
+ * `propagateStatus`), its pass not re-run: the family learns it as from the
+ * pass's own throw. */ function familyStatus(e) {
+    if (e & STATUS_PENDING) wakeFamily(this); else if (e & STATUS_ERROR) errorFamily(this);
+}
+
+function forEachFamilyNode(e, t) {
+    for (const r of e.live) {
+        const e = r.n;
+        if (e !== null) for (const r of Reflect.ownKeys(e)) t(e[r]);
+        const o = r.h;
+        if (o !== null) for (const e of Reflect.ownKeys(o)) t(o[e]);
+        if (r.k !== null) t(r.k);
+        if (r.dk !== null) t(r.dk);
+    }
+}
+
+/** The derive's pass: run `fn` against a draft of the store; commit its
+ * result (sync, or each async landing) through the reconcile channel.
+ * Draft validity is per run (R37): live from here until the NEXT run starts
+ * — a sync derive that subscribes to an external source and pushes into
+ * the draft from the callback (#3585) is the model use. */ function runProjectionComputed(e, t, r, o, n) {
+    const i = getOwner();
+    const s = e[$TARGET];
+    const c = s.fam;
+    const u = c.run = (c.run || 0) + 1;
+    let l;
+    // Open loading window (seedLoadingValue): the observable store IS commit #0
+    // for the whole first flight — the derive works a detached shadow of the
+    // seed so draft writes cannot tear through to readers (#2988). Every
+    // commit point reconciles the shadow through the normal commit path.
+        const a = i.ce ? cloneState(s.v, s.s) : null;
+    // The question a write of this run answers: inside a slice, the slice's
+    // (the sync pass); in a continuation — the flight still registered — the
+    // flight's (`handleAsync` stamped it with the action that asked).
+        const asking = () => question || (i.T !== null && i.T.Ee !== null ? i.T.Ie : 0);
+    const f = wrapDraft(e, () => c.run === u && !isDisposed(i), n, s.s, 
+    // A write after the run returned (a continuation, a callback) arms the
+    // drain itself when no landing will.
+    () => {
+        if (!(i.m & STATUS_PENDING) && !i.ce) schedule();
+    }, asking);
+    // The creation run commits directly (a memo's first value is its
+    // `_value`); every later run — a re-derive in a flush, an async landing
+    // — stages and commits with the flush like a memo's recompute.
+        const d = u === 1;
+    const pass = () => storeSetter(f, n => {
+        l = t(a ?? n);
+        const commit = (t, u = 1) => {
+            // Shadow run: commit a detached snapshot, never the shadow itself
+            // (adoption takes the value by identity — handing it the live
+            // shadow would fuse the draft to the observable store).
+            if (a && (t === undefined || t === a)) t = cloneState(a, s.s);
+            if (t !== n && t !== undefined) {
+                const write = () => {
+                    const o = question;
+                    setQuestion(asking());
+                    try {
+                        storeSetter(e, e => reconcileState(t, e, r, true), false);
+                    } finally {
+                        setQuestion(o);
+                    }
+                };
+                o ? o(write, t) : write();
+            }
+            // A landing (not the sync pass's own commit): the readers held
+            // pending on the derive settle.
+                        if (!d || !(i.m & STATUS_UNINITIALIZED)) settleFamily(c);
+            // A commit is the derive's change for the readers that observed its
+            // flight (linked by `pullFamily`; a settled pull does not link), as
+            // a memo's landing is for its readers: one that caught the NotReady
+            // (a fallback value, not pending) re-runs too (#4070). A pass of a
+            // settled derive has none (`wake` 0): a link left is a stale one a
+            // held frame keeps (A30), from a reader that re-ran since. Woken by
+            // every pass, a reader feeding a key the pass peeks at looped (#4342).
+                        if (u) insertSubs(i);
+        };
+        const u = handleAsync(i, l, commit, (e, t) => {
+            // The flight rejected: the leaves' readers learn it from here —
+            // they do not subscribe to the derive. Pending again (a NotReady
+            // rejection): the wake, as for the pass. Errored: every live
+            // reader re-derives and meets the error at its pull (memo parity,
+            // #2897) — and the flush that runs them advances the clock, so a
+            // later tracked re-read may retry (core `read`).
+            if (d && i.m & STATUS_UNINITIALIZED) return;
+            if (t) wakeFamily(c); else errorFamily(c);
+        });
+        // (The status is the one before this pass: `recompute` sets it after.)
+                if (!i.ce) commit(u, i.m & (STATUS_PENDING | STATUS_ERROR));
+    }, false);
+    try {
+        d ? runDirect(pass) : pass();
+    } catch (e) {
+        // A flight went up (NotReady out of the pass — the derive's own, with
+        // the derive as its source): the leaves' readers learn it from here —
+        // they do not subscribe to the derive.
+        // A synchronous error the same way (#3956: a rerun that finds the
+        // entry failed throws): every live reader re-derives and meets it.
+        if (!d) e instanceof NotReadyError ? wakeFamily(c) : errorFamily(c);
+        throw e;
+    }
+    // A pass that returned with a flight up (an iterator's sync first yield):
+    // the wake, as for the throw. Not a sync pass that superseded one — the
+    // status it reads is the dead flight's, cleared when this pass settles
+    // (#3181: a reader the settle walk had just released, re-parked for good).
+        if (i.m & STATUS_PENDING && i.T.Ee !== null && !i.ce && !d) wakeFamily(c);
+    return i;
+}
+
+function createProjectionInternal(e, t, r) {
+    // Seedless (`fn` takes no draft): the root starts as an empty record. It is
+    // a draft like any seed, never observable before the first landing (A25).
+    t ||= {};
+    const o = r?.key === undefined ? "id" : r.key;
+    const n = {
+        map: new WeakMap,
+        node: null,
+        live: new Set,
+        st: familyStatus,
+        shallow: !!r?.shallow,
+        // The row key, for a child paired after the adoption (store.ts
+        // `adoptChild`, #3712) as the adoption pairs them.
+        key: typeof o === "function" ? o : o === null ? null : e => isWrappable(e) ? e[o] : undefined
+    };
+    const i = wrap(t, null, null, n);
+    if (n.shallow) {
+        i[$TARGET].s = true;
+        markRawIngest(t);
+    }
+    let s;
+    if (r?.seedLoadingValue) s = {
+        loadingValue: undefined
+    };
+    const c = computed(() => {
+        if (!n.node) n.node = getOwner();
+        runProjectionComputed(i, e, o);
+    }, s);
+    c.l &= ~CONFIG_AUTO_DISPOSE;
+    n.node = c;
+    // The derive's leaves are not its dependents: a mark's repoll
+    // (affects-marks.ts) reaches their readers through this.
+        c.fam = n;
+    return {
+        store: i,
+        node: c
+    };
+}
+
+function createProjection(e, t, r) {
+    return createProjectionInternal(e, t, r).store;
+}
+
+/** `createStore(fn, seed, options)`: a projection with a user setter. */ function createStoreDerived(e, t, r) {
+    const {store: o} = createProjectionInternal(e, t, r);
+    return [ o, e => storeSetter(o, e) ];
+}
+
+export { createProjection, createStoreDerived, runProjectionComputed };

package/dist/prod/store/reconcile.js

@@ -0,0 +1,281 @@
+import { isEqual } from "../core/core.js";
+
+import { isOwned, $OWNER, storeLookup, lookupTarget } from "./target.js";
+
+import { userWriting, unwrapValue, adoptPB, sameKey, materializePB, notifyFold, sameRow, targetsEqual, bumpDeep, notifyKeyValue, notifyKeyDiff, notifyFoldTail, hasAccessorFlag } from "./store.js";
+
+import { optHooks } from "./hooks.js";
+
+import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "./types.js";
+
+/**
+ * Store — reconcile: the immutable-diff adoption channel (INTERNALS §3).
+ *
+ * Reconcile never merge-writes into backing objects: it adopts `incoming`
+ * as the backing at every proxied level (an internal pointer swap at the
+ * fold — no clones, no user-object mutation), value-notifies only where
+ * nodes exist, and descends into a changed child pair only where a target
+ * with nodes or the sticky descendants flag exists below (§6d: diff the
+ * listened path, not every cell). Reference-equal unowned pairs skip
+ * outright (an owned backing is setter-diverged and must diff).
+ *
+ * Keyed arrays: the aligned prefix is walked positionally; from the first
+ * misalignment rows match by key (surviving rows keep their proxy
+ * identity), unkeyed items fall back to position.
+ */ function reconcileState(e, n, t, o = false) {
+    if (n == null) throw new Error("");
+    const f = n[$TARGET];
+    if (f?.px !== n) throw new Error("");
+    const i = t === null ? null : typeof t === "string" ? e => e?.[t] : t;
+    // A user's reconcile on an optimistic family (S4): not an adoption of
+    // truth but an optimistic edit — the keyed diff is written into the draft
+    // (a matched row keeps its proxy, its changed leaves become its guesses),
+    // and the setter's exit turns the draft into guesses like any.
+        if (optHooks && userWriting() && f.fam?.opt === true) {
+        optHooks.reconcile(n, unwrapValue(e), i);
+        return;
+    }
+    // Replace-mode root handed another store's proxy: chain to it (§7b).
+        if (o && e !== n && e?.[$TARGET] !== undefined) {
+        const n = f.pb ?? f.v;
+        if (n === e) return;
+ // already chained to this store
+                adoptPB(f, e);
+        return;
+    }
+    const l = unwrapValue(e);
+    if (i) {
+        const e = f.pb ?? f.v;
+        const n = i(e);
+        if (n !== undefined && !sameKey(i(l), n)) {
+            if (!o) throw new Error("");
+            // A different entity at the root: the old backing is disowned (wraps
+            // fresh if re-handed) and the new one adopted whole.
+                        if (isOwned(e)) delete e[$OWNER]; else (f.fam?.map ?? storeLookup).delete(e);
+            adoptPB(f, l);
+            return;
+        }
+    }
+    applyAdopt(f, l, i, o);
+}
+
+/** Adopt `incoming` at `t` and notify its nodes — one leaf write per
+ * changed observed key, the structural nodes once — descending into
+ * changed child pairs that are proxied below. */ function applyAdopt(e, n, t, o = false) {
+    // The diff base is the view the nodes were last told (#3296). A nested
+    // overlay draft (`Object.create(v)`, #3044) reads a key the draft deleted
+    // as present through its prototype; materialized first — `adoptPB` does
+    // so anyway, after the base was taken — so a deletion the draft made is
+    // a deletion here (#3743: the presence and value diffs both read `old`).
+    const f = e.ovl ? materializePB(e) : e.pb ?? e.v;
+    if (n === f && !isOwned(f)) return;
+    // Q-D: a landing on an optimistic family is reconciled against the VIEW
+    // — key matching from the arrangement the guesses made (R28), so a row
+    // the guess added keeps its proxy when the server returns it.
+        const i = optHooks && e.fam?.opt === true ? optHooks.view(e, f) : f;
+    const l = Array.isArray(n);
+    const r = e.s === true;
+    adoptPB(e, n, false);
+    if (r) markRawIngest(n);
+    // The deep witness is bumped once per adoption (none to bump: done).
+        let u = e.dk === null;
+    // A live chained base (a store proxy, §7b) reads the inner store's
+    // current frame, not what the nodes were last told — nothing to diff
+    // against: the fold writes every node (#4361).
+        if (Array.isArray(i) !== l || f[$TARGET]) {
+        notifyFold(e, f, n);
+        return;
+    }
+    if (l) {
+        const l = e.n;
+        let s = 0;
+        if (t && !r) {
+            const r = i.length;
+            const a = n.length;
+            let c = 0;
+            // Aligned prefix: same row (by reference or key) at the same index.
+                        for (const d = Math.min(r, a); c < d; c++) {
+                const r = n[c];
+                const a = i[c];
+                if (a !== r && !sameRow(a, r, t)) break;
+ // misaligned: fall to the keyed remainder below
+                                if (r !== null && typeof r === "object" && (a !== r || isOwned(r))) descend(unwrapValue(a), r, t, o, e, c);
+                if (!u && !(r !== null && typeof r === "object" ? targetsEqual(a, r) : isEqual(a, r))) {
+                    bumpDeep(e);
+                    u = true;
+                }
+                if (l !== null) {
+                    const e = l[c];
+                    if (e !== undefined) {
+                        s++;
+                        notifyKeyValue(e, c, f[c], r, f, n);
+                    }
+                }
+            }
+            if (!u && c < n.length) bumpDeep(e);
+            const d = c;
+ // misalignment point (== nlen on aligned ticks)
+                        let p = null;
+            for (;c < n.length; c++) {
+                const r = n[c];
+                if (r !== null && typeof r === "object") {
+                    const n = t(r);
+                    let f;
+                    if (n !== undefined) {
+                        if (p === null) {
+                            p = new Map;
+                            for (let e = d; e < i.length; e++) {
+                                const n = unwrapValue(i[e]);
+                                if (n !== null && typeof n === "object") {
+                                    const o = t(n);
+                                    if (o === undefined) continue;
+                                    const f = p.get(o);
+                                    if (f === undefined) p.set(o, e); else if (Array.isArray(f)) f.push(e); else p.set(o, [ f, e ]);
+                                }
+                            }
+                        }
+                        const e = p.get(n);
+                        if (e === undefined) f = undefined; else if (Array.isArray(e)) {
+                            f = unwrapValue(i[e.shift()]);
+                            if (e.length === 1) p.set(n, e[0]);
+                        } else {
+                            f = unwrapValue(i[e]);
+                            p.delete(n);
+                        }
+                    } else {
+                        f = unwrapValue(i[c]);
+ // keyless item: positional fallback
+                                        }
+                    descend(f, r, t, o, e, c);
+                }
+                if (l !== null) {
+                    const e = l[c];
+                    if (e !== undefined) {
+                        s++;
+                        notifyKeyDiff(e, c, f, n, false);
+                    }
+                }
+            }
+        } else {
+            const a = Math.min(i.length, n.length);
+            const c = n.length;
+            for (let d = 0; d < c; d++) {
+                const c = n[d];
+                if (!r && d < a && c !== null && typeof c === "object") descend(unwrapValue(i[d]), c, t, o, e, d);
+                if (!u && !(c !== null && typeof c === "object" ? targetsEqual(i[d], c) : isEqual(i[d], c))) {
+                    bumpDeep(e);
+                    u = true;
+                }
+                if (l !== null) {
+                    const e = l[d];
+                    if (e !== undefined) {
+                        s++;
+                        notifyKeyDiff(e, d, f, n, false);
+                    }
+                }
+            }
+        }
+        // Indices past the new length (and `length` itself) still have nodes.
+                if (l !== null && s < e.nc) {
+            for (const e of Reflect.ownKeys(l)) {
+                const t = typeof e === "string" ? +e : NaN;
+                if (!(t >= 0 && t < n.length)) notifyKeyDiff(l[e], e, f, n, false);
+            }
+        }
+        notifyFoldTail(e, f, n);
+        return;
+    }
+    const s = e.n;
+    let a = 0;
+    for (const l in n) {
+        const c = n[l];
+        let d = f[l];
+        // A key under a guess is judged against the guess too (D-34): a truth
+        // equal to the value the guess covered still answers it.
+                if (optHooks && d === c && i !== f) d = i[l];
+        const p = c !== null && typeof c === "object";
+        if (d === c && (!p || !isOwned(c)) && (s === null || s[l] === undefined || !hasAccessorFlag(s[l]))) {
+            if (s?.[l] !== undefined) a++;
+            continue;
+        }
+        if (p && !r) descend(unwrapValue(i[l]), c, t, o, e, l);
+        if (!u && !(p ? targetsEqual(d, c) : isEqual(d, c))) {
+            bumpDeep(e);
+            u = true;
+        }
+        if (s !== null) {
+            const e = s[l];
+            if (e !== undefined) {
+                a++;
+                notifyKeyValue(e, l, d, c, f, n);
+            }
+        }
+    }
+    const c = Object.getOwnPropertySymbols(n);
+    for (let i = 0; i < c.length; i++) {
+        const l = c[i];
+        if (l === $OWNER) continue;
+        const u = n[l];
+        if (!r && u !== null && typeof u === "object") descend(unwrapValue(f[l]), u, t, o, e, l);
+        if (s !== null) {
+            const e = s[l];
+            if (e !== undefined) {
+                a++;
+                notifyKeyValue(e, l, f[l], u, f, n);
+            }
+        }
+    }
+    // Keys the incoming object no longer has still have nodes.
+        if (s !== null && a < e.nc) {
+        for (const e of Reflect.ownKeys(s)) {
+            if (!hasOwnP.call(n, e)) notifyKeyDiff(s[e], e, f, n, false);
+        }
+    }
+    notifyFoldTail(e, f, n);
+}
+
+const hasOwnP = Object.prototype.hasOwnProperty;
+
+/** Descend into a changed child pair — only where something is proxied
+ * below (§6d), never into a raw-marked leaf, never across array/object or a
+ * key mismatch (that is a replacement, handled by the parent's slot).
+ *
+ * A raw in both frames (the same objects swapped, reordered or shifted,
+ * #4001) must not leave two slots on one row. A raw already a live row keeps
+ * it at the slot it moved to; a row's `pk` follows the slot it sits at (a
+ * move or a pairing writes it), so a row whose raw is at that slot of the
+ * incoming frame is spoken for and not paired again here; a raw still
+ * resolving to a row that moved on drops the lookup (it wraps fresh, or is
+ * paired here). One lookup of `nv` on the common path, no allocation. */ function descend(e, n, t, o, f, i) {
+    // `nv` is an object at every call site.
+    if (e === null || typeof e !== "object") return;
+    const l = f.fam;
+    n = unwrapValue(n);
+    let r = lookupTarget(e, l);
+    const u = lookupTarget(n, l);
+    if (r !== undefined && r.pk !== i) {
+        if (r.pk != i && f.v[r.pk] === r.v) r = undefined; else if (r.u === f) r.pk = i;
+    }
+    if (u !== undefined && u !== r) {
+        if (u.v === n) {
+            if (u.u === f) u.pk = i;
+            return;
+        }
+        (l?.map ?? storeLookup).delete(n);
+    }
+    if (r === undefined) return;
+ // nothing proxied below this pair
+        if (!isWrappable(n)) return;
+    if (rawValuesUsed && isRawValue(n)) return;
+    if (Array.isArray(e) !== Array.isArray(n)) return;
+    // An array slot was paired by key already (or both rows are keyless).
+        if (typeof i !== "number" && t) {
+        const o = t(e);
+        const f = t(n);
+        if (o !== undefined && f !== undefined && !sameKey(o, f)) return;
+    }
+    if (!o && t !== null && !r.d) return;
+    applyAdopt(r, n, t, o);
+}
+
+export { reconcileState };