@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.8

package/dist/prod/map.js

@@ -6,6 +6,8 @@ import "./core/scheduler.js";
 
 import { CONFIG_AUTO_DISPOSE } from "./core/constants.js";
 
+import { attrHooks } from "./core/attribution-hooks.js";
+
 import "./core/invariants.js";
 
 import "./core/verdict.js";
@@ -22,199 +24,358 @@ function mapArray(t, s, i) {
     const e = typeof i?.keyed === "function" ? i.keyed : undefined;
     const r = s.length > 1;
     const n = s;
-    const h = {
-        Kt: createOwner(),
-        $t: 0,
-        Jt: t,
-        Xt: [],
-        Yt: n,
-        Zt: [],
-        ts: [],
-        ss: e,
-        es: e || i?.keyed === false ? [] : undefined,
-        rs: r && i?.keyed !== false ? [] : undefined,
-        ns: i?.keyed === false,
-        hs: i?.fallback
+    const o = {
+        ts: createOwner(),
+        ss: 0,
+        es: t,
+        rs: [],
+        ns: n,
+        hs: [],
+        fs: [],
+        xt: e,
+        cs: e || i?.keyed === false ? [] : undefined,
+        ls: r && i?.keyed !== false ? [] : undefined,
+        us: i?.keyed === false,
+        ps: i?.fallback
     };
-    const o = computed(updateKeyedMap.bind(h));
+    const h = computed(updateKeyedMap.bind(o), undefined);
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
     // them through node lets store-proxy lookups see pending writes (not stale _value).
-        h.Kt.Dt = o;
-    o.T &= ~CONFIG_AUTO_DISPOSE;
-    return accessor(o);
+        o.ts.bt = h;
+    h.T &= ~CONFIG_AUTO_DISPOSE;
+    return accessor(h);
 }
 
 const pureOptions = {
     ownedWrite: true
 };
 
-// Exception safety (#2903): a map callback can throw NotReadyError mid-pass
-// (async read), and the computed re-runs the whole pass after settle. Every
-// pass therefore STAGES its work — new rows are created into temp arrays and
-// removals are deferred — and commits to `this` only after every mapper
-// succeeded. An aborted pass disposes just the owners it created and leaves
-// `_items`/`_mappings`/`_nodes`/`_rows`/`_indexes`/`_len` exactly as they
-// were, so the retry diffs against uncorrupted state. Consequence of the
-// strong-abort ordering: removed rows now dispose AFTER the pass's new rows
-// are created (you cannot destroy state before knowing the pass will land).
+function trySmallMove(t, s, i, e) {
+    const r = t.rs;
+    const n = t.ss - 1;
+    const o = [];
+    const h = [];
+    const f = [];
+ // flat triples: oldStart, newStart, length
+        let c = 256;
+    let a = e;
+    let l = e;
+    let u = false;
+    while (a <= n && l <= i - 1) {
+        const t = r[a];
+        const e = s[l];
+        if (t === e) {
+            if (!u) {
+                f.push(a, l, 0);
+                u = true;
+            }
+            f[f.length - 1]++;
+            a++;
+            l++;
+            continue;
+        }
+        u = false;
+        // Bounded realignment lookahead, shorter distance wins.
+                let p = -1;
+        let d = Math.min(32 - o.length, n - a, c);
+        for (let t = 1; t <= d; t++) {
+            if (r[a + t] === e) {
+                p = t;
+                break;
+            }
+        }
+        c -= p === -1 ? d : p;
+        let w = -1;
+        d = Math.min(32 - h.length, i - 1 - l, c);
+        for (let i = 1; i <= d; i++) {
+            if (s[l + i] === t) {
+                w = i;
+                break;
+            }
+        }
+        c -= w === -1 ? d : w;
+        if (p !== -1 && (w === -1 || p <= w)) {
+            while (p-- > 0) o.push(a++);
+            continue;
+        }
+        if (w !== -1) {
+            while (w-- > 0) h.push(l++);
+            continue;
+        }
+        if (c <= 0 || o.length === 32 || h.length === 32) return false;
+        o.push(a++);
+        h.push(l++);
+    }
+    for (;a <= n; a++) {
+        if (o.length === 32) return false;
+        o.push(a);
+    }
+    for (;l <= i - 1; l++) {
+        if (h.length === 32) return false;
+        h.push(l);
+    }
+    return commitSmallMove(t, s, i, o, h, f);
+}
+
+/** PHASE 2 of the small-move path, in its OWN function so that a pass which
+ * only SCANS and bails (a full replace: the first structural pass of a page,
+ * typically) compiles nothing but the scan — V8 parses and compiles lazily
+ * per function, and cold `replace` measured +0.5 ms with both phases in one
+ * 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, s, i, e, r, n) {
+    const o = t.rs;
+    let h;
+    let f;
+    let c;
+    if (r.length !== 0) {
+        c = new Array(e.length);
+        for (f = 0; f < r.length; f++) {
+            let t = -1;
+            for (h = 0; h < e.length; h++) {
+                if (!c[h] && o[e[h]] === s[r[f]]) {
+                    t = h;
+                    break;
+                }
+            }
+            if (t === -1) return false;
+            c[t] = true;
+            r[f] = r[f] << 6 | t;
+ // pack pairing (found < 32)
+                }
+    }
+    // DUPLICATES: the general path pairs equal identities by OCCURRENCE ORDER
+    // (the chained index map). Displaced↔displaced pairing above is ascending
+    // on both sides, so it agrees; but an aligned run was matched by POSITION,
+    // and if a displaced identity also occurs inside a run the two algorithms
+    // can hand different occurrences different owners (row-local state moves;
+    // a shrink could dispose the wrong one). Decline that case — general path.
+        if (e.length !== 0 || r.length !== 0) {
+        const t = new Set;
+        for (h = 0; h < e.length; h++) t.add(o[e[h]]);
+        for (f = 0; f < r.length; f++) t.add(s[r[f] >> 6]);
+        for (let s = 0; s < n.length; s += 3) {
+            const i = n[s];
+            for (let e = 0, r = n[s + 2]; e < r; e++) if (t.has(o[i + e])) return false;
+        }
+    }
+    const a = t.hs;
+    const l = t.fs;
+    const u = a.slice(0, i);
+    const p = l.slice(0, i);
+    for (let t = 0; t < n.length; t += 3) {
+        const s = n[t];
+        const i = n[t + 1];
+        if (s !== i) {
+            for (let e = 0; e < n[t + 2]; e++) {
+                u[i + e] = a[s + e];
+                p[i + e] = l[s + e];
+            }
+        }
+    }
+    for (f = 0; f < r.length; f++) {
+        const t = r[f] >> 6;
+        const s = e[r[f] & 63];
+        u[t] = a[s];
+        p[t] = l[s];
+    }
+    t.hs = u;
+    t.fs = p;
+    t.ss = i;
+    t.rs = s.slice(0);
+    // Dispose unmatched sources LAST (general-path ordering).
+        for (h = 0; h < e.length; h++) {
+        if (c === undefined || !c[h]) l[e[h]].dispose();
+    }
+    return true;
+}
+
 function updateKeyedMap() {
-    const t = this.Jt() || [], s = t.length;
+    const t = this.es() || [], s = t.length;
     t[$TRACK];
  // top level tracking
-        runWithOwner(this.Kt, () => {
+        runWithOwner(this.ts, () => {
         let i, e, r, n, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        h = this.es ? this.ns ? () => {
+        o = this.cs ? this.us ? () => {
             r[e] = signal(t[e], pureOptions);
-            return this.Yt(accessor(r[e]), e);
+            return this.ns(accessor(r[e]), e);
         } : () => {
             r[e] = signal(t[e], pureOptions);
             n && (n[e] = signal(e, pureOptions));
-            return this.Yt(accessor(r[e]), n ? accessor(n[e]) : undefined);
-        } : this.rs ? () => {
+            return this.ns(accessor(r[e]), n ? accessor(n[e]) : undefined);
+        } : this.ls ? () => {
             const s = t[e];
             n[e] = signal(e, pureOptions);
-            return this.Yt(s, accessor(n[e]));
+            return this.ns(s, accessor(n[e]));
         } : () => {
             const s = t[e];
-            return this.Yt(s);
+            return this.ns(s);
         };
         // fast path for empty arrays
                 if (s === 0) {
-            if (this.$t !== 0) {
-                this.Kt.dispose(false);
-                this.ts = [];
-                this.Xt = [];
-                this.Zt = [];
-                this.$t = 0;
-                this.es && (this.es = []);
-                this.rs && (this.rs = []);
+            if (this.ss !== 0) {
+                this.ts.dispose(false);
+                this.fs = [];
+                this.rs = [];
+                this.hs = [];
+                this.ss = 0;
+                this.cs && (this.cs = []);
+                this.ls && (this.ls = []);
             }
-            if (this.hs && !this.Zt[0]) {
+            if (this.ps && !this.hs[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.ts[0]?.dispose();
-                this.Zt[0] = runWithOwner(this.ts[0] = createOwner(), this.hs);
+                this.fs[0]?.dispose();
+                this.hs[0] = runWithOwner(this.fs[0] = createOwner(), this.ps);
             }
         }
         // fast path for new create
-         else if (this.$t === 0) {
-            const o = new Array(s);
-            const c = new Array(s);
-            r = this.es && new Array(s);
-            n = this.rs && new Array(s);
+         else if (this.ss === 0) {
+            const h = new Array(s);
+            const f = new Array(s);
+            r = this.cs && new Array(s);
+            n = this.ls && new Array(s);
             try {
-                for (e = 0; e < s; e++) o[e] = runWithOwner(c[e] = createOwner(), h);
+                for (e = 0; e < s; e++) h[e] = runWithOwner(f[e] = createOwner(), o);
             } catch (t) {
-                for (i = 0; i <= e; i++) c[i]?.dispose();
+                for (i = 0; i <= e; i++) f[i]?.dispose();
                 throw t;
             }
             // commit
-                        if (this.ts[0]) this.ts[0].dispose();
+                        if (this.fs[0]) this.fs[0].dispose();
  // previous fallback
-                        this.Zt = o;
-            this.ts = c;
-            r && (this.es = r);
-            n && (this.rs = n);
-            this.Xt = t.slice(0);
-            this.$t = s;
+                        this.hs = h;
+            this.fs = f;
+            r && (this.cs = r);
+            n && (this.ls = n);
+            this.rs = t.slice(0);
+            this.ss = s;
         } else {
-            let o, c, a, f, u, p, w, l, d;
+            let h, f, c, a, l, u, p, d, w, 
+            // Dev (attribution engine installed): the items behind the exited and
+            // entered rows, for the list-identity census.
+            m, O;
             // skip common prefix
-                        for (o = 0, c = Math.min(this.$t, s); o < c && (this.Xt[o] === t[o] || this.es && compare(this.ss, this.Xt[o], t[o])); o++) {
-                if (this.es) setSignal(this.es[o], t[o]);
+                        for (h = 0, f = Math.min(this.ss, s); h < f && (this.rs[h] === t[h] || this.cs && compare(this.xt, this.rs[h], t[h])); h++) {
+                if (this.cs) setSignal(this.cs[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.$t - 1, a = s - 1; c >= o && a >= o && (this.Xt[c] === t[a] || this.es && compare(this.ss, this.Xt[c], t[a])); c--, 
-            a--) ;
+                        for (f = this.ss - 1, c = s - 1; f >= h && c >= h && (this.rs[f] === t[c] || this.cs && compare(this.xt, this.rs[f], t[c])); f--, 
+            c--) ;
             // 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.$t === s) {
-                this.Xt = t.slice(0);
+                        if (h === s && this.ss === s) {
+                this.rs = t.slice(0);
                 return;
             }
-            const O = s - this.$t;
-            const m = new Array(s);
-            const _ = new Array(s);
-            r = this.es ? new Array(s) : undefined;
-            n = this.rs ? new Array(s) : undefined;
+            // SMALL-MOVE FAST PATH: extracted to its own function — inlining it
+            // here bloats updateKeyedMap past the JIT's optimization budget and
+            // deoptimizes the GENERAL path (measured 2x on reverse). Gated to
+            // LARGE trimmed windows: when the trims already shrank the window
+            // (plain removals, tail edits), the general path is window-
+            // proportional and cheap — the fast path would only re-walk what the
+            // trims proved.
+                        if (s <= this.ss && f - h > 64 && this.cs === undefined && this.ls === 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.
+                // ~65 compares, no allocation, and the scan function is never
+                // compiled for a replace (its cold first-call compile was the cost).
+                const i = h + (c - h >> 1);
+                const e = t[i];
+                const r = Math.min(f, i + 32);
+                let n = Math.max(h, i - 32);
+                while (n <= r && this.rs[n] !== e) n++;
+                if (n <= r && trySmallMove(this, t, s, h)) return;
+            }
+            const _ = s - this.ss;
+            const y = new Array(s);
+            const A = new Array(s);
+            r = this.cs ? new Array(s) : undefined;
+            n = this.ls ? 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--) {
-                f = t[e];
-                u = this.ss ? this.ss(f) : f;
-                i = p.get(u);
-                w[e] = i === undefined ? -1 : i;
-                p.set(u, e);
+                        u = new Map;
+            p = new Array(c + 1);
+            for (e = c; e >= h; e--) {
+                a = t[e];
+                l = this.xt ? this.xt(a) : a;
+                i = u.get(l);
+                p[e] = i === undefined ? -1 : i;
+                u.set(l, e);
             }
             // 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.Xt[i];
-                u = this.ss ? this.ss(f) : f;
-                e = p.get(u);
+                        for (i = h; i <= f; i++) {
+                a = this.rs[i];
+                l = this.xt ? this.xt(a) : a;
+                e = u.get(l);
                 if (e !== undefined && e !== -1) {
-                    m[e] = this.Zt[i];
-                    _[e] = this.ts[i];
-                    r && (r[e] = this.es[i]);
-                    n && (n[e] = this.rs[i]);
-                    e = w[e];
-                    p.set(u, e);
-                } else (l ??= []).push(this.ts[i]);
+                    y[e] = this.hs[i];
+                    A[e] = this.fs[i];
+                    r && (r[e] = this.cs[i]);
+                    n && (n[e] = this.ls[i]);
+                    e = p[e];
+                    u.set(l, e);
+                } else {
+                    (d ??= []).push(this.fs[i]);
+                    if (false && attrHooks !== null) ;
+                }
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
-                for (e = o; e <= a; e++) {
-                    if (_[e] !== undefined) continue;
-                    (d ??= []).push(_[e] = createOwner());
-                    m[e] = runWithOwner(_[e], h);
+                for (e = h; e <= c; e++) {
+                    if (A[e] !== undefined) continue;
+                    (w ??= []).push(A[e] = createOwner());
+                    if (false && attrHooks !== null) ;
+                    y[e] = runWithOwner(A[e], o);
                 }
             } catch (t) {
-                if (d) for (i = 0; i < d.length; i++) d[i].dispose();
+                if (w) for (i = 0; i < w.length; i++) w[i].dispose();
                 throw t;
             }
             // 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.Zt[i];
-                _[i] = this.ts[i];
-                r && (r[i] = this.es[i]);
-                n && (n[i] = this.rs[i]);
+                        for (i = 0; i < h; i++) {
+                y[i] = this.hs[i];
+                A[i] = this.fs[i];
+                r && (r[i] = this.cs[i]);
+                n && (n[i] = this.ls[i]);
             }
-            for (e = o; e <= a; e++) {
+            for (e = h; e <= c; e++) {
                 if (r) setSignal(r[e], t[e]);
                 if (n) setSignal(n[e], e);
             }
-            for (e = a + 1; e < s; e++) {
-                m[e] = this.Zt[e - O];
-                _[e] = this.ts[e - O];
+            for (e = c + 1; e < s; e++) {
+                y[e] = this.hs[e - _];
+                A[e] = this.fs[e - _];
                 if (r) {
-                    r[e] = this.es[e - O];
+                    r[e] = this.cs[e - _];
                     setSignal(r[e], t[e]);
                 }
                 if (n) {
-                    n[e] = this.rs[e - O];
-                    if (O !== 0) setSignal(n[e], e);
+                    n[e] = this.ls[e - _];
+                    if (_ !== 0) setSignal(n[e], e);
                 }
             }
-            this.Zt = m;
-            this.ts = _;
-            r && (this.es = r);
-            n && (this.rs = n);
-            this.$t = s;
+            this.hs = y;
+            this.fs = A;
+            r && (this.cs = r);
+            n && (this.ls = n);
+            this.ss = s;
             // save a copy of the mapped items for the next update
-                        this.Xt = t.slice(0);
-            if (l) for (i = 0; i < l.length; i++) l[i].dispose();
+                        this.rs = t.slice(0);
+            if (d) for (i = 0; i < d.length; i++) d[i].dispose();
+            if (false && attrHooks !== null && m !== undefined && O !== undefined) ;
         }
     });
-    return this.Zt;
+    return this.hs;
 }
 
 /**
@@ -234,21 +395,21 @@ function updateKeyedMap() {
  */ function repeat(t, s, i) {
     const e = s;
     const r = {
-        Kt: createOwner(),
-        $t: 0,
-        cs: 0,
-        fs: t,
-        Yt: e,
-        ts: [],
-        Zt: [],
-        us: i?.from,
-        hs: i?.fallback
+        ts: createOwner(),
+        ss: 0,
+        ds: 0,
+        ws: t,
+        ns: e,
+        fs: [],
+        hs: [],
+        Os: i?.from,
+        ps: i?.fallback
     };
     const n = computed(updateRepeat.bind(r));
     // Same as mapArray: untracked reads inside the internal owner resolve via
     // _parentComputed, so async reads in row callbacks register with the node
     // (pending tracking + post-settle retry) instead of vanishing.
-        r.Kt.Dt = n;
+        r.ts.bt = n;
     n.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
@@ -261,55 +422,55 @@ function updateKeyedMap() {
 // for the post-settle retry. The overlap math also subsumes the previous
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
-    const t = this.fs();
-    const s = this.us?.() || 0;
-    runWithOwner(this.Kt, () => {
+    const t = this.ws();
+    const s = this.Os?.() || 0;
+    runWithOwner(this.ts, () => {
         if (t === 0) {
-            if (this.$t !== 0) {
-                this.Kt.dispose(false);
-                this.ts = [];
-                this.Zt = [];
-                this.$t = 0;
+            if (this.ss !== 0) {
+                this.ts.dispose(false);
+                this.fs = [];
+                this.hs = [];
+                this.ss = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.cs = 0;
+                                this.ds = 0;
             }
-            if (this.hs && !this.Zt[0]) {
+            if (this.ps && !this.hs[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.ts[0]?.dispose();
-                this.Zt[0] = runWithOwner(this.ts[0] = createOwner(), this.hs);
+                this.fs[0]?.dispose();
+                this.hs[0] = runWithOwner(this.fs[0] = createOwner(), this.ps);
             }
             return;
         }
         const i = s + t;
-        const e = this.cs + this.$t;
+        const e = this.ds + this.ss;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
-                const r = Math.max(s, this.cs);
+                const r = Math.max(s, this.ds);
         const n = Math.min(i, e);
-        const h = new Array(t);
         const o = new Array(t);
+        const h = new Array(t);
         for (let t = r; t < n; t++) {
-            o[t - s] = this.ts[t - this.cs];
-            h[t - s] = this.Zt[t - this.cs];
+            h[t - s] = this.fs[t - this.ds];
+            o[t - s] = this.hs[t - this.ds];
         }
         try {
             for (let t = s; t < i; t++) {
                 if (t >= r && t < n) continue;
-                h[t - s] = runWithOwner(o[t - s] = createOwner(), () => this.Yt(t));
+                o[t - s] = runWithOwner(h[t - s] = createOwner(), () => this.ns(t));
             }
         } catch (t) {
-            for (let t = s; t < i; t++) if ((t < r || t >= n) && o[t - s]) o[t - s].dispose();
+            for (let t = s; t < i; t++) if ((t < r || t >= n) && h[t - s]) h[t - s].dispose();
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.$t === 0) this.ts[0]?.dispose(); else for (let t = this.cs; t < e; t++) if (t < s || t >= i) this.ts[t - this.cs].dispose();
-        this.Zt = h;
-        this.ts = o;
-        this.cs = s;
-        this.$t = t;
+                if (this.ss === 0) this.fs[0]?.dispose(); else for (let t = this.ds; t < e; t++) if (t < s || t >= i) this.fs[t - this.ds].dispose();
+        this.hs = o;
+        this.fs = h;
+        this.ds = s;
+        this.ss = t;
     });
-    return this.Zt;
+    return this.hs;
 }
 
 function compare(t, s, i) {