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

package/dist/prod/core/core.js

@@ -82,7 +82,7 @@ function releaseSubtree(e) {
             if (e.se & REACTIVE_SNAPSHOT_STALE) {
                 e.se &= ~REACTIVE_SNAPSHOT_STALE;
                 e.se |= REACTIVE_DIRTY;
-                if (dirtyQueue.Fe > e.He) dirtyQueue.Fe = e.He;
+                if (dirtyQueue.He > e.Fe) dirtyQueue.He = e.Fe;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
@@ -95,7 +95,10 @@ function clearSnapshots() {
     if (snapshotSources) {
         for (const e of snapshotSources) {
             delete e.Ve;
-            delete e[STORE_SNAPSHOT_PROPS];
+            // StoreNode targets share one pre-initialized hidden class (see
+            // createStoreProxy) — assign undefined instead of deleting, and only
+            // when present so signal-node sources don't grow the field.
+                        if (e[STORE_SNAPSHOT_PROPS] !== undefined) e[STORE_SNAPSHOT_PROPS] = undefined;
         }
         snapshotSources = null;
     }
@@ -131,7 +134,7 @@ function recompute(e, t = false) {
     e.se = REACTIVE_RECOMPUTING_DEPS;
     e.ce = clock;
     let a = e.Ne === NOT_PENDING ? e.Pe : e.Ne;
-    let r = e.He;
+    let r = e.Fe;
     let c = tracking;
     let _ = currentOptimisticLane;
     tracking = true;
@@ -252,7 +255,7 @@ function recompute(e, t = false) {
             // for commit on its own transition's schedule — invisibly (A17/A18).
             if (e.Ne === NOT_PENDING) queuePendingNode(e);
             e.Ne = a;
-        } else if (e.He != r) {
+        } else if (e.Fe != r) {
             for (let t = e.o; t !== null; t = t.ue) {
                 insertIntoHeapHeight(t.le, queueFor(t.le));
             }
@@ -301,7 +304,7 @@ function computed(e, t) {
         Qe: 0,
         ke: e,
         Pe: undefined,
-        He: 0,
+        Fe: 0,
         u: null,
         lt: undefined,
         ut: null,
@@ -346,7 +349,7 @@ function computed(e, t) {
         Qe: 0,
         ke: e,
         Pe: undefined,
-        He: 0,
+        Fe: 0,
         u: null,
         lt: undefined,
         ut: null,
@@ -397,7 +400,7 @@ function setupComputedNode(e, t) {
             context.me = e;
         }
     }
-    if (n) e.He = n.He + 1;
+    if (n) e.Fe = n.Fe + 1;
     if (GlobalQueue.Tt !== null) GlobalQueue.Tt(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
@@ -520,15 +523,15 @@ function read(e) {
         link(e, t, pendingCheckActive);
         if (l.ke) {
             const n = queueFor(e);
-            if (l.He >= n.Fe) {
+            if (l.Fe >= n.He) {
                 markNode(t);
                 markHeap(n);
                 updateIfNecessary(l);
             }
-            const i = l.He;
+            const i = l.Fe;
             // parent check is shallow, might need to be recursive
-                        if (i >= t.He && e.Ge !== t) {
-                t.He = i + 1;
+                        if (i >= t.Fe && e.Ge !== t) {
+                t.Fe = i + 1;
             }
         }
     }

package/dist/prod/core/error.js

@@ -25,7 +25,16 @@
 class NotReadyError extends Error {
     source;
     constructor(r) {
+        // Control-flow throw: it happens on every read of a pending source, so in
+        // production skip V8's eager stack capture (proportional to stack depth —
+        // real cost under SSR) by zeroing the V8-specific stackTraceLimit around
+        // super(). Dev keeps the stack for debuggability; non-V8 engines (no
+        // stackTraceLimit) take the plain path.
+        const o = Error;
+        const t = o.stackTraceLimit;
+        if (t !== undefined) o.stackTraceLimit = 0;
         super();
+        if (t !== undefined) o.stackTraceLimit = t;
         this.source = r;
     }
 }

package/dist/prod/core/heap.js

@@ -20,14 +20,14 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
         return;
     }
     const E = queueFor(e);
-    if (E.Fe > e.He) E.Fe = e.He;
+    if (E.He > e.Fe) E.He = e.Fe;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.Ge?.ft ? e.Ge.Nt?.He : e.Ge?.He) ?? -1;
-    if (t >= e.He) e.He = t + 1;
-    const n = e.He;
+    const t = (e.Ge?.ft ? e.Ge.Nt?.Fe : e.Ge?.Fe) ?? -1;
+    if (t >= e.Fe) e.Fe = t + 1;
+    const n = e.Fe;
     const I = E.eE[n];
     if (I === undefined) E.eE[n] = e; else {
         const E = I.ut;
@@ -66,7 +66,7 @@ function deleteFromHeap(e, E) {
     const t = e.se;
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.se = t & -25;
-    const n = e.He;
+    const n = e.Fe;
     if (e.ut === e) E.eE[n] = undefined; else {
         const t = e.lt;
         const I = E.eE[n];
@@ -106,11 +106,11 @@ function markNode(e, E = REACTIVE_DIRTY) {
 
 function runHeap(e, E) {
     e.tE = false;
-    for (e.Fe = 0; e.Fe <= e.EE; e.Fe++) {
-        let t = e.eE[e.Fe];
+    for (e.He = 0; e.He <= e.EE; e.He++) {
+        let t = e.eE[e.He];
         while (t !== undefined) {
             if (t.se & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.Fe];
+            t = e.eE[e.He];
         }
     }
     e.EE = 0;
@@ -118,14 +118,14 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.He;
+    let t = e.Fe;
     for (let E = e.Xe; E; E = E.et) {
         const e = E.tt;
         const n = e.nt || e;
-        if (n.ke && n.He >= t) t = n.He + 1;
+        if (n.ke && n.Fe >= t) t = n.Fe + 1;
     }
-    if (e.He !== t) {
-        e.He = t;
+    if (e.Fe !== t) {
+        e.Fe = t;
         for (let E = e.o; E !== null; E = E.ue) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`

package/dist/prod/core/scheduler.js

@@ -19,14 +19,14 @@ const transitions = new Set;
 const dirtyQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Fe: 0,
+    He: 0,
     EE: 0
 };
 
 const zombieQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Fe: 0,
+    He: 0,
     EE: 0
 };
 
@@ -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.Fe || this.m.Qt.length > 0;
+                                        scheduled = dirtyQueue.EE >= dirtyQueue.He || 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.Fe) {
+                    if (dirtyQueue.EE >= dirtyQueue.He) {
                         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.Fe;
+                        scheduled = dirtyQueue.EE >= dirtyQueue.He;
             // Run lane effects first (for ready lanes), then regular effects
                         activeLanes.size && GlobalQueue.In(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
@@ -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.Fe;
+    const n = dirtyQueue.EE >= dirtyQueue.He;
     if (n) runHeap(dirtyQueue, GlobalQueue.pe);
     if (i) {
         if (n) commitPendingNodes();

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.He >= e.Fe && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.Fe >= e.He && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             prepareComputed(t, true);
         }

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

@@ -16,17 +16,17 @@ 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";
 
-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";
+    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 +35,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 +54,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 +66,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 +83,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 +108,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,8 +123,8 @@ function clearOptimisticStores(e, t) {
     }
 }
 
-function createOptimisticProjectionInternal(e, t, r) {
-    let i;
+function createOptimisticProjectionInternal(e, t, i) {
+    let r;
     const o = new WeakMap;
     const wrapper = e => {
         e[STORE_WRAP] = wrapProjection;
@@ -131,7 +133,7 @@ function createOptimisticProjectionInternal(e, t, r) {
  // Mark as optimistic store
                 Object.defineProperty(e, STORE_FIREWALL, {
             get() {
-                return i;
+                return r;
             },
             configurable: true
         });
@@ -165,19 +167,19 @@ function createOptimisticProjectionInternal(e, t, r) {
                 setProjectionWriteActive(t);
             }
         };
-        i = computed(() => {
+        r = computed(() => {
             setProjectionWriteActive(true);
             try {
-                runProjectionComputed(n, e, r?.key || "id", wrapCommit, clearProjectionOverride);
+                runProjectionComputed(n, 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
+        node: r
     };
 }