@solidjs/signals 2.0.0-rc.1 → 2.0.0-rc.11

package/dist/prod/store/next/projection.js

@@ -1,8 +1,8 @@
-import { computed, suppressComputedRecompute } from "../../core/core.js";
+import { computed } from "../../core/core.js";
 
-import { getOwner } from "../../core/owner.js";
+import { isDisposed, getOwner } from "../../core/owner.js";
 
-import { setProjectionWriteActive, projectionWriteActive } from "../../core/scheduler.js";
+import { setProjectionWriteActive, projectionWriteActive, scheduleWithheld } from "../../core/scheduler.js";
 
 import { handleAsync } from "../../core/async.js";
 
@@ -10,13 +10,13 @@ import "../../core/verdict.js";
 
 import "../../core/effect.js";
 
-import { CONFIG_AUTO_DISPOSE } from "../../core/constants.js";
+import { CONFIG_AUTO_DISPOSE, STATUS_PENDING } from "../../core/constants.js";
 
-import { $TARGET, markRawIngest, STORE_VALUE, setWriteOverride } from "../store.js";
+import { $TARGET, STORE_VALUE, markRawIngest, setWriteOverride } from "../store.js";
 
 import { reconcileNextState } from "./reconcile.js";
 
-import { wrapNext, storeSetterNext } from "./store.js";
+import { storeSetterNext, wrapNext, derivedStoreWrite } from "./store.js";
 
 /**
  * Store rewrite — projections (§7/§7b): a projection is a computed store.
@@ -33,68 +33,119 @@ import { wrapNext, storeSetterNext } from "./store.js";
  * loading windows, handleAsync landings, commit-through-setter) on next
  * primitives; the generic draft write-traps are reused from the legacy
  * module unchanged.
- */ function createWriteTraps(e, t) {
-    // Save/restore, never hard-reset: the draft can be driven from inside an
-    // enclosing authoritative-write scope (next-store optimistic derives), and
-    // a hard `false` would clobber it mid-derive.
-    const r = {
-        get(e, t) {
-            let o;
-            const i = projectionWriteActive;
+ */
+/**
+ * Wrap a store proxy as a projection DRAFT: every operation carries the write
+ * override (the derive is the author — its ops must not hit the §6c firewall
+ * gate, even in a continuation after an `await`/`yield` where the sync write
+ * scope has closed).
+ *
+ * FAKE TARGET, not the store proxy itself (#3060): after a proxy trap
+ * returns, the engine runs spec invariant validation against the proxy's
+ * TARGET — [[OwnPropertyKeys]] after ownKeys, [[GetOwnProperty]] after
+ * set/getOwnPropertyDescriptor/defineProperty. With the store proxy as
+ * target those checks re-enter the store's traps OUTSIDE the override
+ * bracket (the trap's finally has already run), so `Object.keys(state)` in
+ * a derive continuation fired the firewall gate and re-threw the
+ * projection's own pending NotReadyError into the derive. A dummy of
+ * matching kind (array/object, same trick as the store's own TargetShape)
+ * keeps invariant validation away from the store entirely; the traps
+ * forward to the closed-over inner proxy inside the bracket.
+ *
+ * Save/restore projectionWriteActive, never hard-reset: the draft can be
+ * driven from inside an enclosing authoritative-write scope (next-store
+ * optimistic derives), and a hard `false` would clobber it mid-derive.
+ */ function wrapDraft(e, t, r, o, i) {
+    // One bracket for the three mutating traps. A write to a superseded or
+    // disposed draft is dropped silently (proj R37 — the same fate as a
+    // superseded async run's pending draft writes, R26). `afterWrite` runs
+    // once the bracket has closed — outside it, so the scheduler's
+    // projectionWriteActive guard no longer applies — and only for the
+    // outermost bracket (a draft driven from inside an enclosing authoritative
+    // scope, the optimistic derive, leaves scheduling to that scope's caller).
+    const mutate = e => {
+        if (!t()) return true;
+        const o = projectionWriteActive;
+        setWriteOverride(true);
+        setProjectionWriteActive(true);
+        try {
+            r ? r(e) : e();
+        } finally {
+            setWriteOverride(false);
+            setProjectionWriteActive(o);
+        }
+        if (!o && i) i();
+        return true;
+    };
+    const n = {
+        get(n, c) {
+            let s;
+            const l = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                o = e[t];
+                s = e[c];
             } finally {
                 setWriteOverride(false);
-                setProjectionWriteActive(i);
+                setProjectionWriteActive(l);
             }
-            if (t === $TARGET) return o;
-            return typeof o === "object" && o !== null ? new Proxy(o, r) : o;
+            // A shallow store's leaves are raw by contract (#3498): no draft proxy
+            // over them, so identity holds and a frozen leaf is never trapped.
+                        return !o && typeof s === "object" && s !== null && c !== $TARGET ? wrapDraft(s, t, r, false, i) : s;
         },
-        has(e, t) {
-            let r;
-            const o = projectionWriteActive;
+        has(t, r) {
+            let o;
+            const i = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                r = t in e;
+                o = r in e;
             } finally {
                 setWriteOverride(false);
-                setProjectionWriteActive(o);
+                setProjectionWriteActive(i);
             }
-            return r;
+            return o;
         },
-        set(r, o, i) {
-            if (e && !e()) return true;
-            const n = projectionWriteActive;
+        set: (t, r, o) => mutate(() => {
+            e[r] = o;
+        }),
+        deleteProperty: (t, r) => mutate(() => {
+            delete e[r];
+        }),
+        ownKeys() {
+            const t = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                r[o] = i;
-                t?.();
+                return Reflect.ownKeys(e);
             } finally {
                 setWriteOverride(false);
-                setProjectionWriteActive(n);
+                setProjectionWriteActive(t);
             }
-            return true;
         },
-        deleteProperty(r, o) {
-            if (e && !e()) return true;
+        getOwnPropertyDescriptor(t, r) {
+            let o;
             const i = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                delete r[o];
-                t?.();
+                o = Reflect.getOwnPropertyDescriptor(e, r);
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(i);
             }
-            return true;
-        }
+            // The dummy target doesn't hold the key, so a non-configurable report
+            // would violate the proxy invariant. Store descriptors are already
+            // normalized configurable; enforce it for raw leaves too.
+                        if (o) o.configurable = true;
+            return o;
+        },
+        defineProperty: (t, r, o) => mutate(() => {
+            Reflect.defineProperty(e, r, o);
+        })
     };
-    return r;
+    // Matching-kind dummy so Array.isArray(draft) answers like the store.
+        return new Proxy(Array.isArray(e) ? [] : {}, n);
 }
 
 function createProjectionNextInternal(e, t, r) {
@@ -118,7 +169,7 @@ function createProjectionNextInternal(e, t, r) {
         if (!o.node) o.node = getOwner();
         runProjectionComputedNext(i, e, r?.key === undefined ? "id" : r.key);
     }, n);
-    c.T &= ~CONFIG_AUTO_DISPOSE;
+    c.C &= ~CONFIG_AUTO_DISPOSE;
     o.node = c;
     return {
         store: i,
@@ -132,39 +183,73 @@ function createProjectionNext(e, t, r) {
 
 /** Derived writable store (legacy parity): a projection whose public setter
  * masks the recompute for the tick (core R31 — the manual write wins over a
- * same-flush dependency change). */ function createStoreDerivedNext(e, t, r) {
+ * same-flush dependency change). Across a hold the write is not a proposal:
+ * a leaf another transaction holds as the fold's result re-runs the fold
+ * under it, the write being the draft's prior state (A34 amendment, #3612;
+ * core derivedWrite). */ function createStoreDerivedNext(e, t, r) {
     const {store: o, node: i} = createProjectionNextInternal(e, t, r);
-    return [ o, e => {
-        // Mark the projection as manually written before notifying nodes.
-        suppressComputedRecompute(i);
-        storeSetterNext(o, e);
-    } ];
+    return [ o, e => derivedStoreWrite(i, o, e) ];
+}
+
+// A detached copy of projection state: the root container alone for a shallow
+// store — its leaves are raw references by contract and stay so (#3498) — the
+// whole tree otherwise.
+function cloneState(e, t) {
+    return t ? Array.isArray(e) ? e.slice() : {
+        ...e
+    } : JSON.parse(JSON.stringify(e));
 }
 
 function runProjectionComputedNext(e, t, r, o, i) {
     const n = getOwner();
-    let c = false;
-    let s;
+    const c = e[$TARGET];
+    const s = c.fam;
+    // Draft validity is per run (R37): live from here until the NEXT run starts
+    // — this counter moves, whatever that run does (lands, throws NotReady,
+    // awaits) — or the owner is disposed. Not "until no longer in flight": a
+    // sync derive that subscribes to an external source and pushes into the
+    // draft from the callback (#3585) is the model use, and the old gate
+    // (`owner._x?._inFlight === result`) only admitted it by accident — while
+    // nothing had read the projection yet (no `_x`), `undefined === undefined`.
+        const l = s.run = (s.run || 0) + 1;
+    let u;
     // 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 u = n.Ee ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
-    const l = new Proxy(e, createWriteTraps(() => !c || n.Te === s, i));
-    storeSetterNext(l, i => {
-        s = t(u ?? i);
-        c = true;
+    // point reconciles the shadow through the normal commit path. (A callback
+    // that closes over the shadow writes into a dead clone once the window has
+    // closed — the one carve-out from R37's one-draft-per-run model.)
+        const a = n.ve ? cloneState(c[STORE_VALUE], c.s) : null;
+    const f = wrapDraft(e, () => s.run === l && !isDisposed(n), i, c.s, 
+    // A write after the run returned takes the override channel (pending
+    // backing + per-op notify + fold) and arms the drain itself when no
+    // landing will: a flight still up — pending, or the loading window's
+    // first flight — drains at its landing, and must not be drained early.
+    // Not gated on the run having returned: the body's own writes withhold
+    // the microtask too, and a derive body only ever runs outside a flush at
+    // creation (reruns are flush-driven) — a top-level sync projection in a
+    // createRoot stranded the scheduler until an explicit flush(). Arming
+    // mid-body is safe: the microtask fires after this synchronous slice,
+    // when the body has returned or parked, and an initial async run's
+    // pre-await half drains before its landing exactly as it does when the
+    // creation ran inside a flush — nothing reads it before the landing
+    // (the node is uninitialized, proj R23).
+    () => {
+        if (!(n.h & STATUS_PENDING) && !n.ve) scheduleWithheld();
+    });
+    storeSetterNext(f, i => {
+        u = t(a ?? i);
         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 (u && (t === undefined || t === u)) t = JSON.parse(JSON.stringify(u));
+            if (a && (t === undefined || t === a)) t = cloneState(a, c.s);
             if (t === i || t === undefined) return;
             const write = () => storeSetterNext(e, e => reconcileNextState(t, e, r, true), false);
-            o ? o(write) : write();
+            o ? o(write, t) : write();
         };
-        const l = handleAsync(n, s, commit);
-        if (!n.Ee) commit(l);
+        const s = handleAsync(n, u, commit);
+        if (!n.ve) commit(s);
     }, false);
     return n;
 }