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

package/dist/prod/store/optimistic.js

@@ -2,7 +2,7 @@ import { CONFIG_OVERRIDE, CONFIG_AUTO_DISPOSE, NOT_PENDING } from "../core/const
 
 import { computed, ext, untrack, read, isEqual } from "../core/core.js";
 
-import { pendingGuessOf, laneValueOf, optimisticWrite } from "../core/lanes.js";
+import { pendingGuessOf, optimisticWrite } from "../core/lanes.js";
 
 import { getOwner } from "../core/owner.js";
 
@@ -18,6 +18,8 @@ import { $OWNER } 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).
  *
@@ -81,7 +83,7 @@ function notifyOptimisticWrites(e, n) {
     // inner store's truth for its key before guessing over it.
         const o = e.ch ? e.v : null;
     const guess = (e, n, i, r) => {
-        if (o !== null) e.Ae = i ? n in t : unwrapValue(t[n]);
+        if (o !== null) e.Ie = i ? n in t : unwrapValue(t[n]);
         // By value: a function leaf is a value, not an updater (#3017).
                 optimisticWrite(e, () => r);
     };
@@ -185,7 +187,7 @@ function rowSame(e, n, t) {
 
 // A cycle (a row that references itself) is not plain data: no match, so
 // the landing stays a correction.
-GlobalQueue.tn = (e, n) => {
+GlobalQueue.nn = (e, n) => {
     try {
         return echoes(e, n);
     } catch {
@@ -267,9 +269,9 @@ function arrangementEqual(e, n, t) {
  * 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) => {
-    const t = e.lt;
-    if (t === undefined || e.ot !== $TRACK) return;
-    const i = e.m.B;
+    const t = e.O;
+    if (t === undefined || e.ze !== $TRACK) return;
+    const i = e.T.v;
     if (!(i instanceof LaneView)) return;
     if (!Array.isArray(n) || !Array.isArray(i.rows)) {
         i.base = n;
@@ -313,7 +315,7 @@ function arrangementEqual(e, n, t) {
         // key's new object is the same row, its target adopted it).
                 if (n === undefined) {
             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);
+        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.v : c[e], a[e], r)) laneSet(n, a[e], l);
     }
     if (d !== null) {
         for (let e = a.length; ;e++) {
@@ -322,7 +324,7 @@ function arrangementEqual(e, n, t) {
             laneSet(n, undefined, l);
         }
         const e = d.length;
-        if (e !== undefined && (e.i & CONFIG_OVERRIDE || c.length !== a.length)) laneSet(e, a.length, l);
+        if (e !== undefined && (e.l & CONFIG_OVERRIDE || c.length !== a.length)) laneSet(e, a.length, l);
     }
 };
 
@@ -337,12 +339,12 @@ 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.i & CONFIG_OVERRIDE)) {
-        e.i |= CONFIG_OVERRIDE;
+    if (!(e.l & CONFIG_OVERRIDE)) {
+        e.l |= CONFIG_OVERRIDE;
         list(e, t);
-    } else if (i.B === n) return;
-    i.B = n;
-    if (e.t !== null) {
+    } else if (i.v === n) return;
+    i.v = n;
+    if (e.o !== null) {
         insertSubs(e);
         laneDirty(e, t);
     }
@@ -387,7 +389,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.Ae instanceof LaneView) t.Ae = t.Ae.base;
+            if (t !== null && t.Ie instanceof LaneView) t.Ie = t.Ie.base;
         }
         if (n.size === 0) overlaidFamilies.delete(e);
     }
@@ -404,11 +406,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.ye && r.ye(r.Ae, o)) continue;
-        r.Ae = o;
+        if (r.xe && r.xe(r.Ie, o)) continue;
+        r.Ie = 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.qe !== notifyEpoch) {
+                if (r.o !== null && r.Me !== notifyEpoch) {
             insertSubs(r);
             t = true;
         }
@@ -417,9 +419,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.Ae === o) continue;
-        i.Ae = o;
-        if (i.t !== null && i.qe !== notifyEpoch) {
+        if (i.Ie === o) continue;
+        i.Ie = o;
+        if (i.o !== null && i.Me !== notifyEpoch) {
             insertSubs(i);
             t = true;
         }
@@ -427,9 +429,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.Ae instanceof LaneView && o.qe !== notifyEpoch) {
+    if (o !== null && o.o !== null && o.Ie instanceof LaneView && o.Me !== notifyEpoch) {
         const i = Array.isArray(n) ? untrack(() => n.map(unwrapValue)) : n;
-        if (!arrangementEqual(o.Ae.rows, i, e.fam?.key ?? null)) {
+        if (!arrangementEqual(o.Ie.rows, i, e.fam?.key ?? null)) {
             insertSubs(o);
             t = true;
         }
@@ -438,12 +440,12 @@ function sweepOverlaid() {
 }
 
 function carriesLane(e) {
-    if (e.k !== null && e.k.i & CONFIG_OVERRIDE) return true;
-    if (e.dk !== null && e.dk.i & CONFIG_OVERRIDE) return true;
+    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].i & CONFIG_OVERRIDE) return true;
+    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].i & CONFIG_OVERRIDE) return true;
+    if (t !== null) for (const e of Reflect.ownKeys(t)) if (t[e].l & CONFIG_OVERRIDE) return true;
     return false;
 }
 
