@solidjs/signals 2.0.0-rc.19 → 2.0.0-rc.20

package/dist/observe/map.js

@@ -16,7 +16,7 @@ import "./core/effect.js";
 
 import { accessor } from "./signals.js";
 
-import { $TRACK } from "./store/types.js";
+import { $TRACK, shallowView, $TARGET } from "./store/types.js";
 
 function mapArray(t, e, i) {
     const s = typeof i?.keyed === "function" ? i.keyed : undefined;
@@ -25,13 +25,13 @@ function mapArray(t, e, i) {
     const o = {
         H: createOwner(),
         wt: 0,
-        yt: t,
-        Mt: [],
-        Wt: r,
-        vt: [],
+        Mt: t,
+        Wt: [],
+        vt: r,
+        Kt: [],
         Ye: [],
-        Vt: s,
-        Kt: s || i?.keyed === false ? [] : undefined,
+        gt: s,
+        $t: s || i?.keyed === false ? [] : undefined,
         xt: n && i?.keyed !== false ? [] : undefined,
         Ut: i?.keyed === false,
         L: i?.fallback
@@ -48,7 +48,7 @@ const pureOptions = {
 };
 
 function trySmallMove(t, e, i, s) {
-    const n = t.Mt;
+    const n = t.Wt;
     const r = t.wt - 1;
     const o = [];
     const f = [];
@@ -74,29 +74,29 @@ function trySmallMove(t, e, i, s) {
         u = false;
         // Bounded realignment lookahead, shorter distance wins.
                 let d = -1;
-        let p = Math.min(32 - o.length, r - a, c);
-        for (let t = 1; t <= p; t++) {
+        let w = Math.min(32 - o.length, r - a, c);
+        for (let t = 1; t <= w; t++) {
             if (n[a + t] === s) {
                 d = t;
                 break;
             }
         }
-        c -= d === -1 ? p : d;
-        let w = -1;
-        p = Math.min(32 - f.length, i - 1 - l, c);
-        for (let i = 1; i <= p; i++) {
+        c -= d === -1 ? w : d;
+        let p = -1;
+        w = Math.min(32 - f.length, i - 1 - l, c);
+        for (let i = 1; i <= w; i++) {
             if (e[l + i] === t) {
-                w = i;
+                p = i;
                 break;
             }
         }
-        c -= w === -1 ? p : w;
-        if (d !== -1 && (w === -1 || d <= w)) {
+        c -= p === -1 ? w : p;
+        if (d !== -1 && (p === -1 || d <= p)) {
             while (d-- > 0) o.push(a++);
             continue;
         }
-        if (w !== -1) {
-            while (w-- > 0) f.push(l++);
+        if (p !== -1) {
+            while (p-- > 0) f.push(l++);
             continue;
         }
         if (c <= 0 || o.length === 32 || f.length === 32) return false;
@@ -121,7 +121,7 @@ function trySmallMove(t, e, i, s) {
  * body. Pairs displaced sources with destinations (an unmatched destination
  * is a replacement/insertion → general path), then commits: slice() the live
  * arrays, copy shifted runs, patch displaced pairs, dispose leftovers. */ function commitSmallMove(t, e, i, s, n, r) {
-    const o = t.Mt;
+    const o = t.Wt;
     let f;
     let h;
     let c;
@@ -156,7 +156,7 @@ function trySmallMove(t, e, i, s) {
             for (let s = 0, n = r[e + 2]; s < n; s++) if (t.has(o[i + s])) return false;
         }
     }
-    const a = t.vt;
+    const a = t.Kt;
     const l = t.Ye;
     const u = a.slice(0, i);
     const d = l.slice(0, i);
@@ -176,10 +176,10 @@ function trySmallMove(t, e, i, s) {
         u[t] = a[e];
         d[t] = l[e];
     }
-    t.vt = u;
+    t.Kt = u;
     t.Ye = d;
     t.wt = i;
-    t.Mt = e.slice(0);
+    t.Wt = e.slice(0);
     // Dispose unmatched sources LAST (general-path ordering).
         for (f = 0; f < s.length; f++) {
         if (c === undefined || !c[f]) l[s[f]].dispose();
@@ -195,22 +195,22 @@ function trySmallMove(t, e, i, s) {
  * the map path below starts from scratch (it rewrites every window slot of
  * `temp` / `rows` / `indexes`, so only `tempNodes`' `!== undefined` probe
  * needs the reset). The stage arrays are scratch — nothing live is touched. */ function stageRemoval(t, e, i, s, n, r, o, f, h) {
-    const c = t.Vt;
-    const a = t.Mt;
+    const c = t.gt;
+    const a = t.Wt;
     const l = t.Ye;
     const u = [];
     let d = i;
-    for (let p = i; p <= n; d++, p++) {
-        const n = c ? c(e[p]) : e[p];
+    for (let w = i; w <= n; d++, w++) {
+        const n = c ? c(e[w]) : e[w];
         while (d <= s && (c ? c(a[d]) : a[d]) !== n) u.push(l[d++]);
         if (d > s) {
             o.fill(undefined);
             return null;
         }
-        r[p] = t.vt[d];
-        o[p - i] = l[d];
-        if (f) f[p - i] = t.Kt[d];
-        if (h) h[p - i] = t.xt[d];
+        r[w] = t.Kt[d];
+        o[w - i] = l[d];
+        if (f) f[w - i] = t.$t[d];
+        if (h) h[w - i] = t.xt[d];
     }
     for (;d <= s; d++) u.push(l[d]);
     return u;
@@ -223,40 +223,40 @@ function trySmallMove(t, e, i, s) {
  * the JIT's optimization budget — the inlined commit measured ~10% slower on
  * full-window reorders (the small-move note has the same finding). */ function commitWindow(t, e, i, s, n, r, o, f, h) {
     const c = t.Ye;
-    const a = t.Kt;
+    const a = t.$t;
     const l = t.xt;
     const u = t.wt;
     const d = i - u;
-    let p, w;
+    let w, p;
     if (d > 0) {
         // Grow first: a store past the end from the top is a third slower than
         // filling a pre-sized tail (measured on 1k refs, 2026-10-15).
         c.length = i;
         if (a) a.length = i;
         if (l) l.length = i;
-        for (p = u - 1, w = i - 1; p > n; p--, w--) {
-            c[w] = c[p];
-            if (a) a[w] = a[p];
-            if (l) l[w] = l[p];
+        for (w = u - 1, p = i - 1; w > n; w--, p--) {
+            c[p] = c[w];
+            if (a) a[p] = a[w];
+            if (l) l[p] = l[w];
         }
     } else if (d < 0) {
-        for (p = n + 1, w = r + 1; p < u; p++, w++) {
-            c[w] = c[p];
-            if (a) a[w] = a[p];
-            if (l) l[w] = l[p];
+        for (w = n + 1, p = r + 1; w < u; w++, p++) {
+            c[p] = c[w];
+            if (a) a[p] = a[w];
+            if (l) l[p] = l[w];
         }
         c.length = i;
         if (a) a.length = i;
         if (l) l.length = i;
     }
-    for (w = s; w <= r; w++) {
-        c[w] = o[w - s];
-        if (a) setSignal(a[w] = f[w - s], e[w]);
-        if (l) setSignal(l[w] = h[w - s], w);
+    for (p = s; p <= r; p++) {
+        c[p] = o[p - s];
+        if (a) setSignal(a[p] = f[p - s], e[p]);
+        if (l) setSignal(l[p] = h[p - s], p);
     }
-    for (w = r + 1; w < i; w++) {
-        if (a) setSignal(a[w], e[w]);
-        if (l && d !== 0) setSignal(l[w], w);
+    for (p = r + 1; p < i; p++) {
+        if (a) setSignal(a[p], e[p]);
+        if (l && d !== 0) setSignal(l[p], p);
     }
 }
 
@@ -267,11 +267,15 @@ function updateKeyedMap() {
     // the flight's reader (pending tracking + post-settle retry) instead of
     // vanishing. Set per pass: the first pass runs inside `computed()`, before
     // the node exists to the caller.
-    this.H.ht = getOwner();
-    const t = this.yt() || [], e = t.length;
+    this.H.Ht = getOwner();
+    let t = this.Mt() || [];
     t[$TRACK];
  // top level tracking (a store array's container node)
-        runWithOwner(this.H, () => {
+    // A shallow store array diffs its backing: its slots are raw records, and
+    // a trap per slot read was most of a one-row write on a 1k-row list.
+        t = shallowView?.(t[$TARGET]) ?? t;
+    const e = t.length;
+    runWithOwner(this.H, () => {
         let i, s, 
         // The stage slot a mapper writes its row/index signal into: `j` on the
         // create-all path, `j - start` on the general path, whose stage arrays
@@ -279,44 +283,44 @@ function updateKeyedMap() {
         n, r, o, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        f = this.Kt ? this.Ut ? () => {
+        f = this.$t ? this.Ut ? () => {
             r[n] = signal(t[s], pureOptions);
-            return this.Wt(accessor(r[n]), s);
+            return this.vt(accessor(r[n]), s);
         } : () => {
             r[n] = signal(t[s], pureOptions);
             o && (o[n] = signal(s, pureOptions));
-            return this.Wt(accessor(r[n]), o ? accessor(o[n]) : undefined);
+            return this.vt(accessor(r[n]), o ? accessor(o[n]) : undefined);
         } : this.xt ? () => {
             const e = t[s];
             o[n] = signal(s, pureOptions);
-            return this.Wt(e, accessor(o[n]));
+            return this.vt(e, accessor(o[n]));
         } : () => {
             const e = t[s];
-            return this.Wt(e);
+            return this.vt(e);
         };
         // fast path for empty arrays
                 if (e === 0) {
             if (this.wt !== 0) {
                 this.H.dispose(false);
                 this.Ye = [];
-                this.Mt = [];
-                this.vt = [];
+                this.Wt = [];
+                this.Kt = [];
                 this.wt = 0;
-                this.Kt && (this.Kt = []);
+                this.$t && (this.$t = []);
                 this.xt && (this.xt = []);
             }
-            if (this.L && !this.vt.length) {
+            if (this.L && !this.Kt.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.Ye[0]?.dispose();
-                this.vt[0] = runWithOwner(this.Ye[0] = createOwner(), this.L);
+                this.Kt[0] = runWithOwner(this.Ye[0] = createOwner(), this.L);
             }
         }
         // fast path for new create
          else if (this.wt === 0) {
             const h = new Array(e);
             const c = new Array(e);
-            r = this.Kt && new Array(e);
+            r = this.$t && new Array(e);
             o = this.xt && new Array(e);
             try {
                 for (s = 0; s < e; s++) {
@@ -330,14 +334,14 @@ function updateKeyedMap() {
             // commit
                         if (this.Ye[0]) this.Ye[0].dispose();
  // previous fallback
-                        this.vt = h;
+                        this.Kt = h;
             this.Ye = c;
-            r && (this.Kt = r);
+            r && (this.$t = r);
             o && (this.xt = o);
-            this.Mt = t.slice(0);
+            this.Wt = t.slice(0);
             this.wt = e;
         } else {
-            let h, c, a, l, u, d, p, w, m, 
+            let h, c, a, l, u, d, w, p, m, 
             // Dev (attribution engine installed): the items behind the exited and
             // entered rows, for the list-identity census.
             O, _;
@@ -364,18 +368,18 @@ function updateKeyedMap() {
             // CARVE 2: the lane-slot arm (`_landOnOverride`, F1) went with the engine.
                         const y = setSignal;
             // skip common prefix
-                        for (h = 0, c = Math.min(this.wt, e); h < c && (this.Mt[h] === t[h] || this.Kt && compare(this.Vt, this.Mt[h], t[h])); h++) {
-                if (this.Kt) y(this.Kt[h], t[h]);
+                        for (h = 0, c = Math.min(this.wt, e); h < c && (this.Wt[h] === t[h] || this.$t && compare(this.gt, this.Wt[h], t[h])); h++) {
+                if (this.$t) y(this.$t[h], t[h]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (c = this.wt - 1, a = e - 1; c >= h && a >= h && (this.Mt[c] === t[a] || this.Kt && compare(this.Vt, this.Mt[c], t[a])); c--, 
+                        for (c = this.wt - 1, a = e - 1; c >= h && a >= h && (this.Wt[c] === t[a] || this.$t && compare(this.gt, this.Wt[c], t[a])); 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 (h === e && this.wt === e) {
-                this.Mt = t.slice(0);
+                this.Wt = t.slice(0);
                 return;
             }
             // SMALL-MOVE FAST PATH: extracted to its own function — inlining it
@@ -385,7 +389,7 @@ function updateKeyedMap() {
             // (plain removals, tail edits), the general path is window-
             // proportional and cheap — the fast path would only re-walk what the
             // trims proved.
-                        if (e <= this.wt && c - h > 64 && this.Kt === undefined && this.xt === undefined) {
+                        if (e <= this.wt && c - h > 64 && this.$t === undefined && this.xt === undefined) {
                 // PROBE before the scan: a small move keeps a mid-window item within
                 // ±32 of its old position; a REPLACE (all fresh items — the shape
                 // every page's first structural pass usually is) has it nowhere.
@@ -395,10 +399,10 @@ function updateKeyedMap() {
                 const s = t[i];
                 const n = Math.min(c, i + 32);
                 let r = Math.max(h, i - 32);
-                while (r <= n && this.Mt[r] !== s) r++;
+                while (r <= n && this.Wt[r] !== s) r++;
                 if (r <= n && trySmallMove(this, t, e, h)) return;
             }
-            const g = e - this.wt;
+            const A = e - this.wt;
             // WINDOW-SIZED STAGING, IN-PLACE COMMIT (2026-10-15). The strong-abort
             // contract (#2903) only needs the pass to touch nothing live before
             // every mapper has succeeded; it never needed four fresh newLen-sized
@@ -414,46 +418,46 @@ function updateKeyedMap() {
             // staging plus a position-sized chain array per commit (uibench's
             // one-item tree ops at 4–6× Octane, jfb-reorder `removefirst` at
             // 2.5×); now it stages one slot.
-                        const A = a - h + 1;
+                        const g = a - h + 1;
             const S = new Array(e);
-            const M = new Array(A);
-            r = this.Kt ? new Array(A) : undefined;
-            o = this.xt ? new Array(A) : undefined;
+            const M = new Array(g);
+            r = this.$t ? new Array(g) : undefined;
+            o = this.xt ? new Array(g) : undefined;
             // A shrinking pass is tried as a pure removal first (stageRemoval: no
             // key map, one key call per item); anything else takes the map path.
-                        const k = g < 0 ? stageRemoval(this, t, h, c, a, S, M, r, o) : null;
+                        const k = A < 0 ? stageRemoval(this, t, h, c, a, S, M, r, o) : null;
             if (k !== null) {
                 // (The list-churn census below wants removals AND creations in one
                 // pass; a pure removal has none, so no item ledger is kept here.)
-                if (k.length !== 0) w = k;
+                if (k.length !== 0) p = k;
             } else {
                 // 0) prepare a map of all indices in the changed window of newItems,
                 // scanning backwards so we encounter them in natural order
                 d = new Map;
-                p = new Array(A);
+                w = new Array(g);
                 for (s = a; s >= h; s--) {
                     l = t[s];
-                    u = this.Vt ? this.Vt(l) : l;
+                    u = this.gt ? this.gt(l) : l;
                     i = d.get(u);
-                    p[s - h] = i === undefined ? -1 : i;
+                    w[s - h] = i === undefined ? -1 : i;
                     d.set(u, s);
                 }
                 // 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 = h; i <= c; i++) {
-                    l = this.Mt[i];
-                    u = this.Vt ? this.Vt(l) : l;
+                    l = this.Wt[i];
+                    u = this.gt ? this.gt(l) : l;
                     s = d.get(u);
                     if (s !== undefined && s !== -1) {
-                        S[s] = this.vt[i];
+                        S[s] = this.Kt[i];
                         M[s - h] = this.Ye[i];
-                        r && (r[s - h] = this.Kt[i]);
+                        r && (r[s - h] = this.$t[i]);
                         o && (o[s - h] = this.xt[i]);
-                        s = p[s - h];
+                        s = w[s - h];
                         d.set(u, s);
                     } else {
-                        (w ??= []).push(this.Ye[i]);
+                        (p ??= []).push(this.Ye[i]);
                         if (true && attrHooks !== null) (O ??= []).push(l);
                     }
                 }
@@ -475,18 +479,18 @@ function updateKeyedMap() {
             // array; the bookkeeping arrays take the staged window IN PLACE (own
             // function: kept out of this body on purpose, see commitWindow); then
             // the exited rows dispose
-                        for (i = 0; i < h; i++) S[i] = this.vt[i];
-            for (s = a + 1; s < e; s++) S[s] = this.vt[s - g];
+                        for (i = 0; i < h; i++) S[i] = this.Kt[i];
+            for (s = a + 1; s < e; s++) S[s] = this.Kt[s - A];
             commitWindow(this, t, e, h, c, a, M, r, o);
-            this.vt = S;
+            this.Kt = S;
             this.wt = e;
             // save a copy of the mapped items for the next update
-                        this.Mt = t.slice(0);
-            if (w) for (i = 0; i < w.length; i++) w[i].dispose();
-            if (true && attrHooks !== null && O !== undefined && _ !== undefined) attrHooks.listChurn(this.H.ht, O, _, e, this.Vt !== undefined);
+                        this.Wt = t.slice(0);
+            if (p) for (i = 0; i < p.length; i++) p[i].dispose();
+            if (true && attrHooks !== null && O !== undefined && _ !== undefined) attrHooks.listChurn(this.H.Ht, O, _, e, this.gt !== undefined);
         }
     });
-    return this.vt;
+    return this.Kt;
 }
 
 /**
@@ -508,12 +512,12 @@ function updateKeyedMap() {
     const n = {
         H: createOwner(),
         wt: 0,
-        $t: 0,
-        qt: t,
-        Wt: s,
+        qt: 0,
+        zt: t,
+        vt: s,
         Ye: [],
-        vt: [],
-        zt: i?.from,
+        Kt: [],
+        Bt: i?.from,
         L: i?.fallback
     };
     const r = computed(updateRepeat.bind(n));
@@ -530,56 +534,56 @@ function updateKeyedMap() {
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
     // As in updateKeyedMap: the node is the row callbacks' reader, per pass.
-    this.H.ht = getOwner();
-    const t = this.qt();
-    const e = this.zt?.() || 0;
+    this.H.Ht = getOwner();
+    const t = this.zt();
+    const e = this.Bt?.() || 0;
     runWithOwner(this.H, () => {
         if (t === 0) {
             if (this.wt !== 0) {
                 this.H.dispose(false);
                 this.Ye = [];
-                this.vt = [];
+                this.Kt = [];
                 this.wt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.$t = 0;
+                                this.qt = 0;
             }
-            if (this.L && !this.vt.length) {
+            if (this.L && !this.Kt.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.Ye[0]?.dispose();
-                this.vt[0] = runWithOwner(this.Ye[0] = createOwner(), this.L);
+                this.Kt[0] = runWithOwner(this.Ye[0] = createOwner(), this.L);
             }
             return;
         }
         const i = e + t;
-        const s = this.$t + this.wt;
+        const s = this.qt + this.wt;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
-                const n = Math.max(e, this.$t);
+                const n = Math.max(e, this.qt);
         const r = Math.min(i, s);
         const o = new Array(t);
         const f = new Array(t);
         for (let t = n; t < r; t++) {
-            f[t - e] = this.Ye[t - this.$t];
-            o[t - e] = this.vt[t - this.$t];
+            f[t - e] = this.Ye[t - this.qt];
+            o[t - e] = this.Kt[t - this.qt];
         }
         try {
             for (let t = e; t < i; t++) {
                 if (t >= n && t < r) continue;
-                o[t - e] = runWithOwner(f[t - e] = createOwner(), () => this.Wt(t));
+                o[t - e] = runWithOwner(f[t - e] = createOwner(), () => this.vt(t));
             }
         } catch (t) {
             for (let t = e; t < i; t++) if ((t < n || t >= r) && f[t - e]) f[t - e].dispose();
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.wt === 0) this.Ye[0]?.dispose(); else for (let t = this.$t; t < s; t++) if (t < e || t >= i) this.Ye[t - this.$t].dispose();
-        this.vt = o;
+                if (this.wt === 0) this.Ye[0]?.dispose(); else for (let t = this.qt; t < s; t++) if (t < e || t >= i) this.Ye[t - this.qt].dispose();
+        this.Kt = o;
         this.Ye = f;
-        this.$t = e;
+        this.qt = e;
         this.wt = t;
     });
-    return this.vt;
+    return this.Kt;
 }
 
 function compare(t, e, i) {