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

package/dist/prod/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, storeSetter, LaneView, committed, getNode, unwrapValue, sameKey, resolveChainedRaw, getHasNode, targetsEqual, getContainerNode, cloneRaw } from "./store.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 } from "./target.js";
+import { $OWNER, lookupTarget } from "./target.js";
 
 import { $TARGET, markRawIngest, $TRACK, isWrappable } from "./types.js";
 
@@ -93,17 +95,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 u = n[t];
-        const f = unwrapValue(o && u ? resolveChainedRaw(e, t, u) : u);
+                const f = n[t];
+        const a = unwrapValue(o && f ? resolveChainedRaw(e, t, f) : f);
         if (!(t in i)) {
-            guess(getNode(e, t), t, false, f);
+            guess(getNode(e, t), t, false, a);
             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)) {
-                guess(getNode(e, t), t, false, f);
+            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;
             }
         }
@@ -125,17 +127,17 @@ function notifyOptimisticWrites(e, n) {
         // 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 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]) ? u(o[n]) : undefined;
+                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) ? u(t) : undefined;
+                const r = isWrappable(t) ? f(t) : undefined;
                 if (r !== undefined && !e.has(r)) s.add(r);
             }
         }
@@ -143,10 +145,10 @@ function notifyOptimisticWrites(e, n) {
     }
     if (e.dk !== null) optimisticWrite(e.dk, {});
     markOverlaid(e);
-    const u = optStaged.get(e);
-    if (u === undefined) return null;
+    const f = optStaged.get(e);
+    if (f === undefined) return null;
     optStaged.delete(e);
-    return u;
+    return f;
 }
 
 /** The container comparator's lane arm (store.ts `containerEquals`): an
@@ -155,22 +157,24 @@ function notifyOptimisticWrites(e, n) {
     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);
+    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;
-    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 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
@@ -230,18 +234,18 @@ function arrangementEqual(e, n, t) {
             }
         }
         for (let s = 0; s < n.length; s++) {
-            const u = n[s];
-            let f;
-            if (isWrappable(u)) {
+            const f = n[s];
+            let a;
+            if (isWrappable(f)) {
                 if (o !== null) {
-                    const e = t(u);
-                    if (e !== undefined) f = o.get(e);
-                } else if (s < i && isWrappable(unwrapValue(r[s]))) f = r[s];
+                    const e = t(f);
+                    if (e !== undefined) a = o.get(e);
+                } else if (s < i && isWrappable(unwrapValue(r[s]))) a = r[s];
             }
-            if (f !== undefined) {
-                if (unwrapValue(f) !== u) reconcileDraft(f, u, t);
-                if (e[s] !== f) e[s] = f;
-            } else if (unwrapValue(e[s]) !== u) e[s] = u;
+            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;
@@ -257,6 +261,29 @@ function arrangementEqual(e, n, t) {
     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
@@ -270,10 +297,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.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.ze !== $TRACK) return;
+    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)) {
@@ -288,46 +315,46 @@ function arrangementEqual(e, n, t) {
         const i = isWrappable(t) ? o(t) : undefined;
         if (i !== undefined && !s.has(i)) s.set(i, t);
     }
-    const u = new Set;
-    const f = [];
-    const a = r.rows;
-    for (let e = 0; e < a.length; e++) {
-        const n = a[e];
+    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) {
-            f.push(i);
-            u.add(t);
-        } else f.push(n);
+            a.push(i);
+            f.add(t);
+        } else a.push(n);
     }
-    const l = r.removed;
+    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 && !u.has(i) && (l === null || !l.has(i))) f.push(t);
+        if (i !== undefined && !f.has(i) && (u === null || !u.has(i))) a.push(t);
     }
-    r.rows = f;
-    r.base = f;
+    r.rows = a;
+    r.base = a;
     const c = txOf(e);
     const d = committed(i);
     const p = i.n;
-    for (let e = 0; e < f.length; e++) {
+    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], f[e], o)) laneSet(getNode(i, e), f[e], c);
-        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.P : d[e], f[e], o)) laneSet(n, f[e], c);
+            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 = f.length; ;e++) {
+        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 !== f.length)) laneSet(e, f.length, c);
+        if (e !== undefined && (e.l & CONFIG_OVERRIDE || d.length !== a.length)) laneSet(e, a.length, c);
     }
 };
 
@@ -342,9 +369,9 @@ function arrangementEqual(e, n, t) {
     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.ge || !(t?.l & CONFIG_OVERRIDE) || !t.T.P?.removed) return false;
+        if (!i.Ue || !(t?.l & CONFIG_OVERRIDE) || !t.T.P?.removed) return false;
     const r = e.T.P;
-    if ((!e.xe || !e.xe(r, n)) && !GlobalQueue.nn(r, n)) {
+    if ((!e.ye || !e.ye(r, n)) && !GlobalQueue.nn(r, n)) {
         i.folded = foldedRead;
         insertSubs(e);
     } else GlobalQueue.sn?.(i);
@@ -365,8 +392,8 @@ 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) {
@@ -391,7 +418,28 @@ function sameRow(e, n, 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,
@@ -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
@@ -447,7 +539,7 @@ function sweepOverlaid() {
     if (i !== null) for (const e of Reflect.ownKeys(i)) {
         const r = i[e];
         const o = untrack(() => unwrapValue(n[e]));
-        if (r.xe && r.xe(r.le, o)) continue;
+        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.)
@@ -472,7 +564,7 @@ function sweepOverlaid() {
         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?.key ?? null)) {
+        if (!arrangementEqual(o.le.rows, i, 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.Ne === e.u.de) return t;
+    }
 }
 
 function overlaid(e) {
@@ -562,11 +658,11 @@ 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 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;
@@ -579,7 +675,7 @@ function createOptimisticStore(e, n, t) {
     // createProjectionInternal).
         const o = i ? n || {} : e;
     const s = r?.key === undefined ? "id" : r.key;
-    const u = {
+    const f = {
         map: new WeakMap,
         node: null,
         live: new Set,
@@ -587,9 +683,9 @@ function createOptimisticStore(e, n, t) {
         opt: true,
         key: typeof s === "function" ? s : s === null ? null : e => isWrappable(e) ? e[s] : undefined
     };
-    const f = wrap(o, null, null, u);
-    if (u.shallow) {
-        f[$TARGET].s = true;
+    const a = wrap(o, null, null, f);
+    if (f.shallow) {
+        a[$TARGET].s = true;
         markRawIngest(o);
     }
     if (i) {
@@ -599,13 +695,13 @@ function createOptimisticStore(e, n, t) {
             loadingValue: undefined
         };
         const i = computed(() => {
-            if (!u.node) u.node = getOwner();
-            runProjectionComputed(f, n, s);
+            if (!f.node) f.node = getOwner();
+            runProjectionComputed(a, n, s);
         }, t);
         i.l &= ~CONFIG_AUTO_DISPOSE;
-        u.node = i;
+        f.node = i;
     }
-    return [ f, e => storeSetter(f, e) ];
+    return [ a, e => storeSetter(a, e) ];
 }
 
 export { createOptimisticStore, notifyOptimisticWrites, optimisticHas, optimisticOwnDescriptor, optimisticView, sweepOverlaid };