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

package/dist/observe/store/optimistic.js

@@ -1,20 +1,22 @@
-import { CONFIG_OVERRIDE, CONFIG_GUESS, EFFECT_RENDER, CONFIG_CHILDREN_FORBIDDEN, NOT_PENDING, CONFIG_SLOT_NODE, CONFIG_AUTO_DISPOSE } from "../core/constants.js";
+import { CONFIG_GUESS, CONFIG_OVERRIDE, EFFECT_RENDER, CONFIG_CHILDREN_FORBIDDEN, NOT_PENDING, CONFIG_SLOT_NODE, CONFIG_AUTO_DISPOSE, REACTIVE_REASK } from "../core/constants.js";
 
-import { computed, joinPassAt, ext, untrack, read, isEqual } from "../core/core.js";
+import { computed, isEqual, joinPassAt, ext, untrack, read } from "../core/core.js";
 
-import { pendingGuessOf, optimisticWrite } from "../core/lanes.js";
+import { take, pendingGuessOf, optimisticWrite } from "../core/lanes.js";
 
 import { getOwner } from "../core/owner.js";
 
-import { GlobalQueue, txOf, insertSubs, joinFuture, resolveTx, passLane, list, laneDirty, notifyEpoch, schedule } from "../core/scheduler.js";
+import { GlobalQueue, txOf, insertSubs, joinFuture, resolveTx, passLane, list, laneDirty, clock, merge, notifyEpoch, schedule } from "../core/scheduler.js";
 
 import { runProjectionComputed } from "./projection.js";
 
-import { wrap, nameStore, storeSetter, LaneView, committed, getNode, unwrapValue, sameKey, resolveChainedRaw, getHasNode, targetsEqual, getContainerNode, cloneRaw } from "./store.js";
+import { reconcileState } from "./reconcile.js";
+
+import { wrap, nameStore, storeSetter, getContainerNode, getHasNode, getNode, LaneView, committed, unwrapValue, sameKey, resolveChainedRaw, targetsEqual, cloneRaw } from "./store.js";
 
 import { installOptHooks } from "./hooks.js";
 
-import { $OWNER } from "./target.js";
+import { $OWNER, lookupTarget } from "./target.js";
 
 import { $TARGET, markRawIngest, $TRACK, isWrappable } from "./types.js";
 
