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

package/dist/prod/core/owner.js

@@ -54,7 +54,7 @@ function disposeChildren(e, n = false, t) {
         if (n.be || n.ge) GlobalQueue.un(n);
     }
     if (n && e.ke) e.Te = null;
-    let l = t ? e.Le : e.me;
+    let l = t ? e.ye : e.me;
     while (l) {
         const e = l.ve;
         if (l.Xe) {
@@ -71,7 +71,7 @@ function disposeChildren(e, n = false, t) {
         l = e;
     }
     if (t) {
-        e.Le = null;
+        e.ye = null;
     } else {
         e.me = null;
         e.Qe = 0;
@@ -90,15 +90,15 @@ function disposeChildren(e, n = false, t) {
     runDisposal(e, t);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (n && e.Et) {
-        const n = e.Et;
-        e.Et = undefined;
+        if (n && e.ft) {
+        const n = e.ft;
+        e.ft = undefined;
         n();
     }
 }
 
 function runDisposal(e, n) {
-    let t = n ? e.ye : e.xe;
+    let t = n ? e.Le : e.xe;
     if (!t) return;
     if (Array.isArray(t)) {
         for (let e = 0; e < t.length; e++) {
@@ -108,7 +108,7 @@ function runDisposal(e, n) {
     } else {
         t.call(t);
     }
-    n ? e.ye = null : e.xe = null;
+    n ? e.Le = null : e.xe = null;
 }
 
 function childId(e, n) {
@@ -235,8 +235,8 @@ function disposeRootSelf(e = true) {
     const i = {
         id: inheritId(e, t, n),
         T: t ? CONFIG_TRANSPARENT : 0,
-        ft: true,
-        Nt: n?.ft ? n.Nt : n,
+        Et: true,
+        Nt: n?.Et ? n.Nt : n,
         me: null,
         ve: null,
         st: null,
@@ -244,8 +244,8 @@ function disposeRootSelf(e = true) {
         C: n?.C ?? globalQueue,
         we: n?.we || defaultContext,
         Qe: 0,
-        ye: null,
         Le: null,
+        ye: null,
         Ge: n,
         dispose: disposeRootSelf
     };

package/dist/prod/core/scheduler.js

@@ -19,14 +19,14 @@ const transitions = new Set;
 const dirtyQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    He: 0,
+    Fe: 0,
     EE: 0
 };
 
 const zombieQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    He: 0,
+    Fe: 0,
     EE: 0
 };
 
@@ -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;
@@ -334,7 +334,7 @@ class GlobalQueue extends Queue {
                     // A kept ambient batch may hold pending nodes (#2916): stay
                     // scheduled so the outer drain loop commits them via the plain
                     // flush path instead of leaving them until the next natural flush.
-                                        scheduled = dirtyQueue.EE >= dirtyQueue.He || this.m.Qt.length > 0;
+                                        scheduled = dirtyQueue.EE >= dirtyQueue.Fe || this.m.Qt.length > 0;
                     reassignPendingTransition(e.Qt);
                     activeTransition = null;
                     finalizePureQueue(null, true);
@@ -362,7 +362,7 @@ class GlobalQueue extends Queue {
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
-                    if (dirtyQueue.EE >= dirtyQueue.He) {
+                    if (dirtyQueue.EE >= dirtyQueue.Fe) {
                         runHeap(dirtyQueue, GlobalQueue.pe);
                         commitPendingNodes();
                     }
@@ -373,7 +373,7 @@ class GlobalQueue extends Queue {
             }
             clock++;
             // Check if finalization added items to the heap (from optimistic reversion)
-                        scheduled = dirtyQueue.EE >= dirtyQueue.He;
+                        scheduled = dirtyQueue.EE >= dirtyQueue.Fe;
             // Run lane effects first (for ready lanes), then regular effects
                         activeLanes.size && GlobalQueue.In(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
@@ -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);
 }
 
@@ -527,7 +527,7 @@ function finalizePureQueue(e = null, t = false) {
     const i = !t;
     if (i) commitPendingNodes();
     if (!t && globalQueue.vt.length) checkBoundaryChildren(globalQueue);
-    const n = dirtyQueue.EE >= dirtyQueue.He;
+    const n = dirtyQueue.EE >= dirtyQueue.Fe;
     if (n) runHeap(dirtyQueue, GlobalQueue.pe);
     if (i) {
         if (n) commitPendingNodes();
@@ -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

@@ -232,7 +232,7 @@ function getLatestValueComputed(e) {
         // until the flush (#2922). Mirror the tracked-read pull here: mark the
         // queued staleness through the graph, then bring the shadow up to date.
         const e = queueFor(t);
-        if (t.Fe >= e.He && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.He >= e.Fe && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             prepareComputed(t, true);
         }
@@ -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/store/optimistic.js

@@ -14,7 +14,7 @@ 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, i) {
     // Register clear function with scheduler; store nodes marked
@@ -23,6 +23,8 @@ function createOptimisticStore(e, t, i) {
     installOptimisticEngine();
     GlobalQueue.Dt ||= clearOptimisticStores;
     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
@@ -126,9 +128,14 @@ function clearOptimisticStores(e, t) {
 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, {
@@ -145,7 +152,7 @@ function createOptimisticProjectionInternal(e, t, i) {
         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
@@ -154,7 +161,7 @@ function createOptimisticProjectionInternal(e, t, i) {
         // 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 => {
@@ -170,7 +177,7 @@ function createOptimisticProjectionInternal(e, t, i) {
         r = computed(() => {
             setProjectionWriteActive(true);
             try {
-                runProjectionComputed(n, e, i?.key || "id", wrapCommit, clearProjectionOverride);
+                runProjectionComputed(c, e, i?.key || "id", wrapCommit, clearProjectionOverride);
             } finally {
                 setProjectionWriteActive(false);
             }
@@ -178,7 +185,7 @@ function createOptimisticProjectionInternal(e, t, i) {
         r.T &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
-        store: n,
+        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);