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

package/dist/prod/store/optimistic.js

@@ -0,0 +1,707 @@
+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, isEqual, joinPassAt, ext, untrack, read } from "../core/core.js";
+
+import { take, pendingGuessOf, optimisticWrite } from "../core/lanes.js";
+
+import { getOwner } from "../core/owner.js";
+
+import { GlobalQueue, txOf, insertSubs, joinFuture, resolveTx, passLane, list, laneDirty, clock, merge, notifyEpoch, schedule } from "../core/scheduler.js";
+
+import { runProjectionComputed } from "./projection.js";
+
+import { reconcileState } from "./reconcile.js";
+
+import { wrap, storeSetter, getContainerNode, getHasNode, getNode, LaneView, committed, unwrapValue, sameKey, resolveChainedRaw, targetsEqual, cloneRaw } from "./store.js";
+
+import { installOptHooks } from "./hooks.js";
+
+import { $OWNER, lookupTarget } from "./target.js";
+
+import { $TARGET, markRawIngest, $TRACK, isWrappable } from "./types.js";
+
+import { laneValueOf } from "../core/truth.js";
+
+/**
+ * Store — optimistic stores on lanes (plan sec. 31, S4; INTERNALS §3/§7, RUL-3).
+ *
+ * No store-side layer, no backup snapshots, no retaining ledger: a user
+ * write to an optimistic store is a GUESS on the written key's node
+ * (`optimisticWrite` — the same write `createOptimistic`'s setter makes),
+ * a presence guess on its presence node, and, when membership or
+ * arrangement changed, an arrangement guess on the container node. Lanes
+ * do the rest: the guess shows under the action's hold, a landing beneath
+ * it stages as truth and confirms it when equal (A18/A24), the action's
+ * settle dissolves it (a revert to the value it covered, or the landed
+ * truth). The committed backing is never touched by a guess.
+ *
+ * Reads compose: a reader of an overlaid target sees the truth it is served
+ * with the lanes' values over it (`optimisticView` — per node, by the same
+ * rule a leaf read follows: what the lane shows).
+ *
+ * Landings (Q-D, plan sec. 31.7): the derive's output is reconciled against the
+ * optimistic VIEW — a row the guess added and the server returns with the
+ * same key in the same position keeps its proxy (the row target adopts the
+ * server object), its leaves write truth beneath their guesses, and the
+ * container's arrangement guess is confirmed silently (`LaneView`'s
+ * comparator) — `For` does not run. Retained-setter replay (the
+ * 2026-08-31b continuation half) is not built here; the matrix decides.
+ */ const hasOwn = Object.prototype.hasOwnProperty;
+
+/** A user setter's writes on an optimistic family, as guesses: one per
+ * changed key's leaf, one per presence change, the container's arrangement
+ * when membership or order changed. `pb` is the draft (a clone of the view
+ * the user saw); `old` the view it composed on. */
+/** An optimistic setter's targets whose staging was set aside (`draft`),
+ * restored when the setter's writes become guesses (`writes`). */ const optStaged = new Map;
+
+// A chained backing is a proxy: reading it as a handler can expose a
+// derived store's staging. Compose the writer's view on the committed
+// backing of each link, retaining any optimistic guesses on that link.
+function writerBacking(e) {
+    const n = committed(e);
+    const t = n[$TARGET];
+    return t === undefined ? n : optimisticView(t, writerBacking(t), laneValueOf, true);
+}
+
+/** The user's draft on an optimistic family: a clone of the view the user
+ * saw — the committed frame with the lanes' values and the tick's own
+ * unflushed guesses over it (#3665). A staging already on the target (a
+ * landing adopted this flush) is set aside for the setter's duration: the
+ * guesses go over it, it stays the truth beneath. */ function optimisticDraft(e) {
+    if (e.pb !== null) optStaged.set(e, e.pb);
+    return cloneRaw(optimisticView(e, writerBacking(e), laneValueOf, true), e);
+}
+
+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);
+    // 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]);
+        // By value: a function leaf is a value, not an updater (#3017).
+                optimisticWrite(e, () => r);
+    };
+    let s = false;
+    for (const t of Reflect.ownKeys(n)) {
+        if (r && 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 f = n[t];
+        const a = unwrapValue(o && f ? resolveChainedRaw(e, t, f) : f);
+        if (!(t in i)) {
+            guess(getNode(e, t), t, false, a);
+            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);
+                if (r) s = true;
+            }
+        }
+    }
+    for (const t of Reflect.ownKeys(i)) {
+        if (r && 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) {
+        guess(getNode(e, "length"), "length", false, n.length);
+        s = true;
+    }
+    if (s) {
+        const o = r ? 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 f = e.fam.key;
+        if (r && f !== null && f !== undefined) {
+            s = new Set;
+            const e = new Set;
+            for (let n = 0; n < o.length; n++) {
+                const t = isWrappable(o[n]) ? f(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;
+                if (r !== undefined && !e.has(r)) s.add(r);
+            }
+        }
+        optimisticWrite(getContainerNode(e), new LaneView(o, t, s));
+    }
+    if (e.dk !== null) optimisticWrite(e.dk, {});
+    markOverlaid(e);
+    const f = optStaged.get(e);
+    if (f === undefined) return null;
+    optStaged.delete(e);
+    return f;
+}
+
+/** 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);
+}
+
+function rowSame(e, n, t) {
+    if (isEqual(e, n) || targetsEqual(e, n)) return true;
+    const i = t.key;
+    if (!i || !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 r = lookupTarget(e = unwrapValue(e), t);
+    const o = lookupTarget(n = unwrapValue(n), t);
+    if (r || o) return r === o;
+    // (Two keyless rows: `undefined` is the same key.)
+        return sameKey(i(e), i(n));
+}
+
+/** 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.nn = (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)) {
+        if (e.length !== n.length) return false;
+        for (let i = 0; i < e.length; i++) if (!rowSame(e[i], n[i], 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;
+    return true;
+}
+
+/** Write `incoming` into the draft `draft` (a store proxy inside a user's
+ * setter): arrays match rows by key (position when unkeyed) and recurse into
+ * 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];
+        let o = null;
+        if (t !== null) {
+            o = new Map;
+            for (let e = 0; e < i; e++) {
+                const n = unwrapValue(r[e]);
+                if (!isWrappable(n)) continue;
+                const i = t(n);
+                if (i !== undefined && !o.has(i)) o.set(i, r[e]);
+            }
+        }
+        for (let s = 0; s < n.length; s++) {
+            const f = n[s];
+            let a;
+            if (isWrappable(f)) {
+                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];
+            }
+            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 (e.length !== n.length) e.length = n.length;
+        return;
+    }
+    for (const i of Object.keys(n)) {
+        const r = n[i];
+        const o = e[i];
+        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;
+    }
+    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.Xe;
+        markOverlaid(t);
+        return n === $TRACK ? getContainerNode(t) : e.ye === isEqual ? getHasNode(t, n) : getNode(t, n);
+    }
+    const i = t?.fam?.node?.T?.Re;
+    const r = txOf(e);
+    if (!i?.P || sameAction(i, r)) 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) === r) take(n, i, 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
+ * the truth by key (a guessed row the truth has is the truth's object — the
+ * row target adopted it, its proxy survives), guessed rows the truth lacks
+ * kept (the guess's own landing judges them), truth rows the guess lacks
+ * appended. The composed arrangement becomes the lane's value on every
+ * index whose row the committed backing does not already show — compared
+ * BY KEY, never by raw identity: the same key's new object is the same row
+ * (its target adopted it) and the slot stays the committed backing's — (a
+ * 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.Nn = (e, n, t) => {
+    if (!t) return fold(e, n);
+    const i = e.O;
+    if (i === undefined || e.Xe !== $TRACK) return;
+    const r = e.T.P;
+    if (!(r instanceof LaneView)) return;
+    if (!Array.isArray(n) || !Array.isArray(r.rows)) {
+        r.base = n;
+        return;
+    }
+    const o = i.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 f = new Set;
+    const a = [];
+    const l = r.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) {
+            a.push(i);
+            f.add(t);
+        } else a.push(n);
+    }
+    const u = r.removed;
+    for (let e = 0; e < n.length; e++) {
+        const t = n[e];
+        const i = isWrappable(t) ? o(t) : undefined;
+        if (i !== undefined && !f.has(i) && (u === null || !u.has(i))) a.push(t);
+    }
+    r.rows = a;
+    r.base = a;
+    const c = txOf(e);
+    const d = committed(i);
+    const p = i.n;
+    for (let e = 0; e < a.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], a[e], o)) laneSet(getNode(i, e), a[e], c);
+        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.P : d[e], a[e], o)) laneSet(n, a[e], c);
+    }
+    if (p !== null) {
+        for (let e = a.length; ;e++) {
+            const n = p[e];
+            if (n === undefined) break;
+            laneSet(n, undefined, c);
+        }
+        const e = p.length;
+        if (e !== undefined && (e.l & CONFIG_OVERRIDE || d.length !== a.length)) laneSet(e, a.length, c);
+    }
+};
+
+/** D-34 for a keyed arrangement guess: rows by key, not positions. A
+ * current truth that differs folds into the hold beneath it instead of
+ * voiding the lane: the guess stays the lane's value and the screen's until
+ * the hold commits, where rows match by key, and the graph outside the lane
+ * re-derives from the truth now (`foldedRead`). A confirmation is silent
+ * (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);
+    // 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.Ue || !(t?.l & CONFIG_OVERRIDE) || !t.T.P?.removed) return false;
+    const r = e.T.P;
+    if ((!e.ye || !e.ye(r, n)) && !GlobalQueue.nn(r, n)) {
+        i.folded = foldedRead;
+        insertSubs(e);
+    } else GlobalQueue.sn?.(i);
+    joinFuture(resolveTx(i._parent ?? i));
+    return true;
+}
+
+/** A folded lane's guess read by a deriving pass outside the lane, tracked
+ * or not (`untrack` is about dependencies, not about which world a pass
+ * derives from), or by `latest()` (`c` null): the hold's world — the truth
+ * staged beneath the guess, else the value it covered — and the pass joins
+ * the hold. Lane passes and the screen keep the guess: held truth is masked
+ * from lane passes only (#3164). The store's own derive reconciles its
+ * landings against the arrangement the guesses made: it is the author, not
+ * a reader. */ function foldedRead(e, n) {
+    if (e !== null) {
+        if (!(n.l & CONFIG_GUESS) || passLane !== null || e.i === EFFECT_RENDER || e.l & CONFIG_CHILDREN_FORBIDDEN || n.O?.fam?.node === e) return NOT_PENDING;
+        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.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)));
+}
+
+/** 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);
+    if (!(e.l & CONFIG_OVERRIDE)) {
+        e.l |= CONFIG_OVERRIDE;
+        list(e, t);
+    } else if (i.P === n) return;
+    i.P = 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 i of e.fam.overlaid ?? []) {
+        // The guessed row, or its ancestor directly under `t` (none: skip).
+        while (i.u !== e) if ((i = i.u) === null) break;
+        if (i === null) continue;
+        const r = t?.(i.v);
+        const o = Array.isArray(n) ? r !== undefined && n.find(e => isWrappable(e) && sameKey(t(e), r)) : n[i.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, i.px, t, true);
+    }
+}
+
+installOptHooks({
+    pair: pairRows,
+    draft: optimisticDraft,
+    writes: notifyOptimisticWrites,
+    arrangement: arrangement,
+    reconcile: reconcileDraft,
+    view: (e, n, t = false) => t ? optimisticView(e, n, laneValueOf, true) : optimisticView(e, n),
+    has: optimisticHas,
+    descriptor: optimisticOwnDescriptor,
+    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]);
+    return n;
+}
+
+/** Families with a target carrying a lane value — swept at the flush's
+ * commit (`sweepOverlaid`): a target none of whose nodes is a lane's any
+ * more leaves its family's `overlaid`. (Not on the read path: a guess is
+ * pending between the setter and the seam, and a read in between must not
+ * take the target for clean.) */ const overlaidFamilies = new Set;
+
+function markOverlaid(e) {
+    const n = e.fam;
+    (n.overlaid ??= new Set).add(e);
+    overlaidFamilies.add(n);
+}
+
+function sweepOverlaid() {
+    if (overlaidFamilies.size === 0) return;
+    for (const e of overlaidFamilies) {
+        const n = e.overlaid;
+        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
+            // that ended without a landing left its `LaneView` as the value).
+                        const t = e.k;
+            if (t !== null && t.le instanceof LaneView) t.le = t.le.base;
+        }
+        if (n.size === 0) overlaidFamilies.delete(e);
+    }
+}
+
+/** A chained view's lanes ended: its nodes are links (§7b) whose committed
+ * value is the inner store's at the guess, not now — the inner may have
+ * moved underneath the guess (the base committed while the view showed
+ * its arrangement, #3672/F1). Re-base each node on the inner's truth and
+ * 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 o = untrack(() => unwrapValue(n[e]));
+        if (r.ye && r.ye(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.Me !== notifyEpoch) {
+            insertSubs(r);
+            t = true;
+        }
+    }
+    const r = e.h;
+    if (r !== null) for (const e of Reflect.ownKeys(r)) {
+        const i = r[e];
+        const o = untrack(() => e in n);
+        if (i.le === o) continue;
+        i.le = o;
+        if (i.o !== null && i.Me !== notifyEpoch) {
+            insertSubs(i);
+            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.Me !== notifyEpoch) {
+        const i = Array.isArray(n) ? untrack(() => n.map(unwrapValue)) : n;
+        if (!arrangementEqual(o.le.rows, i, e.fam)) {
+            insertSubs(o);
+            t = true;
+        }
+    }
+    if (t) schedule();
+}
+
+/** `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.Ne === e.u.de) return t;
+    }
+}
+
+function overlaid(e) {
+    const n = e.fam;
+    return n !== null && n.opt === true && n.overlaid !== undefined && n.overlaid.has(e);
+}
+
+/** What a lane node shows an untracked reader here: core's rule (`read`
+ * without a link — the lane's world inside its own pass, the screen
+ * outside, a verdict window's answer under one). */ const shown = e => untrack(() => read(e));
+
+/** An untracked `key in store` on an optimistic family: the presence guess
+ * (what its lane shows) when the key carries one; `undefined` when not —
+ * the backing answers. */ function optimisticHas(e, n) {
+    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;
+    return undefined;
+}
+
+/** A descriptor read of a guessed key: synthesized from the lane's value
+ * (`null`: the guess removed the key; `undefined`: no guess — the backing
+ * describes it). */ function optimisticOwnDescriptor(e, n) {
+    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];
+    // An array's `length` is reported as the array has it (non-configurable).
+        if (n === "length" && Array.isArray(e.v)) return {
+        value: r,
+        writable: true,
+        enumerable: false,
+        configurable: false
+    };
+    return {
+        value: r,
+        writable: true,
+        enumerable: true,
+        configurable: true
+    };
+}
+
+/** The truth `src` with the target's lane values over it: each overlaid
+ * leaf's value (`pick`: what the lane shows, or — for `latest` — the lane's
+ * latest), each presence guess as a key added or removed, the array
+ * 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 ] : {
+        ...n
+    };
+    const o = e.n;
+    if (o !== null) {
+        for (const e of Reflect.ownKeys(o)) {
+            const r = o[e];
+            let s;
+            if (r.l & 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)) {
+                ensure()[e] = s;
+            }
+        }
+    }
+    const s = e.h;
+    if (s !== null) {
+        for (const e of Reflect.ownKeys(s)) {
+            const o = s[e];
+            let f;
+            if (o.l & 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];
+        }
+    }
+    return r ?? n;
+}
+
+function createOptimisticStore(e, n, t) {
+    const i = typeof e === "function";
+    const r = i ? 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 f = {
+        map: new WeakMap,
+        node: null,
+        live: new Set,
+        shallow: !!r?.shallow,
+        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;
+        markRawIngest(o);
+    }
+    if (i) {
+        const n = e;
+        let t;
+        if (r?.seedLoadingValue) t = {
+            loadingValue: undefined
+        };
+        const i = computed(() => {
+            if (!f.node) f.node = getOwner();
+            runProjectionComputed(a, n, s);
+        }, t);
+        i.l &= ~CONFIG_AUTO_DISPOSE;
+        f.node = i;
+    }
+    return [ a, e => storeSetter(a, e) ];
+}
+
+export { createOptimisticStore, notifyOptimisticWrites, optimisticHas, optimisticOwnDescriptor, optimisticView, sweepOverlaid };