@@ -461,9 +463,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.i & CONFIG_OVERRIDE) return !!shown(t);
+    if (t !== undefined && t.l & CONFIG_OVERRIDE) return !!shown(t);
     const i = e.n?.[n];
-    if (i !== undefined && i.i & CONFIG_OVERRIDE) return shown(i) !== undefined;
+    if (i !== undefined && i.l & CONFIG_OVERRIDE) return shown(i) !== undefined;
     return undefined;
 }
 
@@ -474,7 +476,7 @@ function overlaid(e) {
     if (t === undefined) return undefined;
     if (!t) return null;
     const i = e.n?.[n];
-    const r = i !== undefined && i.i & CONFIG_OVERRIDE ? shown(i) : e.v[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,
@@ -507,7 +509,7 @@ i = false) {
         for (const e of Reflect.ownKeys(o)) {
             const r = o[e];
             let s;
-            if (r.i & CONFIG_OVERRIDE) s = t(r); else if (!i || (s = pendingGuessOf(r)) === NOT_PENDING) continue;
+            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)) {
@@ -520,7 +522,7 @@ i = false) {
         for (const e of Reflect.ownKeys(s)) {
             const o = s[e];
             let a;
-            if (o.i & CONFIG_OVERRIDE) a = t(o); else if (!i || (a = pendingGuessOf(o)) === NOT_PENDING) continue;
+            if (o.l & 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];
@@ -532,7 +534,9 @@ i = false) {
 function createOptimisticStore(e, n, t) {
     const i = typeof e === "function";
     const r = i ? t : n;
-    const o = i ? n : e;
+    // 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 a = {
         map: new WeakMap,
@@ -557,7 +561,7 @@ function createOptimisticStore(e, n, t) {
             if (!a.node) a.node = getOwner();
             runProjectionComputed(f, n, s);
         }, t);
-        i.i &= ~CONFIG_AUTO_DISPOSE;
+        i.l &= ~CONFIG_AUTO_DISPOSE;
         a.node = i;
     }
     return [ f, e => storeSetter(f, e) ];

package/dist/prod/store/projection.js

@@ -10,7 +10,7 @@ import { enqueueSub } from "../core/heap.js";
 
 import { getOwner, isDisposed } from "../core/owner.js";
 
-import { question, setQuestion, schedule } from "../core/scheduler.js";
+import { question, setQuestion, insertSubs, schedule } from "../core/scheduler.js";
 
 import { reconcileState } from "./reconcile.js";
 
@@ -18,7 +18,7 @@ import { wrap, storeSetter, runDirect } from "./store.js";
 
 import { setLookup } from "./target.js";
 
-import { $TARGET, markRawIngest, setWriteOverride, isWrappable } from "./types.js";
+import { $TARGET, markRawIngest, isWrappable, setWriteOverride } from "./types.js";
 
 /**
  * Store — projections (plan sec. 31, S3; INTERNALS §7/§7b).
@@ -122,7 +122,7 @@ function cloneState(e, t) {
     const r = e.node;
     e.woke = true;
     forEachFamilyNode(e, e => {
-        if (e.t === null) return;
+        if (e.o === null) return;
         // The leaf carries the derive's pending as a propagated copy, as a memo
         // between them would: a dependent recovering one branch stays pending
         // through a leaf it still reads (core `retryReaches`), and the landing's
@@ -139,7 +139,7 @@ function cloneState(e, t) {
 /** The derive's flight rejected: every live reader of the family
  * re-derives (its pull throws the derive's error). */ function errorFamily(e) {
     forEachFamilyNode(e, e => {
-        if (e.t === null) return;
+        if (e.o === null) return;
         forEachDependent(e, e => {
             enqueueSub(e);
         });
@@ -154,7 +154,7 @@ function cloneState(e, t) {
     e.woke = false;
     const t = e.node;
     forEachFamilyNode(e, e => {
-        if (e.t !== null) settlePendingSource(e, t);
+        if (e.o !== null) settlePendingSource(e, t);
     });
 }
 
@@ -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.De ? cloneState(s.v, s.s) : null;
+        const a = i.ce ? cloneState(s.v, s.s) : null;
     // The question a write of this run answers: inside a slice, the slice's
     // (the sync pass); in a continuation — the flight still registered — the
     // flight's (`handleAsync` stamped it with the action that asked).
-        const asking = () => question || (i.m !== null && i.m.Te !== null ? i.m._e : 0);
+        const asking = () => question || (i.T !== null && i.T.Se !== null ? i.T.Ee : 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.S & STATUS_PENDING) && !i.De) schedule();
+        if (!(i.m & STATUS_PENDING) && !i.ce) 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,12 @@ function forEachFamilyNode(e, t) {
             }
             // A landing (not the sync pass's own commit): the readers held
             // pending on the derive settle.
-                        if (!d || !(i.S & STATUS_UNINITIALIZED)) settleFamily(c);
+                        if (!d || !(i.m & STATUS_UNINITIALIZED)) settleFamily(c);
+            // A commit is the derive's change for the readers that observed its
+            // flight (linked by `pullFamily`; a settled pull does not link), as
+            // a memo's landing is for its readers: one that caught the NotReady
+            // (a fallback value, not pending) re-runs too (#4070).
+                        insertSubs(i);
         };
         const u = handleAsync(i, l, commit, (e, t) => {
             // The flight rejected: the leaves' readers learn it from here —
@@ -228,10 +233,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.S & STATUS_UNINITIALIZED) return;
+            if (d && i.m & STATUS_UNINITIALIZED) return;
             if (t) wakeFamily(c, e); else errorFamily(c);
         });
-        if (!i.De) commit(u);
+        if (!i.ce) commit(u);
     }, false);
     try {
         d ? runDirect(pass) : pass();
@@ -248,11 +253,14 @@ function forEachFamilyNode(e, t) {
     // 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.S & STATUS_PENDING && i.m.Te !== null && !i.De && !d) wakeFamily(c, i.m?.F);
+        if (i.m & STATUS_PENDING && i.T.Se !== null && !i.ce && !d) wakeFamily(c, i.T?.F);
     return i;
 }
 
 function createProjectionInternal(e, t, r) {
+    // Seedless (`fn` takes no draft): the root starts as an empty record. It is
+    // a draft like any seed, never observable before the first landing (A25).
+    t ||= {};
     const n = r?.key === undefined ? "id" : r.key;
     const o = {
         map: new WeakMap,
@@ -276,20 +284,18 @@ function createProjectionInternal(e, t, r) {
         if (!o.node) o.node = getOwner();
         runProjectionComputed(i, e, n);
     }, s);
-    c.i &= ~CONFIG_AUTO_DISPOSE;
+    c.l &= ~CONFIG_AUTO_DISPOSE;
     o.node = c;
+    // The derive's leaves are not its dependents: a mark's repoll
+    // (affects-marks.ts) reaches their readers through this.
+        c.fam = o;
     return {
         store: i,
         node: c
     };
 }
 
-/**
- * A derived store: `fn` runs in a computed and writes its draft; readers of
- * the store's keys re-run only when the keys they read change (the
- * firewall). `fn` may be async or an async iterator; the seed is a draft,
- * never an observable value, until the first landing (A25).
- */ function createProjection(e, t, r) {
+function createProjection(e, t, r) {
     return createProjectionInternal(e, t, r).store;
 }