@@ -75,102 +77,104 @@ function notifyOptimisticWrites(e, n) {
     // The view the user saw: the committed frame (a staging adopted eagerly
     // is not it) with the lanes' values and the tick's own guesses over it.
     const t = writerBacking(e);
-    const i = optimisticView(e, t, laneValueOf, true);
-    const r = Array.isArray(n);
+    const r = optimisticView(e, t, laneValueOf, true);
+    const i = Array.isArray(n);
     // A chained target's nodes are links (§7b): their committed value is
     // never served and never learns the inner store's commits — yet a guess
     // is judged against it, and reverts to it (#3672). Hand the node the
     // 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.le = i ? n in t : unwrapValue(t[n]);
+    const guess = (e, n, r, i) => {
+        if (o !== null) e.le = r ? n in t : unwrapValue(t[n]);
         // By value: a function leaf is a value, not an updater (#3017).
-                optimisticWrite(e, () => r);
+                optimisticWrite(e, () => i);
     };
     let s = false;
     for (const t of Reflect.ownKeys(n)) {
-        if (r && t === "length" || t === $OWNER) continue;
+        if (i && t === "length" || t === $OWNER) continue;
         // 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 u = n[t];
-        const f = unwrapValue(o && u ? resolveChainedRaw(e, t, u) : u);
-        if (!(t in i)) {
+                const a = n[t];
+        const f = unwrapValue(o && a ? resolveChainedRaw(e, t, a) : a);
+        if (!(t in r)) {
             guess(getNode(e, t), t, false, f);
             guess(getHasNode(e, t), t, true, true);
             s = true;
         } else {
-            const n = i[t];
-            const u = unwrapValue(o && n ? resolveChainedRaw(e, t, n) : n);
-            if (!isEqual(u, f) && !targetsEqual(u, f)) {
+            const n = r[t];
+            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;
+                if (i) s = true;
             }
         }
     }
-    for (const t of Reflect.ownKeys(i)) {
-        if (r && t === "length" || t === $OWNER) continue;
+    for (const t of Reflect.ownKeys(r)) {
+        if (i && t === "length" || t === $OWNER) continue;
         if (t in n) continue;
         guess(getNode(e, t), t, false, undefined);
         guess(getHasNode(e, t), t, true, false);
         s = true;
     }
-    if (r && i.length !== n.length) {
+    if (i && r.length !== n.length) {
         guess(getNode(e, "length"), "length", false, n.length);
         s = true;
     }
     if (s) {
-        const o = r ? n.map(unwrapValue) : shallowKeys(n);
+        const o = i ? n.map(unwrapValue) : shallowKeys(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. A set
         // (empty or not) marks a keyed arrangement guess (`fold`).
                 let s = null;
-        const u = e.fam.key;
-        if (r && u !== null && u !== undefined) {
+        const a = e.fam.key;
+        if (i && a !== null && a !== undefined) {
             s = new Set;
             const e = new Set;
             for (let n = 0; n < o.length; n++) {
-                const t = isWrappable(o[n]) ? u(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) ? u(t) : undefined;
-                if (r !== undefined && !e.has(r)) s.add(r);
+            for (let n = 0; n < r.length; n++) {
+                const t = unwrapValue(r[n]);
+                const i = isWrappable(t) ? a(t) : undefined;
+                if (i !== undefined && !e.has(i)) s.add(i);
             }
         }
         optimisticWrite(getContainerNode(e), new LaneView(o, t, s));
     }
     if (e.dk !== null) optimisticWrite(e.dk, {});
     markOverlaid(e);
-    const u = optStaged.get(e);
-    if (u === undefined) return null;
+    const a = optStaged.get(e);
+    if (a === undefined) return null;
     optStaged.delete(e);
-    return u;
+    return a;
 }
 
 /** The container comparator's lane arm (store.ts `containerEquals`): an
  * arrangement guess (`LaneView`) against a landing or another arrangement,
  * by row identity — by key when the family has one. */ function arrangement(e, n, t) {
-    const i = n instanceof LaneView;
-    const r = t instanceof LaneView;
-    if (!i && !r) return false;
-    return arrangementEqual(i ? n.rows : n, r ? t.rows : t, e.fam?.key ?? null);
+    const r = n instanceof LaneView;
+    const i = t instanceof LaneView;
+    if (!r && !i) return false;
+    return arrangementEqual(r ? n.rows : n, i ? t.rows : t, e.fam);
 }
 
 function rowSame(e, n, t) {
     if (isEqual(e, n) || targetsEqual(e, n)) return true;
-    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);
+    const r = t.key;
+    if (!r || !isWrappable(e) || !isWrappable(n)) return false;
+    // A row the store already serves is its proxy's row: a reader (a list)
+    // holds that proxy, so another object at the index is another row, by key
+    // or contents alike — a guess's fresh object wraps a new proxy. A landing's
+    // object has been adopted by the row it pairs with, so it serves that
+    // row's proxy. Only rows no proxy serves yet pair by key, keyless rows by
+    // position — reconcile's fallback (#3898).
+        const i = lookupTarget(e = unwrapValue(e), t);
+    const o = lookupTarget(n = unwrapValue(n), t);
+    if (i || o) return i === o;
+    // (Two keyless rows: `undefined` is the same key.)
+        return sameKey(r(e), r(n));
 }
 
 /** Whether reconcile would write anything into `a` from `b`: wrappable
@@ -183,7 +187,7 @@ function rowSame(e, n, t) {
     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;
+    for (const r of t) if (!hasOwn.call(n, r) || !echoes(e[r], n[r])) return false;
     return true;
 }
 
@@ -201,13 +205,13 @@ function arrangementEqual(e, n, t) {
     if (Array.isArray(e) !== Array.isArray(n)) return false;
     if (Array.isArray(e)) {
         if (e.length !== n.length) return false;
-        for (let i = 0; i < e.length; i++) if (!rowSame(e[i], n[i], t)) return false;
+        for (let r = 0; r < e.length; r++) if (!rowSame(e[r], n[r], t)) return false;
         return true;
     }
-    const i = Reflect.ownKeys(e).filter(e => e !== $OWNER);
-    const r = Reflect.ownKeys(n).filter(e => e !== $OWNER);
-    if (i.length !== r.length) return false;
-    for (const e of i) if (!(e in n)) return false;
+    const r = Reflect.ownKeys(e).filter(e => e !== $OWNER);
+    const i = Reflect.ownKeys(n).filter(e => e !== $OWNER);
+    if (r.length !== i.length) return false;
+    for (const e of r) if (!(e in n)) return false;
     return true;
 }
 
@@ -216,47 +220,70 @@ function arrangementEqual(e, n, t) {
  * the matched row's draft; objects recurse into a wrappable pair, assign
  * otherwise; keys `incoming` lacks are deleted. */ function reconcileDraft(e, n, t) {
     if (Array.isArray(n)) {
-        const i = e.length;
-        const r = new Array(i);
-        for (let n = 0; n < i; n++) r[n] = e[n];
+        const r = e.length;
+        const i = new Array(r);
+        for (let n = 0; n < r; n++) i[n] = e[n];
         let o = null;
         if (t !== null) {
             o = new Map;
-            for (let e = 0; e < i; e++) {
-                const n = unwrapValue(r[e]);
+            for (let e = 0; e < r; e++) {
+                const n = unwrapValue(i[e]);
                 if (!isWrappable(n)) continue;
-                const i = t(n);
-                if (i !== undefined && !o.has(i)) o.set(i, r[e]);
+                const r = t(n);
+                if (r !== undefined && !o.has(r)) o.set(r, i[e]);
             }
         }
         for (let s = 0; s < n.length; s++) {
-            const u = n[s];
+            const a = n[s];
             let f;
-            if (isWrappable(u)) {
+            if (isWrappable(a)) {
                 if (o !== null) {
-                    const e = t(u);
+                    const e = t(a);
                     if (e !== undefined) f = o.get(e);
-                } else if (s < i && isWrappable(unwrapValue(r[s]))) f = r[s];
+                } else if (s < r && isWrappable(unwrapValue(i[s]))) f = i[s];
             }
             if (f !== undefined) {
-                if (unwrapValue(f) !== u) reconcileDraft(f, u, t);
+                if (unwrapValue(f) !== a) reconcileDraft(f, a, t);
                 if (e[s] !== f) e[s] = f;
-            } else if (unwrapValue(e[s]) !== u) e[s] = u;
+            } else if (unwrapValue(e[s]) !== a) e[s] = a;
         }
         if (e.length !== n.length) e.length = n.length;
         return;
     }
-    for (const i of Object.keys(n)) {
-        const r = n[i];
-        const o = e[i];
+    for (const r of Object.keys(n)) {
+        const i = n[r];
+        const o = e[r];
         const s = unwrapValue(o);
-        if (isWrappable(r) && isWrappable(s) && Array.isArray(r) === Array.isArray(s) && (t === null || Array.isArray(r) || sameKey(t(r), t(s)))) {
-            if (s !== r) reconcileDraft(o, r, t);
-        } else if (s !== r) e[i] = r;
+        if (isWrappable(i) && isWrappable(s) && Array.isArray(i) === Array.isArray(s) && (t === null || Array.isArray(i) || sameKey(t(i), t(s)))) {
+            if (s !== i) reconcileDraft(o, i, t);
+        } else if (s !== i) e[r] = i;
     }
     for (const t of Object.keys(e)) if (!(t in n)) delete e[t];
 }
 
+/** Core asks (lanes `laneWrite`): the family's derive, re-asking in a lane of
+ * another action than the one that guessed this slot, writes it — that
+ * lane's new question, which the guess (over the old one) does not answer:
+ * the slot is the lane's derivation from here (F-6, #4336; lanes
+ * `laneStage` for a node's own pass). */ GlobalQueue.fn = (e, n) => {
+    const t = e.O;
+    if (n) {
+        // The guess comes back (lanes `endLanes`): on the slot's node now — the
+        // node itself, or the one a read made after it was released.
+        const n = e.gt;
+        markOverlaid(t);
+        return n === $TRACK ? getContainerNode(t) : e.je === isEqual ? getHasNode(t, n) : getNode(t, n);
+    }
+    const r = t?.fam?.node?.T?.Je;
+    const i = txOf(e);
+    if (!r?.V || sameAction(r, i)) return false;
+    // The re-ask takes the target's guess whole: the slot is the lane's
+    // derivation; its other guessed slots show their truth in the lane's
+    // world (lanes `take`).
+        for (const n of nodesOf(t)) if (n?.l & CONFIG_GUESS && txOf(n) === i) take(n, r, n !== e);
+    return true;
+};
+
 /** Q-D (plan sec. 39): an OLDER question's truth landed beneath an arrangement
  * guess (`laneWrite` held it — another action's landing is not this guess's
  * answer). The guess is re-based over it: order from the guess, rows from
@@ -270,54 +297,54 @@ 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.an = (e, n, t) => {
+ * positionally — the guess stands as written (the documented residue). */ GlobalQueue.Nn = (e, n, t) => {
     if (!t) return fold(e, n);
-    const i = e.O;
-    if (i === undefined || e.Vt !== $TRACK) return;
-    const r = e.T.V;
-    if (!(r instanceof LaneView)) return;
-    if (!Array.isArray(n) || !Array.isArray(r.rows)) {
-        r.base = n;
+    const r = e.O;
+    if (r === undefined || e.gt !== $TRACK) return;
+    const i = e.T.V;
+    if (!(i instanceof LaneView)) return;
+    if (!Array.isArray(n) || !Array.isArray(i.rows)) {
+        i.base = n;
         return;
     }
-    const o = i.fam?.key ?? null;
+    const o = r.fam?.key ?? null;
     if (o === null) return;
     const s = new Map;
     for (let e = 0; e < n.length; e++) {
         const t = n[e];
-        const i = isWrappable(t) ? o(t) : undefined;
-        if (i !== undefined && !s.has(i)) s.set(i, t);
+        const r = isWrappable(t) ? o(t) : undefined;
+        if (r !== undefined && !s.has(r)) s.set(r, t);
     }
-    const u = new Set;
+    const a = new Set;
     const f = [];
-    const a = r.rows;
-    for (let e = 0; e < a.length; e++) {
-        const n = a[e];
+    const l = i.rows;
+    for (let e = 0; e < l.length; e++) {
+        const n = l[e];
         const t = isWrappable(n) ? o(n) : undefined;
-        const i = t !== undefined ? s.get(t) : undefined;
-        if (i !== undefined) {
-            f.push(i);
-            u.add(t);
+        const r = t !== undefined ? s.get(t) : undefined;
+        if (r !== undefined) {
+            f.push(r);
+            a.add(t);
         } else f.push(n);
     }
-    const l = r.removed;
+    const u = i.removed;
     for (let e = 0; e < n.length; e++) {
         const t = n[e];
-        const i = isWrappable(t) ? o(t) : undefined;
-        if (i !== undefined && !u.has(i) && (l === null || !l.has(i))) f.push(t);
+        const r = isWrappable(t) ? o(t) : undefined;
+        if (r !== undefined && !a.has(r) && (u === null || !u.has(r))) f.push(t);
     }
-    r.rows = f;
-    r.base = f;
+    i.rows = f;
+    i.base = f;
     const c = txOf(e);
-    const d = committed(i);
-    const p = i.n;
+    const d = committed(r);
+    const p = r.n;
     for (let e = 0; e < f.length; e++) {
         const n = p?.[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(d[e], f[e], o)) laneSet(getNode(i, e), f[e], c);
+            if (!sameRow(d[e], f[e], o)) laneSet(getNode(r, e), f[e], c);
         } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.V : d[e], f[e], o)) laneSet(n, f[e], c);
     }
     if (p !== null) {
@@ -339,16 +366,16 @@ function arrangementEqual(e, n, t) {
  * (A17): only truth readers are told. True: the lane stages the truth
  * beneath (`laneWrite`). */ function fold(e, n) {
     const t = e.O?.k;
-    const i = txOf(e);
+    const r = txOf(e);
     // A guess the screen never showed is void at the correction (D-34); a
     // 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.je || !e.je(r, n)) && !GlobalQueue.sn(r, n)) {
-        i.folded = foldedRead;
+        if (!r.Nt || !(t?.l & CONFIG_OVERRIDE) || !t.T.V?.removed) return false;
+    const i = e.T.V;
+    if ((!e.je || !e.je(i, n)) && !GlobalQueue.sn(i, n)) {
+        r.folded = foldedRead;
         insertSubs(e);
-    } else GlobalQueue.tn?.(i);
-    joinFuture(resolveTx(i._parent ?? i));
+    } else GlobalQueue.tn?.(r);
+    joinFuture(resolveTx(r._parent ?? r));
     return true;
 }
 
@@ -365,33 +392,54 @@ function arrangementEqual(e, n, t) {
         const t = txOf(n);
         joinPassAt(e, resolveTx(t._parent ?? t));
     }
-    if (n.ie !== NOT_PENDING) return n.ie;
-    return n.l & CONFIG_SLOT_NODE ? GlobalQueue.fn(n) : n.le;
+    if (n.ue !== NOT_PENDING) return n.ue;
+    return n.l & CONFIG_SLOT_NODE ? GlobalQueue.an(n) : n.le;
 }
 
 function sameRow(e, n, t) {
     if (e === n) return true;
     if (!isWrappable(e) || !isWrappable(n)) return false;
-    const i = t(unwrapValue(e));
-    return i !== undefined && sameKey(i, t(unwrapValue(n)));
+    const r = t(unwrapValue(e));
+    return r !== undefined && sameKey(r, t(unwrapValue(n)));
 }
 
 /** A composed value becomes the lane's on `node`: a guess re-based, or a
  * 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);
+    const r = ext(e);
     if (!(e.l & CONFIG_OVERRIDE)) {
         e.l |= CONFIG_OVERRIDE;
         list(e, t);
-    } else if (i.V === n) return;
-    i.V = n;
+    } else if (r.V === n) return;
+    r.V = n;
     if (e.o !== null) {
         insertSubs(e);
         laneDirty(e, t);
     }
 }
 
+/** D-34 for a per-key guess (#4329): the derive's draft wrote new objects
+ * over a target holding guessed rows (`d.length = 0; d.push(...rows)`, or
+ * `d.issues = rows`). The container on the way down to each guessed row
+ * reconciles the new object at its slot — in a keyed list, the one with
+ * the row's key — exactly as a returned landing would: rows match by key,
+ * a guessed row keeps its target, and its leaves are judged against their
+ * guesses. Rows nothing guessed are left as the draft wrote them. */ function pairRows(e, n) {
+    const t = e.fam.key;
+    for (let r of e.fam.overlaid ?? []) {
+        // The guessed row, or its ancestor directly under `t` (none: skip).
+        while (r.u !== e) if ((r = r.u) === null) break;
+        if (r === null) continue;
+        const i = t?.(r.v);
+        const o = Array.isArray(n) ? i !== undefined && n.find(e => isWrappable(e) && sameKey(t(e), i)) : n[r.pk];
+        // A new object only: not `c`'s own, nor one another row serves
+        // (pairing it would alias the two).
+                if (isWrappable(o) && !lookupTarget(o, e.fam)) reconcileState(o, r.px, t, true);
+    }
+}
+
 installOptHooks({
+    pair: pairRows,
     draft: optimisticDraft,
     writes: notifyOptimisticWrites,
     arrangement: arrangement,
@@ -399,9 +447,53 @@ installOptHooks({
     view: (e, n, t = false) => t ? optimisticView(e, n, laneValueOf, true) : optimisticView(e, n),
     has: optimisticHas,
     descriptor: optimisticOwnDescriptor,
-    sweep: sweepOverlaid
+    sweep: sweepOverlaid,
+    // A new question (not a `refresh()`) asked over guesses an earlier frame
+    // opened, which answer the old one (D-34, #4336). Stamped on `fam.asked`
+    // with this flush's `clock`, so it lapses when the flush ends: `clock + 1`
+    // from mainline over a live guess — a frame still reading a guess at the
+    // seam shows it beside the new input, so the flush holds with the guess's
+    // action (`park`); `~clock` from a lane with no guess of its own, or with
+    // no live guess left — the lane waits for its answer (F-6), as for a
+    // guessed `createOptimistic` (lanes `laneStage`). The guess's own lane
+    // asks nothing new and stamps nothing.
+    ask: e => {
+        if (e.node.R & REACTIVE_REASK || !e.overlaid?.size) return;
+        // Stamped with the flush (`clock`): it lapses when the flush ends.
+                let n = ~clock;
+        for (const t of e.overlaid) {
+            const e = laneNodeOf(t);
+            if (e) {
+                if (passLane === null) n = clock + 1; else if (sameAction(txOf(e), passLane)) return;
+            }
+        }
+        if ((e.asked = n) > 0) joinFuture(null);
+    },
+    // Over a new question the guesses do not answer (`asked`): from mainline
+    // only a target carrying a guess stands in — a read of one with none is an
+    // ordinary pending read (F-2), so a keyed store's other keys wait for their
+    // answer, not for the guess's action; in a lane with no guess of its own,
+    // or with no live guess left, none does (F-6).
+    stands: e => {
+        const n = e.fam.overlaid;
+        const t = e.fam.asked;
+        return !!n?.size && (t !== clock + 1 || passLane !== null || n.has(e)) && t !== ~clock;
+    },
+    // Mainline hold (`clock + 1`): the flush joins the action of each guess a
+    // reader still reads at the seam; a reader that moved off it (a keyed
+    // store's other key) holds nothing.
+    park: e => {
+        for (const n of overlaidFamilies) if (n.asked === clock + 1) for (const t of n.overlaid) {
+            const n = laneNodeOf(t, true);
+            if (n) merge(txOf(n)._parent, e);
+        }
+    }
 });
 
+/** Two lanes of one action (their parents resolved through merges). */ function sameAction(e, n) {
+    return resolveTx(e._parent) === resolveTx(n._parent);
+}
+
 function shallowKeys(e) {
     const n = {};
     for (const t of Reflect.ownKeys(e)) if (t !== $OWNER) n[t] = unwrapValue(e[t]);
@@ -424,7 +516,7 @@ function sweepOverlaid() {
     if (overlaidFamilies.size === 0) return;
     for (const e of overlaidFamilies) {
         const n = e.overlaid;
-        for (const e of n) if (!carriesLane(e)) {
+        for (const e of n) if (!laneNodeOf(e)) {
             n.delete(e);
             if (e.ch) rebaseChained(e);
             // The container shows its backing again (a shown arrangement guess
@@ -443,36 +535,36 @@ function sweepOverlaid() {
  * re-derive the readers whose shown value it is not. */ function rebaseChained(e) {
     const n = e.v;
     let t = false;
-    const i = e.n;
-    if (i !== null) for (const e of Reflect.ownKeys(i)) {
-        const r = i[e];
+    const r = e.n;
+    if (r !== null) for (const e of Reflect.ownKeys(r)) {
+        const i = r[e];
         const o = untrack(() => unwrapValue(n[e]));
-        if (r.je && r.je(r.le, o)) continue;
-        r.le = o;
+        if (i.je && i.je(i.le, o)) continue;
+        i.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) {
-            insertSubs(r);
+                if (i.o !== null && i.Dt !== notifyEpoch) {
+            insertSubs(i);
             t = true;
         }
     }
-    const r = e.h;
-    if (r !== null) for (const e of Reflect.ownKeys(r)) {
-        const i = r[e];
+    const i = e.h;
+    if (i !== null) for (const e of Reflect.ownKeys(i)) {
+        const r = i[e];
         const o = untrack(() => e in n);
-        if (i.le === o) continue;
-        i.le = o;
-        if (i.o !== null && i.Ot !== notifyEpoch) {
-            insertSubs(i);
+        if (r.le === o) continue;
+        r.le = o;
+        if (r.o !== null && r.Dt !== notifyEpoch) {
+            insertSubs(r);
             t = true;
         }
     }
     // 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.le instanceof LaneView && o.Ot !== notifyEpoch) {
-        const i = Array.isArray(n) ? untrack(() => n.map(unwrapValue)) : n;
-        if (!arrangementEqual(o.le.rows, i, e.fam?.key ?? null)) {
+    if (o !== null && o.o !== null && o.le instanceof LaneView && o.Dt !== notifyEpoch) {
+        const r = Array.isArray(n) ? untrack(() => n.map(unwrapValue)) : n;
+        if (!arrangementEqual(o.le.rows, r, e.fam)) {
             insertSubs(o);
             t = true;
         }
@@ -480,14 +572,18 @@ function sweepOverlaid() {
     if (t) schedule();
 }
 
-function carriesLane(e) {
-    if (e.k !== null && e.k.l & CONFIG_OVERRIDE) return true;
-    if (e.dk !== null && e.dk.l & CONFIG_OVERRIDE) return true;
-    const n = e.n;
-    if (n !== null) for (const e of Reflect.ownKeys(n)) if (n[e].l & CONFIG_OVERRIDE) return true;
-    const t = e.h;
-    if (t !== null) for (const e of Reflect.ownKeys(t)) if (t[e].l & CONFIG_OVERRIDE) return true;
-    return false;
+/** `t`'s nodes (a missing container or deep node: null). */ function nodesOf(e) {
+    const n = [ e.k, e.dk ];
+    for (const t of [ e.n, e.h ]) if (t !== null) for (const e of Reflect.ownKeys(t)) n.push(t[e]);
+    return n;
+}
+
+/** A node of `t` carrying a lane value, if any (`read`: one a reader's
+ * last pass read). */ function laneNodeOf(e, n) {
+    for (const t of nodesOf(e)) if (t?.l & CONFIG_OVERRIDE) {
+        if (!n) return t;
+        for (let e = t.o; e !== null; e = e.t) if (e.de === e.u.Ne) return t;
+    }
 }
 
 function overlaid(e) {
@@ -505,8 +601,8 @@ function overlaid(e) {
     if (!overlaid(e)) return undefined;
     const t = e.h?.[n];
     if (t !== undefined && t.l & CONFIG_OVERRIDE) return !!shown(t);
-    const i = e.n?.[n];
-    if (i !== undefined && i.l & CONFIG_OVERRIDE) return shown(i) !== undefined;
+    const r = e.n?.[n];
+    if (r !== undefined && r.l & CONFIG_OVERRIDE) return shown(r) !== undefined;
     return undefined;
 }
 
@@ -516,17 +612,17 @@ function overlaid(e) {
     const t = optimisticHas(e, n);
     if (t === undefined) return undefined;
     if (!t) return null;
-    const i = e.n?.[n];
-    const r = i !== undefined && i.l & CONFIG_OVERRIDE ? shown(i) : e.v[n];
+    const r = e.n?.[n];
+    const i = r !== undefined && r.l & CONFIG_OVERRIDE ? shown(r) : 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,
+        value: i,
         writable: true,
         enumerable: false,
         configurable: false
     };
     return {
-        value: r,
+        value: i,
         writable: true,
         enumerable: true,
         configurable: true
@@ -539,18 +635,18 @@ function overlaid(e) {
  * length. Returns `src` itself when nothing is overlaid. */ function optimisticView(e, n, t = shown, 
 // The writer's view: the unflushed guesses too (on nodes that are no
 // lane's yet) — what the next write composes on (#3665).
-i = false) {
-    if (!i && !overlaid(e)) return n;
-    let r = null;
-    const ensure = () => r ??= Array.isArray(n) ? [ ...n ] : {
+r = false) {
+    if (!r && !overlaid(e)) return n;
+    let i = null;
+    const ensure = () => i ??= Array.isArray(n) ? [ ...n ] : {
         ...n
     };
     const o = e.n;
     if (o !== null) {
         for (const e of Reflect.ownKeys(o)) {
-            const r = o[e];
+            const i = o[e];
             let s;
-            if (r.l & CONFIG_OVERRIDE) s = t(r); else if (!i || (s = pendingGuessOf(r)) === NOT_PENDING) continue;
+            if (i.l & CONFIG_OVERRIDE) s = t(i); else if (!r || (s = pendingGuessOf(i)) === 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)) {
@@ -562,54 +658,54 @@ i = false) {
     if (s !== null) {
         for (const e of Reflect.ownKeys(s)) {
             const o = s[e];
-            let u;
-            if (o.l & CONFIG_OVERRIDE) u = t(o); else if (!i || (u = pendingGuessOf(o)) === NOT_PENDING) continue;
-            const f = !!u;
-            const a = r ?? n;
-            if (!f && e in a) delete ensure()[e];
+            let a;
+            if (o.l & CONFIG_OVERRIDE) a = t(o); else if (!r || (a = pendingGuessOf(o)) === NOT_PENDING) continue;
+            const f = !!a;
+            const l = i ?? n;
+            if (!f && e in l) delete ensure()[e];
         }
     }
-    return r ?? n;
+    return i ?? n;
 }
 
 function createOptimisticStore(e, n, t) {
-    const i = typeof e === "function";
-    const r = i ? t : n;
+    const r = typeof e === "function";
+    const i = r ? t : n;
     // Seedless derived form: the root starts as an empty record (see
     // createProjectionInternal).
-        const o = i ? n || {} : e;
-    const s = r?.key === undefined ? "id" : r.key;
-    const u = {
+        const o = r ? n || {} : e;
+    const s = i?.key === undefined ? "id" : i.key;
+    const a = {
         map: new WeakMap,
         node: null,
         live: new Set,
-        shallow: !!r?.shallow,
+        shallow: !!i?.shallow,
         opt: true,
         key: typeof s === "function" ? s : s === null ? null : e => isWrappable(e) ? e[s] : undefined
     };
-    const f = wrap(o, null, null, u);
-    nameStore(f, r?.name, r?.loc);
-    if (u.shallow) {
+    const f = wrap(o, null, null, a);
+    nameStore(f, i?.name, i?.loc);
+    if (a.shallow) {
         f[$TARGET].s = true;
         markRawIngest(o);
     }
-    if (i) {
+    if (r) {
         const n = e;
         let t;
-        if (r?.seedLoadingValue) t = {
+        if (i?.seedLoadingValue) t = {
             loadingValue: undefined
         };
-        if (r?.name || r?.loc) t = {
+        if (i?.name || i?.loc) t = {
             ...t,
-            name: r.name,
-            loc: r.loc
+            name: i.name,
+            loc: i.loc
         };
-        const i = computed(() => {
-            if (!u.node) u.node = getOwner();
+        const r = computed(() => {
+            if (!a.node) a.node = getOwner();
             runProjectionComputed(f, n, s);
         }, t);
-        i.l &= ~CONFIG_AUTO_DISPOSE;
-        u.node = i;
+        r.l &= ~CONFIG_AUTO_DISPOSE;
+        a.node = r;
     }
     return [ f, e => storeSetter(f, e) ];
 }