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

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

@@ -33,81 +33,143 @@ 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) {
+    const i = {
+        get(i, o) {
+            let n;
+            const c = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                o = e[t];
+                n = e[o];
             } finally {
                 setWriteOverride(false);
-                setProjectionWriteActive(i);
+                setProjectionWriteActive(c);
             }
-            if (t === $TARGET) return o;
-            return typeof o === "object" && o !== null ? new Proxy(o, r) : o;
+            if (o === $TARGET) return n;
+            return typeof n === "object" && n !== null ? wrapDraft(n, t, r) : n;
         },
-        has(e, t) {
-            let r;
+        has(t, r) {
+            let i;
             const o = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                r = t in e;
+                i = r in e;
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(o);
             }
-            return r;
+            return i;
+        },
+        set(i, o, n) {
+            if (t && !t()) return true;
+            const c = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                e[o] = n;
+                r?.();
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(c);
+            }
+            return true;
         },
-        set(r, o, i) {
-            if (e && !e()) return true;
+        deleteProperty(i, o) {
+            if (t && !t()) return true;
             const n = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                r[o] = i;
-                t?.();
+                delete e[o];
+                r?.();
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(n);
             }
             return true;
         },
-        deleteProperty(r, o) {
-            if (e && !e()) return true;
-            const i = projectionWriteActive;
+        ownKeys() {
+            const t = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                return Reflect.ownKeys(e);
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(t);
+            }
+        },
+        getOwnPropertyDescriptor(t, r) {
+            let i;
+            const o = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                i = Reflect.getOwnPropertyDescriptor(e, r);
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(o);
+            }
+            // 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 (i) i.configurable = true;
+            return i;
+        },
+        defineProperty(i, o, n) {
+            if (t && !t()) return true;
+            const c = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                delete r[o];
-                t?.();
+                Reflect.defineProperty(e, o, n);
+                r?.();
             } finally {
                 setWriteOverride(false);
-                setProjectionWriteActive(i);
+                setProjectionWriteActive(c);
             }
             return true;
         }
     };
-    return r;
+    // Matching-kind dummy so Array.isArray(draft) answers like the store.
+        return new Proxy(Array.isArray(e) ? [] : {}, i);
 }
 
 function createProjectionNextInternal(e, t, r) {
-    const o = {
+    const i = {
         map: new WeakMap,
         node: null,
         shallow: !!r?.shallow
     };
-    const i = wrapNext(t, null, null, o);
-    if (o.shallow) {
+    const o = wrapNext(t, null, null, i);
+    if (i.shallow) {
         // Shallow projection: the root is the only wrapped level — slot values
         // serve raw, ingests sticky raw-mark (same t.s machinery as plain).
-        i[$TARGET].s = true;
+        o[$TARGET].s = true;
         markRawIngest(t);
     }
     let n;
@@ -115,13 +177,13 @@ function createProjectionNextInternal(e, t, r) {
         loadingValue: undefined
     };
     const c = computed(() => {
-        if (!o.node) o.node = getOwner();
-        runProjectionComputedNext(i, e, r?.key === undefined ? "id" : r.key);
+        if (!i.node) i.node = getOwner();
+        runProjectionComputedNext(o, e, r?.key === undefined ? "id" : r.key);
     }, n);
     c.T &= ~CONFIG_AUTO_DISPOSE;
-    o.node = c;
+    i.node = c;
     return {
-        store: i,
+        store: o,
         node: c
     };
 }
@@ -133,15 +195,15 @@ 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) {
-    const {store: o, node: i} = createProjectionNextInternal(e, t, r);
-    return [ o, e => {
+    const {store: i, node: o} = createProjectionNextInternal(e, t, r);
+    return [ i, e => {
         // Mark the projection as manually written before notifying nodes.
-        suppressComputedRecompute(i);
-        storeSetterNext(o, e);
+        suppressComputedRecompute(o);
+        storeSetterNext(i, e);
     } ];
 }
 
-function runProjectionComputedNext(e, t, r, o, i) {
+function runProjectionComputedNext(e, t, r, i, o) {
     const n = getOwner();
     let c = false;
     let s;
@@ -150,18 +212,18 @@ function runProjectionComputedNext(e, t, r, o, i) {
     // seed so draft writes cannot tear through to readers (#2988). Every commit
     // point reconciles the shadow through the normal commit path.
         const u = n.Ie ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
-    const l = new Proxy(e, createWriteTraps(() => !c || n.o?.Ee === s, i));
-    storeSetterNext(l, i => {
-        s = t(u ?? i);
+    const l = wrapDraft(e, () => !c || n.o?.Ee === s, o);
+    storeSetterNext(l, o => {
+        s = t(u ?? o);
         c = true;
         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 (t === i || t === undefined) return;
+            if (t === o || t === undefined) return;
             const write = () => storeSetterNext(e, e => reconcileNextState(t, e, r, true), false);
-            o ? o(write) : write();
+            i ? i(write) : write();
         };
         const l = handleAsync(n, s, commit);
         if (!n.Ie) commit(l);