@solidjs/signals 2.0.0-beta.25 → 2.0.0-beta.27

package/dist/prod/store/optimistic.js

@@ -1,6 +1,6 @@
-import { computed } from "../core/core.js";
+import { STATUS_PENDING, CONFIG_AUTO_DISPOSE, NOT_PENDING } from "../core/constants.js";
 
-import { CONFIG_AUTO_DISPOSE, NOT_PENDING } from "../core/constants.js";
+import { computed } from "../core/core.js";
 
 import { GlobalQueue, schedule, currentTransition, insertSubs, setProjectionWriteActive, projectionWriteActive } from "../core/scheduler.js";
 
@@ -14,21 +14,40 @@ import { installOptimisticEngine } from "../core/optimistic.js";
 
 import { runProjectionComputed } from "./projection.js";
 
-import { storeSetter, $TARGET, STORE_OPTIMISTIC_OVERRIDE, STORE_NODE, STORE_OPTIMISTIC_OWNERS, getOverlayLayer, STORE_VALUE, $DELETED, isWrappable, wrap, visibleNodeValue, $TRACK, notifySelf, STORE_WRAP, createStoreProxy, storeTraps, STORE_LOOKUP, STORE_SHALLOW, markRawIngest, STORE_OPTIMISTIC, STORE_FIREWALL } from "./store.js";
+import { $TARGET, STORE_FIREWALL, storeSetter, STORE_OPTIMISTIC_OVERRIDE, STORE_NODE, STORE_OPTIMISTIC_OWNERS, getOverlayLayer, STORE_VALUE, $DELETED, isWrappable, wrap, visibleNodeValue, $TRACK, notifySelf, STORE_WRAP, createStoreProxy, storeTraps, STORE_LOOKUP, STORE_SHALLOW, markRawIngest, STORE_OPTIMISTIC } from "./store.js";
 
