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

package/dist/prod/core/scheduler.js

@@ -281,8 +281,8 @@ class GlobalQueue extends Queue {
     static ae=null;
     static he=null;
     static un=null;
-    static St=null;
     static dt=null;
+    static St=null;
     static Rt=null;
     static ze=null;
     static k=null;
@@ -296,13 +296,13 @@ class GlobalQueue extends Queue {
     // once the gate holds.
     static Pt=null;
     static En=null;
-    static Tn=null;
     static dn=null;
+    static Tn=null;
     static In=null;
     static Ct=null;
     static At=null;
     static Ot=null;
-    static We=null;
+    static Ye=null;
     static Ke=null;
     static Me=null;
     static Nn=null;
@@ -509,7 +509,7 @@ function commitPendingNode(e) {
     }
     t.se &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
-    if (t.Le !== null || t.ye !== null) GlobalQueue.Ce(t, false, true);
+    if (t.ye !== null || t.Le !== null) GlobalQueue.Ce(t, false, true);
     if (e.be || e.ge) GlobalQueue.un(e);
 }
 
@@ -562,7 +562,7 @@ function finalizePureQueue(e = null, t = false) {
                 if (t.cn.size) GlobalQueue.Dt(t.cn, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.dn(e);
+                if (activeLanes.size) GlobalQueue.Tn(e);
     }
 }
 
@@ -668,7 +668,7 @@ function transitionComplete(e) {
     // Override blockage lives with the engine. Absent hook = "no optimistic
     // blockage", which is exact: only _optimisticWrite (engine) pushes to
     // _optimisticNodes, so without the engine the loop was vacuous anyway.
-        if (t && e.Ze.length && GlobalQueue.Tn(e)) t = false;
+        if (t && e.Ze.length && GlobalQueue.dn(e)) t = false;
     t && (e.fn = true);
     return t;
 }

package/dist/prod/core/verdict.js

@@ -343,9 +343,9 @@ GlobalQueue.he = updateChildCompanions;
 
 GlobalQueue.un = snapCompanionsToState;
 
-GlobalQueue.St = latestRead;
+GlobalQueue.dt = latestRead;
 
-GlobalQueue.dt = pendingCheckRead;
+GlobalQueue.St = pendingCheckRead;
 
 GlobalQueue.Rt = recordFreshRead;
 

package/dist/prod/map.js

@@ -118,22 +118,29 @@ function updateKeyedMap() {
             this.Mt = t.slice(0);
             this.jt = s;
         } else {
-            let o, c, a, f, u, p, w, l, d, O = new Array(s), m = new Array(s);
-            r = this.Ut ? new Array(s) : undefined;
-            n = this.$t ? new Array(s) : undefined;
+            let o, c, a, f, u, p, w, l, d;
             // skip common prefix
                         for (o = 0, c = Math.min(this.jt, s); o < c && (this.Mt[o] === t[o] || this.Ut && compare(this.Gt, this.Mt[o], t[o])); o++) {
                 if (this.Ut) setSignal(this.Ut[o], t[o]);
             }
-            // common suffix
+            // skip common suffix — counted only; retained entries land in one pass
+            // at commit instead of being staged and copied twice
                         for (c = this.jt - 1, a = s - 1; c >= o && a >= o && (this.Mt[c] === t[a] || this.Ut && compare(this.Gt, this.Mt[c], t[a])); c--, 
-            a--) {
-                O[a] = this.xt[c];
-                m[a] = this.Ft[c];
-                r && (r[a] = this.Ut[c]);
-                n && (n[a] = this.$t[c]);
+            a--) ;
+            // no structural change (every position matched in place at equal
+            // length — the common post-reconcile shape): keep the same mapped
+            // array identity so downstream consumers don't re-run at all
+                        if (o === s && this.jt === s) {
+                this.Mt = t.slice(0);
+                return;
             }
-            // 0) prepare a map of all indices in newItems, scanning backwards so we encounter them in natural order
+            const O = s - this.jt;
+            const m = new Array(s);
+            const _ = new Array(s);
+            r = this.Ut ? new Array(s) : undefined;
+            n = this.$t ? new Array(s) : undefined;
+            // 0) prepare a map of all indices in the changed window of newItems,
+            // scanning backwards so we encounter them in natural order
                         p = new Map;
             w = new Array(a + 1);
             for (e = a; e >= o; e--) {
@@ -143,14 +150,16 @@ function updateKeyedMap() {
                 w[e] = i === undefined ? -1 : i;
                 p.set(u, e);
             }
-            // 1) step through all old items and see if they can be found in the new set; if so, save them in a temp array and mark them moved; if not, queue them for disposal at commit
+            // 1) step through the old changed window and see if items can be found
+            // in the new set; if so, stage them at their new positions; if not,
+            // queue them for disposal at commit
                         for (i = o; i <= c; i++) {
                 f = this.Mt[i];
                 u = this.Gt ? this.Gt(f) : f;
                 e = p.get(u);
                 if (e !== undefined && e !== -1) {
-                    O[e] = this.xt[i];
-                    m[e] = this.Ft[i];
+                    m[e] = this.xt[i];
+                    _[e] = this.Ft[i];
                     r && (r[e] = this.Ut[i]);
                     n && (n[e] = this.$t[i]);
                     e = w[e];
@@ -159,33 +168,48 @@ function updateKeyedMap() {
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
-                for (e = o; e < s; e++) {
-                    if (e in O) continue;
-                    (d ??= []).push(m[e] = createOwner());
-                    O[e] = runWithOwner(m[e], h);
+                for (e = o; e <= a; e++) {
+                    if (_[e] !== undefined) continue;
+                    (d ??= []).push(_[e] = createOwner());
+                    m[e] = runWithOwner(_[e], h);
                 }
             } catch (t) {
                 if (d) for (i = 0; i < d.length; i++) d[i].dispose();
                 throw t;
             }
-            // 3) commit: land positions, then dispose exited rows
-                        for (e = o; e < s; e++) {
-                this.xt[e] = O[e];
-                this.Ft[e] = m[e];
+            // 3) commit: land the retained prefix and suffix plus the staged window
+            // into the fresh arrays, swap them in (new identity for downstream
+            // change propagation), then dispose exited rows
+                        for (i = 0; i < o; i++) {
+                m[i] = this.xt[i];
+                _[i] = this.Ft[i];
+                r && (r[i] = this.Ut[i]);
+                n && (n[i] = this.$t[i]);
+            }
+            for (e = o; e <= a; e++) {
+                if (r) setSignal(r[e], t[e]);
+                if (n) setSignal(n[e], e);
+            }
+            for (e = a + 1; e < s; e++) {
+                m[e] = this.xt[e - O];
+                _[e] = this.Ft[e - O];
                 if (r) {
-                    this.Ut[e] = r[e];
-                    setSignal(this.Ut[e], t[e]);
+                    r[e] = this.Ut[e - O];
+                    setSignal(r[e], t[e]);
                 }
                 if (n) {
-                    this.$t[e] = n[e];
-                    setSignal(this.$t[e], e);
+                    n[e] = this.$t[e - O];
+                    if (O !== 0) setSignal(n[e], e);
                 }
             }
-            if (l) for (i = 0; i < l.length; i++) l[i].dispose();
-            // 4) in case the new set is shorter than the old, set the length of the mapped array
-                        this.xt = this.xt.slice(0, this.jt = s);
-            // 5) save a copy of the mapped items for the next update
+            this.xt = m;
+            this.Ft = _;
+            r && (this.Ut = r);
+            n && (this.$t = n);
+            this.jt = s;
+            // save a copy of the mapped items for the next update
                         this.Mt = t.slice(0);
+            if (l) for (i = 0; i < l.length; i++) l[i].dispose();
         }
     });
     return this.xt;

package/dist/prod/store/optimistic.js

@@ -14,19 +14,21 @@ 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_OPTIMISTIC, STORE_FIREWALL } from "./store.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";
 
-function createOptimisticStore(e, t, r) {
+function createOptimisticStore(e, t, i) {
     // 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 i = typeof e === "function";
-    const o = i ? t : e;
-    const n = i ? e : undefined;
+    const r = 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;
     // Create optimistic projection store
-        const {store: c} = createOptimisticProjectionInternal(n, o, r);
+        const {store: c} = createOptimisticProjectionInternal(n, o, i);
     return [ c, e => storeSetter(c, e) ];
 }
 
@@ -35,8 +37,8 @@ function createOptimisticStore(e, t, r) {
 // 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 r of e) {
-        const e = r[$TARGET];
+    for (const i of e) {
+        const e = i[$TARGET];
         if (e?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(e, t);
     }
     e.clear();
@@ -54,9 +56,9 @@ function clearOptimisticStores(e, t) {
  * fresh authoritative data) consumes everything — the correction supersedes
  * every tentative layer.
  */ function clearOptimisticOverride(e, t) {
-    const r = e[STORE_OPTIMISTIC_OVERRIDE];
-    if (!r) return;
-    const i = e[STORE_NODE];
+    const i = e[STORE_OPTIMISTIC_OVERRIDE];
+    if (!i) return;
+    const r = e[STORE_NODE];
     const o = e[STORE_OPTIMISTIC_OWNERS];
     const n = t !== undefined;
     let c = false;
@@ -66,7 +68,7 @@ function clearOptimisticStores(e, t) {
         const O = projectionWriteActive;
     setProjectionWriteActive(true);
     try {
-        for (const O of Reflect.ownKeys(r)) {
+        for (const O of Reflect.ownKeys(i)) {
             if (n) {
                 let e = o?.[O] ?? null;
                 // Resolve merge chains (entangled actions settle as one); path-compress
@@ -83,19 +85,19 @@ function clearOptimisticStores(e, t) {
                     }
                 }
             }
-            delete r[O];
+            delete i[O];
             if (o) delete o[O];
             c = true;
-            const T = i?.[O];
+            const T = r?.[O];
             if (T) {
                 // Clear lane association so effects go to regular queue
                 T.je = 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 r = t ? t[O] : e[STORE_VALUE][O];
-                const i = r === $DELETED ? undefined : r;
-                const o = isWrappable(i) ? wrap(i, e) : i;
+                const i = t ? t[O] : e[STORE_VALUE][O];
+                const r = i === $DELETED ? undefined : i;
+                const o = isWrappable(r) ? wrap(r, e) : r;
                 const n = visibleNodeValue(T);
                 T.Ee = NOT_PENDING;
                 T.sn = null;
@@ -108,12 +110,14 @@ function clearOptimisticStores(e, t) {
             }
         }
         if (!s) {
-            delete e[STORE_OPTIMISTIC_OVERRIDE];
-            delete e[STORE_OPTIMISTIC_OWNERS];
+            // Assignment, not delete: StoreNode targets share one pre-initialized
+            // hidden class (see createStoreProxy) and a delete would demote it.
+            e[STORE_OPTIMISTIC_OVERRIDE] = undefined;
+            e[STORE_OPTIMISTIC_OWNERS] = undefined;
         }
         // Notify $TRACK
-                if (c && i?.[$TRACK]) {
-            i[$TRACK].je = undefined;
+                if (c && r?.[$TRACK]) {
+            r[$TRACK].je = undefined;
             notifySelf(e);
         }
     } finally {
@@ -121,17 +125,22 @@ function clearOptimisticStores(e, t) {
     }
 }
 
-function createOptimisticProjectionInternal(e, t, r) {
-    let i;
+function createOptimisticProjectionInternal(e, t, i) {
+    let r;
     const o = new WeakMap;
+    const n = !!i?.shallow;
     const wrapper = e => {
         e[STORE_WRAP] = wrapProjection;
         e[STORE_LOOKUP] = o;
+        if (n) {
+            e[STORE_SHALLOW] = true;
+            markRawIngest(e[STORE_VALUE]);
+        }
         e[STORE_OPTIMISTIC] = true;
  // Mark as optimistic store
                 Object.defineProperty(e, STORE_FIREWALL, {
             get() {
-                return i;
+                return r;
             },
             configurable: true
         });
@@ -143,7 +152,7 @@ function createOptimisticProjectionInternal(e, t, r) {
         o.set(e, t);
         return t;
     };
-    const n = wrapProjection(t);
+    const c = wrapProjection(t);
     // If there's a projection function, create a computed to drive it
         if (e) {
         // All writes inside firewall recompute must go to STORE_OVERRIDE (base), not
@@ -152,7 +161,7 @@ function createOptimisticProjectionInternal(e, t, r) {
         // async yields because they fire outside any enclosing try/finally. It also
         // consumes stale optimistic overlays once fresh projected data lands.
         const clearProjectionOverride = () => {
-            const e = n[$TARGET];
+            const e = c[$TARGET];
             if (e?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(e);
         };
         const wrapCommit = e => {
@@ -165,19 +174,19 @@ function createOptimisticProjectionInternal(e, t, r) {
                 setProjectionWriteActive(t);
             }
         };
-        i = computed(() => {
+        r = computed(() => {
             setProjectionWriteActive(true);
             try {
-                runProjectionComputed(n, e, r?.key || "id", wrapCommit, clearProjectionOverride);
+                runProjectionComputed(c, e, i?.key || "id", wrapCommit, clearProjectionOverride);
             } finally {
                 setProjectionWriteActive(false);
             }
         }, undefined);
-        i.T &= ~CONFIG_AUTO_DISPOSE;
+        r.T &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
-        store: n,
-        node: i
+        store: c,
+        node: r
     };
 }
 

package/dist/prod/store/projection.js

@@ -14,14 +14,21 @@ import { CONFIG_AUTO_DISPOSE } from "../core/constants.js";
 
 import { reconcile } from "./reconcile.js";
 
-import { storeSetter, $TARGET, STORE_WRAP, createStoreProxy, storeTraps, setWriteOverride, STORE_LOOKUP, STORE_FIREWALL } from "./store.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) {
     let o;
-    const i = new WeakMap;
+    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 wrapper = e => {
         e[STORE_WRAP] = wrapProjection;
-        e[STORE_LOOKUP] = i;
+        e[STORE_LOOKUP] = n;
+        if (i) {
+            e[STORE_SHALLOW] = true;
+            markRawIngest(e[STORE_VALUE]);
+        }
         Object.defineProperty(e, STORE_FIREWALL, {
             get() {
                 return o;
@@ -30,20 +37,20 @@ function createProjectionInternal(e, r, t) {
         });
     };
     const wrapProjection = e => {
-        if (i.has(e)) return i.get(e);
+        if (n.has(e)) return n.get(e);
         if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
         const r = createStoreProxy(e, storeTraps, wrapper);
-        i.set(e, r);
+        n.set(e, r);
         return r;
     };
-    const n = wrapProjection(r);
+    const c = wrapProjection(r);
     o = computed(() => {
         if (!o) o = getOwner();
-        runProjectionComputed(n, e, t?.key || "id");
+        runProjectionComputed(c, e, t?.key || "id");
     }, undefined);
     o.T &= ~CONFIG_AUTO_DISPOSE;
     return {
-        store: n,
+        store: c,
         node: o
     };
 }
@@ -106,22 +113,22 @@ 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, i) {
-    const n = getOwner();
+ */ function runProjectionComputed(e, r, t, o, n) {
+    const i = getOwner();
     let c = false;
     let s;
-    const u = new Proxy(e, createWriteTraps(() => !c || n.Te === s, i));
-    storeSetter(u, i => {
-        s = r(i);
+    const u = new Proxy(e, createWriteTraps(() => !c || i.Te === s, n));
+    storeSetter(u, n => {
+        s = r(n);
         c = true;
         const commit = r => {
-            if (r === i || r === undefined) return;
+            if (r === n || r === undefined) return;
             const write = () => storeSetter(e, reconcile(r, t));
             o ? o(write) : write();
         };
-        commit(handleAsync(n, s, commit));
+        commit(handleAsync(i, s, commit));
     });
-    return n;
+    return i;
 }
 
 function createWriteTraps(e, r) {
@@ -151,12 +158,12 @@ function createWriteTraps(e, r) {
             }
             return t;
         },
-        set(t, o, i) {
+        set(t, o, n) {
             if (e && !e()) return true;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                t[o] = i;
+                t[o] = n;
                 r?.();
             } finally {
                 setWriteOverride(false);