@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.15

package/dist/prod/store/optimistic.js

@@ -10,7 +10,9 @@ import { GlobalQueue, txOf, list, insertSubs, laneDirty, notifyEpoch, schedule }
 
 import { runProjectionComputed } from "./projection.js";
 
-import { wrap, storeSetter, LaneView, committed, getNode, unwrapValue, sameKey, installOptHooks, resolveChainedRaw, getHasNode, targetsEqual, getContainerNode, cloneRaw } from "./store.js";
+import { wrap, storeSetter, LaneView, committed, getNode, unwrapValue, sameKey, resolveChainedRaw, getHasNode, targetsEqual, getContainerNode, cloneRaw } from "./store.js";
+
+import { installOptHooks } from "./hooks.js";
 
 import { $OWNER } from "./target.js";
 
@@ -79,7 +81,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.pe = i ? n in t : unwrapValue(t[n]);
+        if (o !== null) e.Ae = i ? n in t : unwrapValue(t[n]);
         // By value: a function leaf is a value, not an updater (#3017).
                 optimisticWrite(e, () => r);
     };
@@ -89,17 +91,17 @@ function notifyOptimisticWrites(e, n) {
         // A chained draft holds the inner store's raws; a raw is the inner slot it
         // resolves to (as a read of it serves) — the row a held write staged is
         // the same row, not a guess over the slot (#3796).
-                const f = n[t];
-        const a = unwrapValue(o && f ? resolveChainedRaw(e, t, f) : f);
+                const a = n[t];
+        const f = unwrapValue(o && a ? resolveChainedRaw(e, t, a) : a);
         if (!(t in i)) {
-            guess(getNode(e, t), t, false, a);
+            guess(getNode(e, t), t, false, f);
             guess(getHasNode(e, t), t, true, true);
             s = true;
         } else {
             const n = i[t];
-            const f = unwrapValue(o && n ? resolveChainedRaw(e, t, n) : n);
-            if (!isEqual(f, a) && !targetsEqual(f, a)) {
-                guess(getNode(e, t), t, false, a);
+            const a = unwrapValue(o && n ? resolveChainedRaw(e, t, n) : n);
+            if (!isEqual(a, f) && !targetsEqual(a, f)) {
+                guess(getNode(e, t), t, false, f);
                 if (r) s = true;
             }
         }
@@ -120,16 +122,16 @@ function notifyOptimisticWrites(e, n) {
         // The rows the setter removed from the view it saw, by key: a later
         // re-base over another action's truth must not bring them back.
                 let s = null;
-        const f = e.fam.key;
-        if (r && f !== null && f !== undefined) {
+        const a = e.fam.key;
+        if (r && a !== null && a !== undefined) {
             const e = new Set;
             for (let n = 0; n < o.length; n++) {
-                const t = isWrappable(o[n]) ? f(o[n]) : undefined;
+                const t = isWrappable(o[n]) ? a(o[n]) : undefined;
                 if (t !== undefined) e.add(t);
             }
             for (let n = 0; n < i.length; n++) {
                 const t = unwrapValue(i[n]);
-                const r = isWrappable(t) ? f(t) : undefined;
+                const r = isWrappable(t) ? a(t) : undefined;
                 if (r !== undefined && !e.has(r)) (s ??= new Set).add(r);
             }
         }
@@ -137,10 +139,10 @@ function notifyOptimisticWrites(e, n) {
     }
     if (e.dk !== null) optimisticWrite(e.dk, {});
     markOverlaid(e);
-    const f = optStaged.get(e);
-    if (f === undefined) return null;
+    const a = optStaged.get(e);
+    if (a === undefined) return null;
     optStaged.delete(e);
-    return f;
+    return a;
 }
 
 /** The container comparator's lane arm (store.ts `containerEquals`): an
@@ -157,9 +159,40 @@ function rowSame(e, n, t) {
     if (t === null || !isWrappable(e) || !isWrappable(n)) return false;
     const i = t(unwrapValue(e));
     const r = t(unwrapValue(n));
+    // Keyless rows are identified by position — reconcile's fallback when the
+    // key is missing. The caller already paired these by index, so two keyless
+    // rows are the same row and the landing confirms the arrangement instead of
+    // dissolving it. Dissolving held an external echo under the action, and a
+    // mainline `until` then timed out on a source that already contained it
+    // (#3898). Keyed rows still match only on the key.
+        if (i === undefined && r === undefined) return true;
     return i !== undefined && sameKey(i, r);
 }
 
+/** Whether reconcile would write anything into `a` from `b`: wrappable
+ * pairs descend, leaves compare as its writes do. A key mismatch is a
+ * replacement, which a content difference already says. Plain data — the
+ * server's echo of a guessed row is a new object with the same contents. */ function echoes(e, n) {
+    if (e === n) return true;
+    if (!isWrappable(e) || !isWrappable(n)) return false;
+    e = unwrapValue(e);
+    n = unwrapValue(n);
+    const t = Object.keys(e);
+    if (Array.isArray(e) !== Array.isArray(n) || t.length !== Object.keys(n).length) return false;
+    for (const i of t) if (!hasOwn.call(n, i) || !echoes(e[i], n[i])) return false;
+    return true;
+}
+
+// A cycle (a row that references itself) is not plain data: no match, so
+// the landing stays a correction.
+GlobalQueue.tn = (e, n) => {
+    try {
+        return echoes(e, n);
+    } catch {
+        return false;
+    }
+};
+
 function arrangementEqual(e, n, t) {
     if (Array.isArray(e) !== Array.isArray(n)) return false;
     if (Array.isArray(e)) {
@@ -193,18 +226,18 @@ function arrangementEqual(e, n, t) {
             }
         }
         for (let s = 0; s < n.length; s++) {
-            const f = n[s];
-            let a;
-            if (isWrappable(f)) {
+            const a = n[s];
+            let f;
+            if (isWrappable(a)) {
                 if (o !== null) {
-                    const e = t(f);
-                    if (e !== undefined) a = o.get(e);
-                } else if (s < i && isWrappable(unwrapValue(r[s]))) a = r[s];
+                    const e = t(a);
+                    if (e !== undefined) f = o.get(e);
+                } else if (s < i && isWrappable(unwrapValue(r[s]))) f = r[s];
             }
-            if (a !== undefined) {
-                if (unwrapValue(a) !== f) reconcileDraft(a, f, t);
-                if (e[s] !== a) e[s] = a;
-            } else if (unwrapValue(e[s]) !== f) e[s] = f;
+            if (f !== undefined) {
+                if (unwrapValue(f) !== a) reconcileDraft(f, a, t);
+                if (e[s] !== f) e[s] = f;
+            } else if (unwrapValue(e[s]) !== a) e[s] = a;
         }
         if (e.length !== n.length) e.length = n.length;
         return;
@@ -233,10 +266,10 @@ function arrangementEqual(e, n, t) {
  * node is born for it as the lane's derivation), on `length` only when the
  * committed length differs, and as the `LaneView`'s base for structural
  * reads. Unkeyed families compose
- * positionally — the guess stands as written (the documented residue). */ GlobalQueue.En = (e, n) => {
-    const t = e.ot;
-    if (t === undefined || e.rt !== $TRACK) return;
-    const i = e.m.Z;
+ * positionally — the guess stands as written (the documented residue). */ GlobalQueue.an = (e, n) => {
+    const t = e.lt;
+    if (t === undefined || e.ot !== $TRACK) return;
+    const i = e.m.B;
     if (!(i instanceof LaneView)) return;
     if (!Array.isArray(n) || !Array.isArray(i.rows)) {
         i.base = n;
@@ -251,45 +284,45 @@ function arrangementEqual(e, n, t) {
         if (i !== undefined && !o.has(i)) o.set(i, t);
     }
     const s = new Set;
-    const f = [];
-    const a = i.rows;
-    for (let e = 0; e < a.length; e++) {
-        const n = a[e];
+    const a = [];
+    const f = i.rows;
+    for (let e = 0; e < f.length; e++) {
+        const n = f[e];
         const t = isWrappable(n) ? r(n) : undefined;
         const i = t !== undefined ? o.get(t) : undefined;
         if (i !== undefined) {
-            f.push(i);
+            a.push(i);
             s.add(t);
-        } else f.push(n);
+        } else a.push(n);
     }
-    const l = i.removed;
+    const u = i.removed;
     for (let e = 0; e < n.length; e++) {
         const t = n[e];
         const i = isWrappable(t) ? r(t) : undefined;
-        if (i !== undefined && !s.has(i) && (l === null || !l.has(i))) f.push(t);
+        if (i !== undefined && !s.has(i) && (u === null || !u.has(i))) a.push(t);
     }
-    i.rows = f;
-    i.base = f;
-    const u = txOf(e);
+    i.rows = a;
+    i.base = a;
+    const l = txOf(e);
     const c = committed(t);
     const d = t.n;
-    for (let e = 0; e < f.length; e++) {
+    for (let e = 0; e < a.length; e++) {
         const n = d?.[e];
         // A slot the lane does not own shows the committed row: it becomes the
         // lane's only where the composed row is another row (by key — the same
         // key's new object is the same row, its target adopted it).
                 if (n === undefined) {
-            if (!sameRow(c[e], f[e], r)) laneSet(getNode(t, e), f[e], u);
-        } else if (!sameRow(n.u & CONFIG_OVERRIDE ? n.m.Z : c[e], f[e], r)) laneSet(n, f[e], u);
+            if (!sameRow(c[e], a[e], r)) laneSet(getNode(t, e), a[e], l);
+        } else if (!sameRow(n.i & CONFIG_OVERRIDE ? n.m.B : c[e], a[e], r)) laneSet(n, a[e], l);
     }
     if (d !== null) {
-        for (let e = f.length; ;e++) {
+        for (let e = a.length; ;e++) {
             const n = d[e];
             if (n === undefined) break;
-            laneSet(n, undefined, u);
+            laneSet(n, undefined, l);
         }
         const e = d.length;
-        if (e !== undefined && (e.u & CONFIG_OVERRIDE || c.length !== f.length)) laneSet(e, f.length, u);
+        if (e !== undefined && (e.i & CONFIG_OVERRIDE || c.length !== a.length)) laneSet(e, a.length, l);
     }
 };
 
@@ -304,11 +337,11 @@ function sameRow(e, n, t) {
  * node that was not the lane's becomes its derivation (its committed value
  * untouched beneath; the lane's end commits the latest). */ function laneSet(e, n, t) {
     const i = ext(e);
-    if (!(e.u & CONFIG_OVERRIDE)) {
-        e.u |= CONFIG_OVERRIDE;
+    if (!(e.i & CONFIG_OVERRIDE)) {
+        e.i |= CONFIG_OVERRIDE;
         list(e, t);
-    } else if (i.Z === n) return;
-    i.Z = n;
+    } else if (i.B === n) return;
+    i.B = n;
     if (e.t !== null) {
         insertSubs(e);
         laneDirty(e, t);
@@ -354,7 +387,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.pe instanceof LaneView) t.pe = t.pe.base;
+            if (t !== null && t.Ae instanceof LaneView) t.Ae = t.Ae.base;
         }
         if (n.size === 0) overlaidFamilies.delete(e);
     }
@@ -371,11 +404,11 @@ function sweepOverlaid() {
     if (i !== null) for (const e of Reflect.ownKeys(i)) {
         const r = i[e];
         const o = untrack(() => unwrapValue(n[e]));
-        if (r.We && r.We(r.pe, o)) continue;
-        r.pe = o;
+        if (r.ye && r.ye(r.Ae, o)) continue;
+        r.Ae = 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.t !== null && r.ze !== notifyEpoch) {
+                if (r.t !== null && r.qe !== notifyEpoch) {
             insertSubs(r);
             t = true;
         }
@@ -384,9 +417,9 @@ function sweepOverlaid() {
     if (r !== null) for (const e of Reflect.ownKeys(r)) {
         const i = r[e];
         const o = untrack(() => e in n);
-        if (i.pe === o) continue;
-        i.pe = o;
-        if (i.t !== null && i.ze !== notifyEpoch) {
+        if (i.Ae === o) continue;
+        i.Ae = o;
+        if (i.t !== null && i.qe !== notifyEpoch) {
             insertSubs(i);
             t = true;
         }
@@ -394,9 +427,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.t !== null && o.pe instanceof LaneView && o.ze !== notifyEpoch) {
+    if (o !== null && o.t !== null && o.Ae instanceof LaneView && o.qe !== notifyEpoch) {
         const i = Array.isArray(n) ? untrack(() => n.map(unwrapValue)) : n;
-        if (!arrangementEqual(o.pe.rows, i, e.fam?.key ?? null)) {
+        if (!arrangementEqual(o.Ae.rows, i, e.fam?.key ?? null)) {
             insertSubs(o);
             t = true;
         }
@@ -405,12 +438,12 @@ function sweepOverlaid() {
 }
 
 function carriesLane(e) {
-    if (e.k !== null && e.k.u & CONFIG_OVERRIDE) return true;
-    if (e.dk !== null && e.dk.u & CONFIG_OVERRIDE) return true;
+    if (e.k !== null && e.k.i & CONFIG_OVERRIDE) return true;
+    if (e.dk !== null && e.dk.i & CONFIG_OVERRIDE) return true;
     const n = e.n;
-    if (n !== null) for (const e of Reflect.ownKeys(n)) if (n[e].u & CONFIG_OVERRIDE) return true;
+    if (n !== null) for (const e of Reflect.ownKeys(n)) if (n[e].i & CONFIG_OVERRIDE) return true;
     const t = e.h;
-    if (t !== null) for (const e of Reflect.ownKeys(t)) if (t[e].u & CONFIG_OVERRIDE) return true;
+    if (t !== null) for (const e of Reflect.ownKeys(t)) if (t[e].i & CONFIG_OVERRIDE) return true;
     return false;
 }
 
@@ -428,9 +461,9 @@ function overlaid(e) {
  * the backing answers. */ function optimisticHas(e, n) {
     if (!overlaid(e)) return undefined;
     const t = e.h?.[n];
-    if (t !== undefined && t.u & CONFIG_OVERRIDE) return !!shown(t);
+    if (t !== undefined && t.i & CONFIG_OVERRIDE) return !!shown(t);
     const i = e.n?.[n];
-    if (i !== undefined && i.u & CONFIG_OVERRIDE) return shown(i) !== undefined;
+    if (i !== undefined && i.i & CONFIG_OVERRIDE) return shown(i) !== undefined;
     return undefined;
 }
 
@@ -441,7 +474,7 @@ function overlaid(e) {
     if (t === undefined) return undefined;
     if (!t) return null;
     const i = e.n?.[n];
-    const r = i !== undefined && i.u & CONFIG_OVERRIDE ? shown(i) : e.v[n];
+    const r = i !== undefined && i.i & CONFIG_OVERRIDE ? shown(i) : e.v[n];
     // An array's `length` is reported as the array has it (non-configurable).
         if (n === "length" && Array.isArray(e.v)) return {
         value: r,
@@ -474,7 +507,7 @@ i = false) {
         for (const e of Reflect.ownKeys(o)) {
             const r = o[e];
             let s;
-            if (r.u & CONFIG_OVERRIDE) s = t(r); else if (!i || (s = pendingGuessOf(r)) === NOT_PENDING) continue;
+            if (r.i & CONFIG_OVERRIDE) s = t(r); else if (!i || (s = pendingGuessOf(r)) === NOT_PENDING) continue;
             if (e === "length" && Array.isArray(n)) {
                 if (n.length !== s) ensure().length = s;
             } else if (!isEqual(n[e], s) || !hasOwn.call(n, e)) {
@@ -486,11 +519,11 @@ i = false) {
     if (s !== null) {
         for (const e of Reflect.ownKeys(s)) {
             const o = s[e];
-            let f;
-            if (o.u & CONFIG_OVERRIDE) f = t(o); else if (!i || (f = pendingGuessOf(o)) === NOT_PENDING) continue;
-            const a = !!f;
-            const l = r ?? n;
-            if (!a && e in l) delete ensure()[e];
+            let a;
+            if (o.i & CONFIG_OVERRIDE) a = t(o); else if (!i || (a = pendingGuessOf(o)) === NOT_PENDING) continue;
+            const f = !!a;
+            const u = r ?? n;
+            if (!f && e in u) delete ensure()[e];
         }
     }
     return r ?? n;
@@ -501,7 +534,7 @@ function createOptimisticStore(e, n, t) {
     const r = i ? t : n;
     const o = i ? n : e;
     const s = r?.key === undefined ? "id" : r.key;
-    const f = {
+    const a = {
         map: new WeakMap,
         node: null,
         live: new Set,
@@ -509,9 +542,9 @@ function createOptimisticStore(e, n, t) {
         opt: true,
         key: typeof s === "function" ? s : s === null ? null : e => isWrappable(e) ? e[s] : undefined
     };
-    const a = wrap(o, null, null, f);
-    if (f.shallow) {
-        a[$TARGET].s = true;
+    const f = wrap(o, null, null, a);
+    if (a.shallow) {
+        f[$TARGET].s = true;
         markRawIngest(o);
     }
     if (i) {
@@ -521,13 +554,13 @@ function createOptimisticStore(e, n, t) {
             loadingValue: undefined
         };
         const i = computed(() => {
-            if (!f.node) f.node = getOwner();
-            runProjectionComputed(a, n, s);
+            if (!a.node) a.node = getOwner();
+            runProjectionComputed(f, n, s);
         }, t);
-        i.u &= ~CONFIG_AUTO_DISPOSE;
-        f.node = i;
+        i.i &= ~CONFIG_AUTO_DISPOSE;
+        a.node = i;
     }
-    return [ a, e => storeSetter(a, e) ];
+    return [ f, e => storeSetter(f, e) ];
 }
 
 export { createOptimisticStore, notifyOptimisticWrites, optimisticHas, optimisticOwnDescriptor, optimisticView, sweepOverlaid };

package/dist/prod/store/projection.js

@@ -18,7 +18,7 @@ import { wrap, storeSetter, runDirect } from "./store.js";
 
 import { setLookup } from "./target.js";
 
-import { $TARGET, markRawIngest, setWriteOverride } from "./types.js";
+import { $TARGET, markRawIngest, setWriteOverride, isWrappable } from "./types.js";
 
 /**
  * Store — projections (plan sec. 31, S3; INTERNALS §7/§7b).
@@ -183,16 +183,16 @@ function forEachFamilyNode(e, t) {
     // 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._e ? cloneState(s.v, s.s) : null;
+        const a = i.De ? 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.m !== null && i.m.De !== null ? i.m.Oe : 0);
+        const asking = () => question || (i.m !== null && i.m.Te !== null ? i.m._e : 0);
     const f = wrapDraft(e, () => c.run === u && !isDisposed(i), o, s.s, 
     // A write after the run returned (a continuation, a callback) arms the
     // drain itself when no landing will.
     () => {
-        if (!(i.G & STATUS_PENDING) && !i._e) schedule();
+        if (!(i.S & STATUS_PENDING) && !i.De) 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
@@ -219,7 +219,7 @@ function forEachFamilyNode(e, t) {
             }
             // A landing (not the sync pass's own commit): the readers held
             // pending on the derive settle.
-                        if (!d || !(i.G & STATUS_UNINITIALIZED)) settleFamily(c);
+                        if (!d || !(i.S & STATUS_UNINITIALIZED)) settleFamily(c);
         };
         const u = handleAsync(i, l, commit, (e, t) => {
             // The flight rejected: the leaves' readers learn it from here —
@@ -228,10 +228,10 @@ function forEachFamilyNode(e, t) {
             // 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.G & STATUS_UNINITIALIZED) return;
+            if (d && i.S & STATUS_UNINITIALIZED) return;
             if (t) wakeFamily(c, e); else errorFamily(c);
         });
-        if (!i._e) commit(u);
+        if (!i.De) commit(u);
     }, false);
     try {
         d ? runDirect(pass) : pass();
@@ -239,42 +239,48 @@ function forEachFamilyNode(e, t) {
         // 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.
-        if (e instanceof NotReadyError && !d) wakeFamily(c, e);
+        // 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);
         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.G & STATUS_PENDING && i.m.De !== null && !i._e && !d) wakeFamily(c, i.m?.V);
+        if (i.S & STATUS_PENDING && i.m.Te !== null && !i.De && !d) wakeFamily(c, i.m?.F);
     return i;
 }
 
 function createProjectionInternal(e, t, r) {
-    const n = {
+    const n = r?.key === undefined ? "id" : r.key;
+    const o = {
         map: new WeakMap,
         node: null,
         live: new Set,
-        shallow: !!r?.shallow
+        shallow: !!r?.shallow,
+        // The row key, for a child paired after the adoption (store.ts
+        // `adoptChild`, #3712) as the adoption pairs them.
+        key: typeof n === "function" ? n : n === null ? null : e => isWrappable(e) ? e[n] : undefined
     };
-    const o = wrap(t, null, null, n);
-    if (n.shallow) {
-        o[$TARGET].s = true;
+    const i = wrap(t, null, null, o);
+    if (o.shallow) {
+        i[$TARGET].s = true;
         markRawIngest(t);
     }
-    let i;
-    if (r?.seedLoadingValue) i = {
+    let s;
+    if (r?.seedLoadingValue) s = {
         loadingValue: undefined
     };
-    const s = computed(() => {
-        if (!n.node) n.node = getOwner();
-        runProjectionComputed(o, e, r?.key === undefined ? "id" : r.key);
-    }, i);
-    s.u &= ~CONFIG_AUTO_DISPOSE;
-    n.node = s;
+    const c = computed(() => {
+        if (!o.node) o.node = getOwner();
+        runProjectionComputed(i, e, n);
+    }, s);
+    c.i &= ~CONFIG_AUTO_DISPOSE;
+    o.node = c;
     return {
-        store: o,
-        node: s
+        store: i,
+        node: c
     };
 }
 

package/dist/prod/store/reconcile.js

@@ -2,7 +2,9 @@ import { isEqual } from "../core/core.js";
 
 import { isOwned, $OWNER, storeLookup, lookupTarget } from "./target.js";
 
-import { userWriting, optHooks, unwrapValue, adoptPB, sameKey, materializePB, notifyFold, targetsEqual, bumpDeep, notifyKeyValue, notifyKeyDiff, notifyFoldTail, hasAccessorFlag } from "./store.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";
 
@@ -73,33 +75,33 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
     // — 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 u = Array.isArray(n);
-    const s = e.s === true;
+    const s = Array.isArray(n);
+    const u = e.s === true;
     const r = f;
     adoptPB(e, n, false);
-    if (s) markRawIngest(n);
-    if (Array.isArray(i) !== u) {
+    if (u) markRawIngest(n);
+    if (Array.isArray(i) !== s) {
         notifyFold(e, r, n);
         return;
     }
-    if (u) {
+    if (s) {
         const f = i;
-        const u = n;
+        const s = n;
         const a = e.n;
         let c = 0;
-        if (t && !s) {
+        if (t && !u) {
             const i = f.length;
-            const s = u.length;
+            const u = s.length;
             let d = false;
             let p = 0;
             // Aligned prefix: same row (by reference or key) at the same index.
-                        for (const y = Math.min(i, s); p < y; p++) {
-                const i = u[p];
-                const s = f[p];
-                if (s !== i && !(s !== null && typeof s === "object" && i !== null && typeof i === "object" && sameKey(t(s), t(i)))) break;
+                        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;
  // misaligned: fall to the keyed remainder below
-                                if ((s !== i || i !== null && typeof i === "object" && isOwned(i)) && i !== null && typeof i === "object") descend(unwrapValue(s), i, t, l, o);
-                if (e.dk !== null && !d && !(i !== null && typeof i === "object" ? targetsEqual(s, i) : isEqual(s, i))) {
+                                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))) {
                     bumpDeep(e);
                     d = true;
                 }
@@ -111,12 +113,12 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
                     }
                 }
             }
-            if (e.dk !== null && !d && p < u.length) bumpDeep(e);
+            if (e.dk !== null && !d && p < s.length) bumpDeep(e);
             const y = p;
  // misalignment point (== nlen on aligned ticks)
                         let w = null;
-            for (;p < u.length; p++) {
-                const e = u[p];
+            for (;p < s.length; p++) {
+                const e = s[p];
                 if (e !== null && typeof e === "object") {
                     const n = t(e);
                     let i;
@@ -156,12 +158,12 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
                 }
             }
         } else {
-            const i = Math.min(f.length, u.length);
-            const d = u.length;
+            const i = Math.min(f.length, s.length);
+            const d = s.length;
             let p = false;
             for (let y = 0; y < d; y++) {
-                const d = u[y];
-                if (!s && y < i && d !== null && typeof d === "object") descend(unwrapValue(f[y]), d, t, l, o);
+                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))) {
                     bumpDeep(e);
                     p = true;
@@ -179,7 +181,7 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
                 if (a !== null && c < e.nc) {
             for (const e of Reflect.ownKeys(a)) {
                 const t = typeof e === "string" ? +e : NaN;
-                if (!(t >= 0 && t < u.length)) notifyKeyDiff(a[e], e, r, n, false);
+                if (!(t >= 0 && t < s.length)) notifyKeyDiff(a[e], e, r, n, false);
             }
         }
         notifyFoldTail(e, r, n);
@@ -189,15 +191,15 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
     let c = 0;
     let d = false;
     for (const f in n) {
-        const u = n[f];
+        const s = n[f];
         const p = r[f];
-        const y = u !== null && typeof u === "object";
-        if (p === u && (!y || !isOwned(u)) && (a === null || a[f] === undefined || !hasAccessorFlag(a[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++;
             continue;
         }
-        if (y && !s) descend(unwrapValue(i[f]), u, t, l, o);
-        if (e.dk !== null && !d && !(y ? targetsEqual(p, u) : isEqual(p, u))) {
+        if (y && !u) descend(unwrapValue(i[f]), s, t, l, o);
+        if (e.dk !== null && !d && !(y ? targetsEqual(p, s) : isEqual(p, s))) {
             bumpDeep(e);
             d = true;
         }
@@ -205,7 +207,7 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
             const e = a[f];
             if (e !== undefined) {
                 c++;
-                notifyKeyValue(e, f, p, u, r, n);
+                notifyKeyValue(e, f, p, s, r, n);
             }
         }
     }
@@ -214,7 +216,7 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
         const f = p[e];
         if (f === $OWNER) continue;
         const i = n[f];
-        if (!s && i !== null && typeof i === "object") descend(unwrapValue(r[f]), i, t, l, o);
+        if (!u && i !== null && typeof i === "object") descend(unwrapValue(r[f]), i, t, l, o);
         if (a !== null) {
             const e = a[f];
             if (e !== undefined) {