-function createOptimisticStore(e, t, i) {
+function createOptimisticStore(e, t, r) {
     // Register clear function with scheduler; store nodes marked
     // STORE_OPTIMISTIC take the engine's write path, so install it before any
     // node can be created.
     installOptimisticEngine();
-    GlobalQueue.Dt ||= clearOptimisticStores;
-    const r = typeof e === "function";
+    if (!GlobalQueue.Dt) {
+        GlobalQueue.Dt = clearOptimisticStores;
+        // Store half of the engine's override blockage (#2951): signal-form
+        // createOptimistic carries the pending async and the override on ONE node,
+        // so transitionBlocked sees both; a derived optimistic STORE splits them —
+        // the layer sits on store targets while the in-flight truth lives on the
+        // firewall computed. Without this, the transition adopting a bare store
+        // write settled in the same flush that started the refetch and its settle
+        // consumed the layer mid-flight (follow-up writes then drafted from base,
+        // clobbering instead of composing). Optimistic state clears when truth
+        // lands or its transaction ends — never mid-refetch. Wrapped here (engine
+        // is already installed above) so store-free apps never carry the check.
+                const e = GlobalQueue.dn;
+        GlobalQueue.dn = t => {
+            for (const e of t.cn) {
+                if ((e[$TARGET]?.[STORE_FIREWALL]?.S ?? 0) & STATUS_PENDING) return true;
+            }
+            return e(t);
+        };
+    }
+    const i = typeof e === "function";
     // Plain form: the second slot carries options.
-        if (!r && i === undefined) i = t;
-    const o = r ? t : e;
-    const n = r ? e : undefined;
+        if (!i && r === undefined) r = t;
+    const o = i ? t : e;
+    const n = i ? e : undefined;
     // Create optimistic projection store
-        const {store: c} = createOptimisticProjectionInternal(n, o, i);
+        const {store: c} = createOptimisticProjectionInternal(n, o, r);
     return [ c, e => storeSetter(c, e) ];
 }
 
@@ -37,8 +56,8 @@ function createOptimisticStore(e, t, i) {
 // scheduler's flush tail carries only a size-guarded hook call. The
 // completing transition scopes each clear to its own layer keys (#2899).
 function clearOptimisticStores(e, t) {
-    for (const i of e) {
-        const e = i[$TARGET];
+    for (const r of e) {
+        const e = r[$TARGET];
         if (e?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(e, t);
     }
     e.clear();
@@ -56,9 +75,9 @@ function clearOptimisticStores(e, t) {
  * fresh authoritative data) consumes everything — the correction supersedes
  * every tentative layer.
  */ function clearOptimisticOverride(e, t) {
-    const i = e[STORE_OPTIMISTIC_OVERRIDE];
-    if (!i) return;
-    const r = e[STORE_NODE];
+    const r = e[STORE_OPTIMISTIC_OVERRIDE];
+    if (!r) return;
+    const i = e[STORE_NODE];
     const o = e[STORE_OPTIMISTIC_OWNERS];
     const n = t !== undefined;
     let c = false;
@@ -68,7 +87,7 @@ function clearOptimisticStores(e, t) {
         const O = projectionWriteActive;
     setProjectionWriteActive(true);
     try {
-        for (const O of Reflect.ownKeys(i)) {
+        for (const O of Reflect.ownKeys(r)) {
             if (n) {
                 let e = o?.[O] ?? null;
                 // Resolve merge chains (entangled actions settle as one); path-compress
@@ -85,25 +104,25 @@ function clearOptimisticStores(e, t) {
                     }
                 }
             }
-            delete i[O];
+            delete r[O];
             if (o) delete o[O];
             c = true;
-            const T = r?.[O];
+            const T = i?.[O];
             if (T) {
                 // Clear lane association so effects go to regular queue
-                T.je = undefined;
+                T.Me = undefined;
                 // Re-read from base — this key left the optimistic layer above, so the
                 // overlay resolves to STORE_OVERRIDE or STORE_VALUE.
                                 const t = getOverlayLayer(e, O);
-                const i = t ? t[O] : e[STORE_VALUE][O];
-                const r = i === $DELETED ? undefined : i;
-                const o = isWrappable(r) ? wrap(r, e) : r;
+                const r = t ? t[O] : e[STORE_VALUE][O];
+                const i = r === $DELETED ? undefined : r;
+                const o = isWrappable(i) ? wrap(i, e) : i;
                 const n = visibleNodeValue(T);
-                T.Ee = NOT_PENDING;
+                T.Ae = NOT_PENDING;
                 T.sn = null;
-                T.Ne = NOT_PENDING;
-                T.Pe = o;
-                if (!T.Re || !T.Re(n, o)) {
+                T.De = NOT_PENDING;
+                T.Ue = o;
+                if (!T.be || !T.be(n, o)) {
                     insertSubs(T, true);
                     schedule();
                 }
@@ -116,8 +135,8 @@ function clearOptimisticStores(e, t) {
             e[STORE_OPTIMISTIC_OWNERS] = undefined;
         }
         // Notify $TRACK
-                if (c && r?.[$TRACK]) {
-            r[$TRACK].je = undefined;
+                if (c && i?.[$TRACK]) {
+            i[$TRACK].Me = undefined;
             notifySelf(e);
         }
     } finally {
@@ -125,10 +144,10 @@ function clearOptimisticStores(e, t) {
     }
 }
 
-function createOptimisticProjectionInternal(e, t, i) {
-    let r;
+function createOptimisticProjectionInternal(e, t, r) {
+    let i;
     const o = new WeakMap;
-    const n = !!i?.shallow;
+    const n = !!r?.shallow;
     const wrapper = e => {
         e[STORE_WRAP] = wrapProjection;
         e[STORE_LOOKUP] = o;
@@ -140,7 +159,7 @@ function createOptimisticProjectionInternal(e, t, i) {
  // Mark as optimistic store
                 Object.defineProperty(e, STORE_FIREWALL, {
             get() {
-                return r;
+                return i;
             },
             configurable: true
         });
@@ -174,19 +193,19 @@ function createOptimisticProjectionInternal(e, t, i) {
                 setProjectionWriteActive(t);
             }
         };
-        r = computed(() => {
+        i = computed(() => {
             setProjectionWriteActive(true);
             try {
-                runProjectionComputed(c, e, i?.key || "id", wrapCommit, clearProjectionOverride);
+                runProjectionComputed(c, e, r?.key === undefined ? "id" : r.key, wrapCommit, clearProjectionOverride);
             } finally {
                 setProjectionWriteActive(false);
             }
         }, undefined);
-        r.T &= ~CONFIG_AUTO_DISPOSE;
+        i.T &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
         store: c,
-        node: r
+        node: i
     };
 }
 

package/dist/prod/store/projection.js

@@ -12,16 +12,16 @@ import "../core/effect.js";
 
 import { CONFIG_AUTO_DISPOSE } from "../core/constants.js";
 
-import { reconcile } from "./reconcile.js";
+import { reconcileState } from "./reconcile.js";
 
 import { storeSetter, $TARGET, STORE_WRAP, createStoreProxy, storeTraps, setWriteOverride, STORE_LOOKUP, STORE_SHALLOW, markRawIngest, STORE_VALUE, STORE_FIREWALL } from "./store.js";
 
-function createProjectionInternal(e, r, t) {
+function createProjectionInternal(e, t, r) {
     let o;
     const n = new WeakMap;
     // A shallow projection's children are raw and never wrapped, so the
     // wrapper only ever runs for the root — flagging unconditionally is safe.
-        const i = !!t?.shallow;
+        const i = !!r?.shallow;
     const wrapper = e => {
         e[STORE_WRAP] = wrapProjection;
         e[STORE_LOOKUP] = n;
@@ -39,14 +39,14 @@ function createProjectionInternal(e, r, t) {
     const wrapProjection = e => {
         if (n.has(e)) return n.get(e);
         if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
-        const r = createStoreProxy(e, storeTraps, wrapper);
-        n.set(e, r);
-        return r;
+        const t = createStoreProxy(e, storeTraps, wrapper);
+        n.set(e, t);
+        return t;
     };
-    const c = wrapProjection(r);
+    const c = wrapProjection(t);
     o = computed(() => {
         if (!o) o = getOwner();
-        runProjectionComputed(c, e, t?.key || "id");
+        runProjectionComputed(c, e, r?.key === undefined ? "id" : r.key);
     }, undefined);
     o.T &= ~CONFIG_AUTO_DISPOSE;
     return {
@@ -63,6 +63,10 @@ function createProjectionInternal(e, r, t) {
  * items keep their proxy identity — only added/removed items are
  * created/disposed.
  *
+ * If the derive returns a different entity than the one currently held (the
+ * `/users/1` → `/users/2` shape), the store swaps to it rather than merging,
+ * and nothing below it is treated as surviving.
+ *
  * Returns the projected store directly (no setter — reads only).
  *
  * Use this when you want the structural-sharing / per-property tracking
@@ -75,7 +79,8 @@ function createProjectionInternal(e, r, t) {
  * @param seed the backing store value to wrap and reconcile into
  * @param options `ProjectionOptions` — `name`, `key`. `key` defaults to
  *   `"id"`; specify it only when your data uses a different identity field
- *   (e.g. `{ key: "uuid" }` or `{ key: u => u.slug }`).
+ *   (e.g. `{ key: "uuid" }` or `{ key: u => u.slug }`), or `null` to merge
+ *   positionally with no keyed pass.
  *
  * @example
  * ```ts
@@ -97,8 +102,8 @@ function createProjectionInternal(e, r, t) {
  * ```
  *
  * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
- */ function createProjection(e, r, t) {
-    return createProjectionInternal(e, r, t).store;
+ */ function createProjection(e, t, r) {
+    return createProjectionInternal(e, t, r).store;
 }
 
 /**
@@ -113,17 +118,17 @@ function createProjectionInternal(e, r, t) {
  * re-enters `setProjectionWriteActive` so reconciles target `STORE_OVERRIDE`
  * instead of `STORE_OPTIMISTIC_OVERRIDE` even when an async yield fires outside
  * the outer `setProjectionWriteActive` scope.
- */ function runProjectionComputed(e, r, t, o, n) {
+ */ function runProjectionComputed(e, t, r, o, n) {
     const i = getOwner();
     let c = false;
     let s;
     const u = new Proxy(e, createWriteTraps(() => !c || i.Te === s, n));
     storeSetter(u, n => {
-        s = r(n);
+        s = t(n);
         c = true;
-        const commit = r => {
-            if (r === n || r === undefined) return;
-            const write = () => storeSetter(e, reconcile(r, t));
+        const commit = t => {
+            if (t === n || t === undefined) return;
+            const write = () => storeSetter(e, e => reconcileState(t, e, r, true));
             o ? o(write) : write();
         };
         commit(handleAsync(i, s, commit));
@@ -131,53 +136,53 @@ function createProjectionInternal(e, r, t) {
     return i;
 }
 
-function createWriteTraps(e, r) {
-    const t = {
-        get(e, r) {
+function createWriteTraps(e, t) {
+    const r = {
+        get(e, t) {
             let o;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                o = e[r];
+                o = e[t];
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(false);
             }
-            if (r === $TARGET) return o;
-            return typeof o === "object" && o !== null ? new Proxy(o, t) : o;
+            if (t === $TARGET) return o;
+            return typeof o === "object" && o !== null ? new Proxy(o, r) : o;
         },
-        has(e, r) {
-            let t;
+        has(e, t) {
+            let r;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                t = r in e;
+                r = t in e;
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(false);
             }
-            return t;
+            return r;
         },
-        set(t, o, n) {
+        set(r, o, n) {
             if (e && !e()) return true;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                t[o] = n;
-                r?.();
+                r[o] = n;
+                t?.();
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(false);
             }
             return true;
         },
-        deleteProperty(t, o) {
+        deleteProperty(r, o) {
             if (e && !e()) return true;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                delete t[o];
-                r?.();
+                delete r[o];
+                t?.();
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(false);
@@ -185,7 +190,7 @@ function createWriteTraps(e, r) {
             return true;
         }
     };
-    return t;
+    return r;
 }
 
 export { createProjection, createProjectionInternal, createWriteTraps, runProjectionComputed };