@solidjs/signals 2.0.0-rc.17 → 2.0.0-rc.19

package/dist/observe/store/optimistic.js

@@ -83,7 +83,7 @@ function notifyOptimisticWrites(e, n) {
     // inner store's truth for its key before guessing over it.
         const o = e.ch ? e.v : null;
     const guess = (e, n, i, r) => {
-        if (o !== null) e.Ie = i ? n in t : unwrapValue(t[n]);
+        if (o !== null) e.le = i ? n in t : unwrapValue(t[n]);
         // By value: a function leaf is a value, not an updater (#3017).
                 optimisticWrite(e, () => r);
     };
@@ -344,7 +344,7 @@ function arrangementEqual(e, n, t) {
     // keyed arrangement guess's view carries its removed-keys set.
         if (!i.It || !(t?.l & CONFIG_OVERRIDE) || !t.T.V?.removed) return false;
     const r = e.T.V;
-    if ((!e.Ye || !e.Ye(r, n)) && !GlobalQueue.sn(r, n)) {
+    if ((!e.je || !e.je(r, n)) && !GlobalQueue.sn(r, n)) {
         i.folded = foldedRead;
         insertSubs(e);
     } else GlobalQueue.tn?.(i);
@@ -365,8 +365,8 @@ function arrangementEqual(e, n, t) {
         const t = txOf(n);
         joinPassAt(e, resolveTx(t._parent ?? t));
     }
-    if (n.ue !== NOT_PENDING) return n.ue;
-    return n.l & CONFIG_SLOT_NODE ? GlobalQueue.fn(n) : n.Ie;
+    if (n.ie !== NOT_PENDING) return n.ie;
+    return n.l & CONFIG_SLOT_NODE ? GlobalQueue.fn(n) : n.le;
 }
 
 function sameRow(e, n, t) {
@@ -430,7 +430,7 @@ function sweepOverlaid() {
             // The container shows its backing again (a shown arrangement guess
             // that ended without a landing left its `LaneView` as the value).
                         const t = e.k;
-            if (t !== null && t.Ie instanceof LaneView) t.Ie = t.Ie.base;
+            if (t !== null && t.le instanceof LaneView) t.le = t.le.base;
         }
         if (n.size === 0) overlaidFamilies.delete(e);
     }
@@ -447,8 +447,8 @@ function sweepOverlaid() {
     if (i !== null) for (const e of Reflect.ownKeys(i)) {
         const r = i[e];
         const o = untrack(() => unwrapValue(n[e]));
-        if (r.Ye && r.Ye(r.Ie, o)) continue;
-        r.Ie = o;
+        if (r.je && r.je(r.le, o)) continue;
+        r.le = o;
         // (The lane's end notified it this epoch when the shown value and the
         // covered one differed — its readers re-derive already.)
                 if (r.o !== null && r.Ot !== notifyEpoch) {
@@ -460,8 +460,8 @@ function sweepOverlaid() {
     if (r !== null) for (const e of Reflect.ownKeys(r)) {
         const i = r[e];
         const o = untrack(() => e in n);
-        if (i.Ie === o) continue;
-        i.Ie = o;
+        if (i.le === o) continue;
+        i.le = o;
         if (i.o !== null && i.Ot !== notifyEpoch) {
             insertSubs(i);
             t = true;
@@ -470,9 +470,9 @@ function sweepOverlaid() {
     // The arrangement the readers saw (the shown guess) against the inner's
     // now: a structural reader re-derives when they differ.
         const o = e.k;
-    if (o !== null && o.o !== null && o.Ie instanceof LaneView && o.Ot !== notifyEpoch) {
+    if (o !== null && o.o !== null && o.le instanceof LaneView && o.Ot !== notifyEpoch) {
         const i = Array.isArray(n) ? untrack(() => n.map(unwrapValue)) : n;
-        if (!arrangementEqual(o.Ie.rows, i, e.fam?.key ?? null)) {
+        if (!arrangementEqual(o.le.rows, i, e.fam?.key ?? null)) {
             insertSubs(o);
             t = true;
         }

package/dist/observe/store/projection.js

@@ -1,6 +1,6 @@
 import { attrHooks } from "../core/attribution-hooks.js";
 
-import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, STATUS_UNINITIALIZED } from "../core/constants.js";
+import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, STATUS_ERROR, STATUS_UNINITIALIZED } from "../core/constants.js";
 
 import { computed } from "../core/core.js";
 
@@ -80,8 +80,8 @@ import { $TARGET, markRawIngest, isWrappable, setWriteOverride } from "./types.j
     };
     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;
+            const a = read(() => e[c]);
+            return !o && typeof a === "object" && a !== null && c !== $TARGET ? wrapDraft(a, t, r, false, n, i) : a;
         },
         has: (t, r) => read(() => r in e),
         set: (t, r, o) => mutate(() => {
@@ -103,8 +103,8 @@ import { $TARGET, markRawIngest, isWrappable, setWriteOverride } from "./types.j
     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);
+        const a = e[$TARGET];
+    if (a !== undefined) setLookup(c, a);
     return c;
 }
 
@@ -120,8 +120,14 @@ function cloneState(e, t) {
  * (`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, t) {
-    const r = e.node;
+ * 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;
     forEachFamilyNode(e, e => {
         if (e.o === null) return;
@@ -129,12 +135,12 @@ function cloneState(e, t) {
         // 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, r);
+                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, t);
+                propagateStatus(e, STATUS_PENDING, r);
     });
 }
 
@@ -160,6 +166,12 @@ function cloneState(e, 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;
@@ -179,18 +191,18 @@ function forEachFamilyNode(e, t) {
     const i = getOwner();
     const s = e[$TARGET];
     const c = s.fam;
-    const u = c.run = (c.run || 0) + 1;
+    const a = 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;
+        const u = 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.Se !== null ? i.T.Ee : 0);
-    const f = wrapDraft(e, () => c.run === u && !isDisposed(i), n, s.s, 
+        const asking = () => question || (i.T !== null && i.T.Ee !== null ? i.T.de : 0);
+    const f = wrapDraft(e, () => c.run === a && !isDisposed(i), n, s.s, 
     // A write after the run returned (a continuation, a callback) arms the
     // drain itself when no landing will.
     () => {
@@ -199,14 +211,14 @@ function forEachFamilyNode(e, t) {
     // 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 d = a === 1;
     const pass = () => storeSetter(f, n => {
-        l = t(a ?? n);
+        l = t(u ?? n);
         const commit = t => {
             // 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 (u && (t === undefined || t === u)) t = cloneState(u, s.s);
             if (t !== n && t !== undefined) {
                 const write = () => {
                     const o = question;
@@ -228,7 +240,7 @@ function forEachFamilyNode(e, t) {
             // (a fallback value, not pending) re-runs too (#4070).
                         insertSubs(i);
         };
-        const u = handleAsync(i, l, commit, (e, t) => {
+        const a = 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
@@ -236,9 +248,9 @@ function forEachFamilyNode(e, t) {
             // #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, e); else errorFamily(c);
+            if (t) wakeFamily(c); else errorFamily(c);
         });
-        if (!i.ce) commit(u);
+        if (!i.ce) commit(a);
     }, false);
     try {
         d ? runDirect(pass) : pass();
@@ -248,14 +260,14 @@ function forEachFamilyNode(e, t) {
         // 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, e) : errorFamily(c);
+        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.Se !== null && !i.ce && !d) wakeFamily(c, i.T?.F);
+        if (i.m & STATUS_PENDING && i.T.Ee !== null && !i.ce && !d) wakeFamily(c);
     return i;
 }
 
@@ -268,6 +280,7 @@ function createProjectionInternal(e, t, r) {
         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.

package/dist/observe/store/reconcile.js

@@ -24,15 +24,15 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
  * 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 === undefined || f.px !== n) throw new Error("");
-    const l = t === null ? null : typeof t === "string" ? e => e?.[t] : t;
+    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 (userWriting() && f.fam?.opt === true) {
-        optHooks.reconcile(n, unwrapValue(e), l);
+        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).
@@ -43,21 +43,20 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
                 adoptPB(f, e);
         return;
     }
-    const i = unwrapValue(e);
-    if (l) {
+    const l = unwrapValue(e);
+    if (i) {
         const e = f.pb ?? f.v;
-        const n = l(e);
-        if (n !== undefined && !sameKey(l(i), n)) {
+        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.
-                        const e = f.pb ?? f.v;
-            if (isOwned(e)) delete e[$OWNER]; else (f.fam?.map ?? storeLookup).delete(e);
-            adoptPB(f, i);
+                        if (isOwned(e)) delete e[$OWNER]; else (f.fam?.map ?? storeLookup).delete(e);
+            adoptPB(f, l);
             return;
         }
     }
-    applyAdopt(f, i, l, o);
+    applyAdopt(f, l, i, o);
 }
 
 /** Adopt `incoming` at `t` and notify its nodes — one leaf write per
@@ -70,190 +69,207 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
     // 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;
-    const l = e.fam;
     // 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 = l?.opt === true ? optHooks.view(e, f) : f;
-    const s = Array.isArray(n);
-    const u = e.s === true;
-    const r = f;
+        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 (u) markRawIngest(n);
-    if (Array.isArray(i) !== s) {
-        notifyFold(e, r, n);
+    if (r) markRawIngest(n);
+    // The deep witness is bumped once per adoption (none to bump: done).
+        let u = e.dk === null;
+    if (Array.isArray(i) !== l) {
+        notifyFold(e, f, n);
         return;
     }
-    if (s) {
-        const f = i;
-        const s = n;
-        const a = e.n;
-        let c = 0;
-        if (t && !u) {
-            const i = f.length;
-            const u = s.length;
-            let d = false;
-            let p = 0;
+    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 y = Math.min(i, u); p < y; p++) {
-                const i = s[p];
-                const u = f[p];
-                if (u !== i && !sameRow(u, i, t)) break;
+                        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 ((u !== i || i !== null && typeof i === "object" && isOwned(i)) && i !== null && typeof i === "object") descend(unwrapValue(u), i, t, l, o);
-                if (e.dk !== null && !d && !(i !== null && typeof i === "object" ? targetsEqual(u, i) : isEqual(u, i))) {
+                                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);
-                    d = true;
+                    u = true;
                 }
-                if (a !== null) {
-                    const e = a[p];
+                if (l !== null) {
+                    const e = l[c];
                     if (e !== undefined) {
-                        c++;
-                        notifyKeyValue(e, p, r[p], i, r, n);
+                        s++;
+                        notifyKeyValue(e, c, f[c], r, f, n);
                     }
                 }
             }
-            if (e.dk !== null && !d && p < s.length) bumpDeep(e);
-            const y = p;
+            if (!u && c < n.length) bumpDeep(e);
+            const d = c;
  // misalignment point (== nlen on aligned ticks)
-                        let w = null;
-            for (;p < s.length; p++) {
-                const e = s[p];
-                if (e !== null && typeof e === "object") {
-                    const n = t(e);
-                    let i;
+                        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 (w === null) {
-                            w = new Map;
-                            for (let e = y; e < f.length; e++) {
-                                const n = unwrapValue(f[e]);
+                        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 = w.get(o);
-                                    if (f === undefined) w.set(o, e); else if (Array.isArray(f)) f.push(e); else w.set(o, [ f, e ]);
+                                    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 = w.get(n);
-                        if (e === undefined) i = undefined; else if (Array.isArray(e)) {
-                            i = unwrapValue(f[e.shift()]);
-                            if (e.length === 1) w.set(n, e[0]);
+                        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 {
-                            i = unwrapValue(f[e]);
-                            w.delete(n);
+                            f = unwrapValue(i[e]);
+                            p.delete(n);
                         }
                     } else {
-                        i = unwrapValue(f[p]);
+                        f = unwrapValue(i[c]);
  // keyless item: positional fallback
                                         }
-                    descend(i, e, t, l, o);
+                    descend(f, r, t, o, e, c);
                 }
-                if (a !== null) {
-                    const e = a[p];
+                if (l !== null) {
+                    const e = l[c];
                     if (e !== undefined) {
-                        c++;
-                        notifyKeyDiff(e, p, r, n, false);
+                        s++;
+                        notifyKeyDiff(e, c, f, n, false);
                     }
                 }
             }
         } else {
-            const i = Math.min(f.length, s.length);
-            const d = s.length;
-            let p = false;
-            for (let y = 0; y < d; y++) {
-                const d = s[y];
-                if (!u && y < i && d !== null && typeof d === "object") descend(unwrapValue(f[y]), d, t, l, o);
-                if (e.dk !== null && !p && !(d !== null && typeof d === "object" ? targetsEqual(f[y], d) : isEqual(f[y], d))) {
+            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);
-                    p = true;
+                    u = true;
                 }
-                if (a !== null) {
-                    const e = a[y];
+                if (l !== null) {
+                    const e = l[d];
                     if (e !== undefined) {
-                        c++;
-                        notifyKeyDiff(e, y, r, n, false);
+                        s++;
+                        notifyKeyDiff(e, d, f, n, false);
                     }
                 }
             }
         }
         // Indices past the new length (and `length` itself) still have nodes.
-                if (a !== null && c < e.nc) {
-            for (const e of Reflect.ownKeys(a)) {
+                if (l !== null && s < e.nc) {
+            for (const e of Reflect.ownKeys(l)) {
                 const t = typeof e === "string" ? +e : NaN;
-                if (!(t >= 0 && t < s.length)) notifyKeyDiff(a[e], e, r, n, false);
+                if (!(t >= 0 && t < n.length)) notifyKeyDiff(l[e], e, f, n, false);
             }
         }
-        notifyFoldTail(e, r, n);
+        notifyFoldTail(e, f, n);
         return;
     }
-    const a = e.n;
-    let c = 0;
-    let d = false;
-    for (const f in n) {
-        const s = n[f];
-        const p = r[f];
-        const y = s !== null && typeof s === "object";
-        if (p === s && (!y || !isOwned(s)) && (a === null || a[f] === undefined || !hasAccessorFlag(a[f]))) {
-            if (a !== null && a[f] !== undefined) c++;
+    const s = e.n;
+    let a = 0;
+    for (const l in n) {
+        const c = n[l];
+        const d = f[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 (y && !u) descend(unwrapValue(i[f]), s, t, l, o);
-        if (e.dk !== null && !d && !(y ? targetsEqual(p, s) : isEqual(p, s))) {
+        if (p && !r) descend(unwrapValue(i[l]), c, t, o, e, l);
+        if (!u && !(p ? targetsEqual(d, c) : isEqual(d, c))) {
             bumpDeep(e);
-            d = true;
+            u = true;
         }
-        if (a !== null) {
-            const e = a[f];
+        if (s !== null) {
+            const e = s[l];
             if (e !== undefined) {
-                c++;
-                notifyKeyValue(e, f, p, s, r, n);
+                a++;
+                notifyKeyValue(e, l, d, c, f, n);
             }
         }
     }
-    const p = Object.getOwnPropertySymbols(n);
-    for (let e = 0; e < p.length; e++) {
-        const f = p[e];
-        if (f === $OWNER) continue;
-        const i = n[f];
-        if (!u && i !== null && typeof i === "object") descend(unwrapValue(r[f]), i, t, l, o);
-        if (a !== null) {
-            const e = a[f];
+    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) {
-                c++;
-                notifyKeyValue(e, f, r[f], i, r, n);
+                a++;
+                notifyKeyValue(e, l, f[l], u, f, n);
             }
         }
     }
     // Keys the incoming object no longer has still have nodes.
-        if (a !== null && c < e.nc) {
-        for (const e of Reflect.ownKeys(a)) {
-            if (!hasOwnP.call(n, e)) notifyKeyDiff(a[e], e, r, n, false);
+        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, r, n);
+    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). */ function descend(e, n, t, o, f = false) {
-    if (e === null || typeof e !== "object" || n === null || typeof n !== "object") return;
-    const l = lookupTarget(e, o);
-    if (l === undefined) return;
+ * 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;
-    n = unwrapValue(n);
     if (Array.isArray(e) !== Array.isArray(n)) return;
-    if (t) {
+    // 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 (!f && t !== null && !l.d) return;
-    applyAdopt(l, n, t, f);
+    if (!o && t !== null && !r.d) return;
+    applyAdopt(r, n, t, o);
 }
 
 export { reconcileState };