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

package/dist/observe/store/projection.js

@@ -1,3 +1,5 @@
+import { attrHooks } from "../core/attribution-hooks.js";
+
 import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, STATUS_UNINITIALIZED } from "../core/constants.js";
 
 import { computed } from "../core/core.js";
@@ -10,15 +12,15 @@ 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";
 
 import { wrap, nameStore, storeSetter, runDirect } from "./store.js";
 
-import { setLookup } from "./target.js";
+import { storeOwners, setLookup } from "./target.js";
 
-import { $TARGET, markRawIngest, setWriteOverride } from "./types.js";
+import { $TARGET, markRawIngest, isWrappable, setWriteOverride } from "./types.js";
 
 /**
  * Store — projections (plan sec. 31, S3; INTERNALS §7/§7b).
@@ -50,22 +52,22 @@ import { $TARGET, markRawIngest, setWriteOverride } from "./types.js";
  * set/getOwnPropertyDescriptor/defineProperty. With the store proxy as
  * target those checks re-enter the store's traps OUTSIDE the override
  * bracket, so `Object.keys(state)` in a derive continuation fired the gate.
- */ function wrapDraft(e, t, r, n, o, i) {
+ */ function wrapDraft(e, t, r, o, n, i) {
     const mutate = e => {
         if (!t()) return true;
         setWriteOverride(true);
         // A continuation's write is the flight's answer: it asks the flight's
         // question (A18 provenance — a landing beneath a newer guess is held,
         // not a correction; lanes.ts `laneWrite`).
-                const n = question;
+                const o = question;
         if (i !== undefined) setQuestion(i());
         try {
             r ? r(e) : e();
         } finally {
             setWriteOverride(false);
-            setQuestion(n);
+            setQuestion(o);
         }
-        if (o) o();
+        if (n) n();
         return true;
     };
     const read = e => {
@@ -79,23 +81,23 @@ import { $TARGET, markRawIngest, setWriteOverride } from "./types.js";
     const s = {
         get(s, c) {
             const u = read(() => e[c]);
-            return !n && typeof u === "object" && u !== null && c !== $TARGET ? wrapDraft(u, t, r, false, o, i) : u;
+            return !o && typeof u === "object" && u !== null && c !== $TARGET ? wrapDraft(u, t, r, false, n, i) : u;
         },
         has: (t, r) => read(() => r in e),
-        set: (t, r, n) => mutate(() => {
-            e[r] = n;
+        set: (t, r, o) => mutate(() => {
+            e[r] = o;
         }),
         deleteProperty: (t, r) => mutate(() => {
             delete e[r];
         }),
         ownKeys: () => read(() => Reflect.ownKeys(e)),
         getOwnPropertyDescriptor(t, r) {
-            const n = read(() => Reflect.getOwnPropertyDescriptor(e, r));
-            if (n) n.configurable = true;
-            return n;
+            const o = read(() => Reflect.getOwnPropertyDescriptor(e, r));
+            if (o) o.configurable = true;
+            return o;
         },
-        defineProperty: (t, r, n) => mutate(() => {
-            Reflect.defineProperty(e, r, n);
+        defineProperty: (t, r, o) => mutate(() => {
+            Reflect.defineProperty(e, r, o);
         })
     };
     const c = new Proxy(Array.isArray(e) ? [] : {}, s);
@@ -122,7 +124,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 +141,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 +156,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);
     });
 }
 
@@ -162,8 +164,8 @@ function forEachFamilyNode(e, t) {
     for (const r of e.live) {
         const e = r.n;
         if (e !== null) for (const r of Reflect.ownKeys(e)) t(e[r]);
-        const n = r.h;
-        if (n !== null) for (const e of Reflect.ownKeys(n)) t(n[e]);
+        const o = r.h;
+        if (o !== null) for (const e of Reflect.ownKeys(o)) t(o[e]);
         if (r.k !== null) t(r.k);
         if (r.dk !== null) t(r.dk);
     }
@@ -173,65 +175,70 @@ function forEachFamilyNode(e, t) {
  * result (sync, or each async landing) through the reconcile channel.
  * Draft validity is per run (R37): live from here until the NEXT run starts
  * — a sync derive that subscribes to an external source and pushes into
- * the draft from the callback (#3585) is the model use. */ function runProjectionComputed(e, t, r, n, o) {
+ * the draft from the callback (#3585) is the model use. */ function runProjectionComputed(e, t, r, o, n) {
     const i = getOwner();
     const s = e[$TARGET];
     const c = s.fam;
     const u = c.run = (c.run || 0) + 1;
-    let a;
+    let l;
     // Open loading window (seedLoadingValue): the observable store IS commit #0
     // 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 l = i._e ? 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.De !== null ? i.m.Oe : 0);
-    const f = wrapDraft(e, () => c.run === u && !isDisposed(i), o, s.s, 
+        const asking = () => question || (i.T !== null && i.T.Se !== null ? i.T.Ee : 0);
+    const f = wrapDraft(e, () => c.run === u && !isDisposed(i), n, s.s, 
     // A write after the run returned (a continuation, a callback) arms the
     // drain itself when no landing will.
     () => {
-        if (!(i.G & STATUS_PENDING) && !i._e) schedule();
+        if (!(i.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
     // — stages and commits with the flush like a memo's recompute.
         const d = u === 1;
-    const pass = () => storeSetter(f, o => {
-        a = t(l ?? o);
+    const pass = () => storeSetter(f, n => {
+        l = t(a ?? n);
         const commit = t => {
             // Shadow run: commit a detached snapshot, never the shadow itself
             // (adoption takes the value by identity — handing it the live
             // shadow would fuse the draft to the observable store).
-            if (l && (t === undefined || t === l)) t = cloneState(l, s.s);
-            if (t !== o && t !== undefined) {
+            if (a && (t === undefined || t === a)) t = cloneState(a, s.s);
+            if (t !== n && t !== undefined) {
                 const write = () => {
-                    const n = question;
+                    const o = question;
                     setQuestion(asking());
                     try {
                         storeSetter(e, e => reconcileState(t, e, r, true), false);
                     } finally {
-                        setQuestion(n);
+                        setQuestion(o);
                     }
                 };
-                n ? n(write, t) : write();
+                o ? o(write, t) : write();
             }
             // A landing (not the sync pass's own commit): the readers held
             // pending on the derive settle.
-                        if (!d || !(i.G & STATUS_UNINITIALIZED)) settleFamily(c);
+                        if (!d || !(i.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, a, commit, (e, t) => {
+        const u = handleAsync(i, l, commit, (e, t) => {
             // The flight rejected: the leaves' readers learn it from here —
             // they do not subscribe to the derive. Pending again (a NotReady
             // rejection): the wake, as for the pass. Errored: every live
             // reader re-derives and meets the error at its pull (memo parity,
             // #2897) — and the flush that runs them advances the clock, so a
             // later tracked re-read may retry (core `read`).
-            if (d && i.G & STATUS_UNINITIALIZED) return;
+            if (d && i.m & STATUS_UNINITIALIZED) return;
             if (t) wakeFamily(c, e); else errorFamily(c);
         });
-        if (!i._e) commit(u);
+        if (!i.ce) commit(u);
     }, false);
     try {
         d ? runDirect(pass) : pass();
@@ -239,64 +246,76 @@ function forEachFamilyNode(e, t) {
         // A flight went up (NotReady out of the pass — the derive's own, with
         // the derive as its source): the leaves' readers learn it from here —
         // they do not subscribe to the derive.
-        if (e instanceof NotReadyError && !d) wakeFamily(c, e);
+        // A synchronous error the same way (#3956: a rerun that finds the
+        // entry failed throws): every live reader re-derives and meets it.
+        if (!d) e instanceof NotReadyError ? wakeFamily(c, e) : errorFamily(c);
         throw e;
     }
     // A pass that returned with a flight up (an iterator's sync first yield):
     // the wake, as for the throw. Not a sync pass that superseded one — the
     // status it reads is the dead flight's, cleared when this pass settles
     // (#3181: a reader the settle walk had just released, re-parked for good).
-        if (i.G & STATUS_PENDING && i.m.De !== null && !i._e && !d) wakeFamily(c, i.m?.v);
+        if (i.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 o = r?.key === undefined ? "id" : r.key;
     const n = {
         map: new WeakMap,
         node: null,
         live: new Set,
-        shallow: !!r?.shallow
+        shallow: !!r?.shallow,
+        // The row key, for a child paired after the adoption (store.ts
+        // `adoptChild`, #3712) as the adoption pairs them.
+        key: typeof o === "function" ? o : o === null ? null : e => isWrappable(e) ? e[o] : undefined
     };
-    const o = wrap(t, null, null, n);
+    const i = wrap(t, null, null, n);
     if (n.shallow) {
-        o[$TARGET].s = true;
+        i[$TARGET].s = true;
         markRawIngest(t);
     }
-    let i;
-    if (r?.seedLoadingValue) i = {
+    let s;
+    if (r?.seedLoadingValue) s = {
         loadingValue: undefined
     };
-    if (r?.name) {
-        i = {
-            ...i,
-            name: r.name
+    if (attrHooks !== null) 
+    // As createStore: the owner in scope stamps the projection's property
+    // nodes, so attribution places them under it (#4035).
+    storeOwners.set(i[$TARGET], getOwner());
+    if (r?.name || r?.loc) {
+        s = {
+            ...s,
+            name: r.name,
+            loc: r.loc
         };
-        nameStore(o, r.name);
+        nameStore(i, r.name, r.loc);
     }
-    const s = computed(() => {
+    const c = computed(() => {
         if (!n.node) n.node = getOwner();
-        runProjectionComputed(o, e, r?.key === undefined ? "id" : r.key);
-    }, i);
-    s.u &= ~CONFIG_AUTO_DISPOSE;
-    n.node = s;
+        runProjectionComputed(i, e, o);
+    }, s);
+    c.l &= ~CONFIG_AUTO_DISPOSE;
+    n.node = c;
+    // The derive's leaves are not its dependents: a mark's repoll
+    // (affects-marks.ts) reaches their readers through this.
+        c.fam = n;
     return {
-        store: o,
-        node: s
+        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;
 }
 
 /** `createStore(fn, seed, options)`: a projection with a user setter. */ function createStoreDerived(e, t, r) {
-    const {store: n} = createProjectionInternal(e, t, r);
-    return [ n, e => storeSetter(n, e) ];
+    const {store: o} = createProjectionInternal(e, t, r);
+    return [ o, e => storeSetter(o, e) ];
 }
 
 export { createProjection, createStoreDerived, runProjectionComputed };

package/dist/observe/store/reconcile.js

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