@solidjs/signals 2.0.0-rc.15 → 2.0.0-rc.17

package/dist/prod/map.js

@@ -16,98 +16,98 @@ import { accessor } from "./signals.js";
 
 import { $TRACK } from "./store/types.js";
 
-function mapArray(t, s, e) {
-    const i = typeof e?.keyed === "function" ? e.keyed : undefined;
-    const r = s.length > 1;
-    const n = s;
+function mapArray(t, e, i) {
+    const s = typeof i?.keyed === "function" ? i.keyed : undefined;
+    const n = e.length > 1;
+    const r = e;
     const o = {
         L: createOwner(),
-        ht: 0,
-        dt: t,
-        wt: [],
-        Ot: n,
-        yt: [],
-        ln: [],
-        ot: i,
-        At: i || e?.keyed === false ? [] : undefined,
-        Mt: r && e?.keyed !== false ? [] : undefined,
-        gt: e?.keyed === false,
-        v: e?.fallback
+        it: 0,
+        st: t,
+        ot: [],
+        ft: r,
+        ht: [],
+        tn: [],
+        ze: s,
+        ct: s || i?.keyed === false ? [] : undefined,
+        lt: n && i?.keyed !== false ? [] : undefined,
+        ut: i?.keyed === false,
+        H: i?.fallback
     };
-    const h = computed(updateKeyedMap.bind(o), undefined);
-    h.i &= ~CONFIG_AUTO_DISPOSE;
-    return accessor(h);
+    const f = computed(updateKeyedMap.bind(o), undefined);
+    f.l &= ~CONFIG_AUTO_DISPOSE;
+    return accessor(f);
 }
 
 const pureOptions = {
     ownedWrite: true
 };
 
-function trySmallMove(t, s, e, i) {
-    const r = t.wt;
-    const n = t.ht - 1;
+function trySmallMove(t, e, i, s) {
+    const n = t.ot;
+    const r = t.it - 1;
     const o = [];
-    const h = [];
     const f = [];
+    const h = [];
  // flat triples: oldStart, newStart, length
         let c = 256;
-    let a = i;
-    let u = i;
-    let l = false;
-    while (a <= n && u <= e - 1) {
-        const t = r[a];
-        const i = s[u];
-        if (t === i) {
-            if (!l) {
-                f.push(a, u, 0);
-                l = true;
+    let a = s;
+    let l = s;
+    let u = false;
+    while (a <= r && l <= i - 1) {
+        const t = n[a];
+        const s = e[l];
+        if (t === s) {
+            if (!u) {
+                h.push(a, l, 0);
+                u = true;
             }
-            f[f.length - 1]++;
+            h[h.length - 1]++;
             a++;
-            u++;
+            l++;
             continue;
         }
-        l = false;
+        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] === i) {
-                p = t;
+                let d = -1;
+        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 -= p === -1 ? d : p;
-        let w = -1;
-        d = Math.min(32 - h.length, e - 1 - u, c);
-        for (let e = 1; e <= d; e++) {
-            if (s[u + e] === t) {
-                w = e;
+        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) {
+                p = i;
                 break;
             }
         }
-        c -= w === -1 ? d : w;
-        if (p !== -1 && (w === -1 || p <= w)) {
-            while (p-- > 0) o.push(a++);
+        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) h.push(u++);
+        if (p !== -1) {
+            while (p-- > 0) f.push(l++);
             continue;
         }
-        if (c <= 0 || o.length === 32 || h.length === 32) return false;
+        if (c <= 0 || o.length === 32 || f.length === 32) return false;
         o.push(a++);
-        h.push(u++);
+        f.push(l++);
     }
-    for (;a <= n; a++) {
+    for (;a <= r; a++) {
         if (o.length === 32) return false;
         o.push(a);
     }
-    for (;u <= e - 1; u++) {
-        if (h.length === 32) return false;
-        h.push(u);
+    for (;l <= i - 1; l++) {
+        if (f.length === 32) return false;
+        f.push(l);
     }
-    return commitSmallMove(t, s, e, o, h, f);
+    return commitSmallMove(t, e, i, o, f, h);
 }
 
 /** PHASE 2 of the small-move path, in its OWN function so that a pass which
@@ -116,24 +116,24 @@ function trySmallMove(t, s, e, i) {
  * 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, e, i, r, n) {
-    const o = t.wt;
-    let h;
+ * arrays, copy shifted runs, patch displaced pairs, dispose leftovers. */ function commitSmallMove(t, e, i, s, n, r) {
+    const o = t.ot;
     let f;
+    let h;
     let c;
-    if (r.length !== 0) {
-        c = new Array(i.length);
-        for (f = 0; f < r.length; f++) {
+    if (n.length !== 0) {
+        c = new Array(s.length);
+        for (h = 0; h < n.length; h++) {
             let t = -1;
-            for (h = 0; h < i.length; h++) {
-                if (!c[h] && o[i[h]] === s[r[f]]) {
-                    t = h;
+            for (f = 0; f < s.length; f++) {
+                if (!c[f] && o[s[f]] === e[n[h]]) {
+                    t = f;
                     break;
                 }
             }
             if (t === -1) return false;
             c[t] = true;
-            r[f] = r[f] << 6 | t;
+            n[h] = n[h] << 6 | t;
  // pack pairing (found < 32)
                 }
     }
@@ -143,46 +143,119 @@ function trySmallMove(t, s, e, i) {
     // 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 (i.length !== 0 || r.length !== 0) {
+        if (s.length !== 0 || n.length !== 0) {
         const t = new Set;
-        for (h = 0; h < i.length; h++) t.add(o[i[h]]);
-        for (f = 0; f < r.length; f++) t.add(s[r[f] >> 6]);
-        for (let s = 0; s < n.length; s += 3) {
-            const e = n[s];
-            for (let i = 0, r = n[s + 2]; i < r; i++) if (t.has(o[e + i])) return false;
+        for (f = 0; f < s.length; f++) t.add(o[s[f]]);
+        for (h = 0; h < n.length; h++) t.add(e[n[h] >> 6]);
+        for (let e = 0; e < r.length; e += 3) {
+            const i = r[e];
+            for (let s = 0, n = r[e + 2]; s < n; s++) if (t.has(o[i + s])) return false;
         }
     }
-    const a = t.yt;
-    const u = t.ln;
-    const l = a.slice(0, e);
-    const p = u.slice(0, e);
-    for (let t = 0; t < n.length; t += 3) {
-        const s = n[t];
-        const e = n[t + 1];
-        if (s !== e) {
-            for (let i = 0; i < n[t + 2]; i++) {
-                l[e + i] = a[s + i];
-                p[e + i] = u[s + i];
+    const a = t.ht;
+    const l = t.tn;
+    const u = a.slice(0, i);
+    const d = l.slice(0, i);
+    for (let t = 0; t < r.length; t += 3) {
+        const e = r[t];
+        const i = r[t + 1];
+        if (e !== i) {
+            for (let s = 0; s < r[t + 2]; s++) {
+                u[i + s] = a[e + s];
+                d[i + s] = l[e + s];
             }
         }
     }
-    for (f = 0; f < r.length; f++) {
-        const t = r[f] >> 6;
-        const s = i[r[f] & 63];
-        l[t] = a[s];
-        p[t] = u[s];
+    for (h = 0; h < n.length; h++) {
+        const t = n[h] >> 6;
+        const e = s[n[h] & 63];
+        u[t] = a[e];
+        d[t] = l[e];
     }
-    t.yt = l;
-    t.ln = p;
-    t.ht = e;
-    t.wt = s.slice(0);
+    t.ht = u;
+    t.tn = d;
+    t.it = i;
+    t.ot = e.slice(0);
     // Dispose unmatched sources LAST (general-path ordering).
-        for (h = 0; h < i.length; h++) {
-        if (c === undefined || !c[h]) u[i[h]].dispose();
+        for (f = 0; f < s.length; f++) {
+        if (c === undefined || !c[f]) l[s[f]].dispose();
     }
     return true;
 }
 
+/** Stage a PURE REMOVAL without the key map: when the new window is the old
+ * window with items dropped, in order (one-item removals, every-nth, the
+ * table filters), a two-pointer walk lands every survivor in the window
+ * stage with one key call per item and returns the leavers; a shape that is
+ * not an ordered subsequence returns null with the node stage cleared, and
+ * 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.ze;
+    const a = t.ot;
+    const l = t.tn;
+    const u = [];
+    let d = i;
+    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[w] = t.ht[d];
+        o[w - i] = l[d];
+        if (f) f[w - i] = t.ct[d];
+        if (h) h[w - i] = t.lt[d];
+    }
+    for (;d <= s; d++) u.push(l[d]);
+    return u;
+}
+
+/** Land a staged window into the live bookkeeping arrays in place: shift the
+ * suffix by `dif` (a loop walked from the side that never overwrites an
+ * unread slot), take the window from the stage, write survivors' row and
+ * index signals. Its own function so the general path's body stays under
+ * 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.tn;
+    const a = t.ct;
+    const l = t.lt;
+    const u = t.it;
+    const d = i - u;
+    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 (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 (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 (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 (p = r + 1; p < i; p++) {
+        if (a) setSignal(a[p], e[p]);
+        if (l && d !== 0) setSignal(l[p], p);
+    }
+}
+
 function updateKeyedMap() {
     // Untracked reads inside the internal owner resolve via _parentComputed:
     // routed through the node, a store-proxy lookup sees pending writes (not a
@@ -190,73 +263,80 @@ 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.L.et = getOwner();
-    const t = this.dt() || [], s = t.length;
+    this.L.Ye = getOwner();
+    const t = this.st() || [], e = t.length;
     t[$TRACK];
  // top level tracking (a store array's container node)
         runWithOwner(this.L, () => {
-        let e, i, r, n, 
+        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
+        // are sized to the changed WINDOW, not the list.
+        n, r, o, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        o = this.At ? this.gt ? () => {
-            r[i] = signal(t[i], pureOptions);
-            return this.Ot(accessor(r[i]), i);
+        f = this.ct ? this.ut ? () => {
+            r[n] = signal(t[s], pureOptions);
+            return this.ft(accessor(r[n]), s);
         } : () => {
-            r[i] = signal(t[i], pureOptions);
-            n && (n[i] = signal(i, pureOptions));
-            return this.Ot(accessor(r[i]), n ? accessor(n[i]) : undefined);
-        } : this.Mt ? () => {
-            const s = t[i];
-            n[i] = signal(i, pureOptions);
-            return this.Ot(s, accessor(n[i]));
+            r[n] = signal(t[s], pureOptions);
+            o && (o[n] = signal(s, pureOptions));
+            return this.ft(accessor(r[n]), o ? accessor(o[n]) : undefined);
+        } : this.lt ? () => {
+            const e = t[s];
+            o[n] = signal(s, pureOptions);
+            return this.ft(e, accessor(o[n]));
         } : () => {
-            const s = t[i];
-            return this.Ot(s);
+            const e = t[s];
+            return this.ft(e);
         };
         // fast path for empty arrays
-                if (s === 0) {
-            if (this.ht !== 0) {
+                if (e === 0) {
+            if (this.it !== 0) {
                 this.L.dispose(false);
-                this.ln = [];
-                this.wt = [];
-                this.yt = [];
-                this.ht = 0;
-                this.At && (this.At = []);
-                this.Mt && (this.Mt = []);
+                this.tn = [];
+                this.ot = [];
+                this.ht = [];
+                this.it = 0;
+                this.ct && (this.ct = []);
+                this.lt && (this.lt = []);
             }
-            if (this.v && !this.yt[0]) {
+            if (this.H && !this.ht.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.ln[0]?.dispose();
-                this.yt[0] = runWithOwner(this.ln[0] = createOwner(), this.v);
+                this.tn[0]?.dispose();
+                this.ht[0] = runWithOwner(this.tn[0] = createOwner(), this.H);
             }
         }
         // fast path for new create
-         else if (this.ht === 0) {
-            const h = new Array(s);
-            const f = new Array(s);
-            r = this.At && new Array(s);
-            n = this.Mt && new Array(s);
+         else if (this.it === 0) {
+            const h = new Array(e);
+            const c = new Array(e);
+            r = this.ct && new Array(e);
+            o = this.lt && new Array(e);
             try {
-                for (i = 0; i < s; i++) h[i] = runWithOwner(f[i] = createOwner(), o);
+                for (s = 0; s < e; s++) {
+                    n = s;
+                    h[s] = runWithOwner(c[s] = createOwner(), f);
+                }
             } catch (t) {
-                for (e = 0; e <= i; e++) f[e]?.dispose();
+                for (i = 0; i <= s; i++) c[i]?.dispose();
                 throw t;
             }
             // commit
-                        if (this.ln[0]) this.ln[0].dispose();
+                        if (this.tn[0]) this.tn[0].dispose();
  // previous fallback
-                        this.yt = h;
-            this.ln = f;
-            r && (this.At = r);
-            n && (this.Mt = n);
-            this.wt = t.slice(0);
-            this.ht = s;
+                        this.ht = h;
+            this.tn = c;
+            r && (this.ct = r);
+            o && (this.lt = o);
+            this.ot = t.slice(0);
+            this.it = e;
         } else {
-            let h, f, c, a, u, l, p, d, w, 
+            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.
-            m, O;
+            O, _;
             // The pass's write to a per-slot signal (a row accessor in index mode,
             // an index accessor in keyed mode). The list's frame lives in these
             // writes as much as in the computed's result, so under a LANE pass they
@@ -278,20 +358,20 @@ function updateKeyedMap() {
             // takes `setSignal` directly. The engine is installed whenever a lane
             // is active.
             // CARVE 2: the lane-slot arm (`_landOnOverride`, F1) went with the engine.
-                        const _ = setSignal;
+                        const y = setSignal;
             // skip common prefix
-                        for (h = 0, f = Math.min(this.ht, s); h < f && (this.wt[h] === t[h] || this.At && compare(this.ot, this.wt[h], t[h])); h++) {
-                if (this.At) _(this.At[h], t[h]);
+                        for (h = 0, c = Math.min(this.it, e); h < c && (this.ot[h] === t[h] || this.ct && compare(this.ze, this.ot[h], t[h])); h++) {
+                if (this.ct) y(this.ct[h], t[h]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (f = this.ht - 1, c = s - 1; f >= h && c >= h && (this.wt[f] === t[c] || this.At && compare(this.ot, this.wt[f], t[c])); f--, 
-            c--) ;
+                        for (c = this.it - 1, a = e - 1; c >= h && a >= h && (this.ot[c] === t[a] || this.ct && compare(this.ze, this.ot[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 === s && this.ht === s) {
-                this.wt = t.slice(0);
+                        if (h === e && this.it === e) {
+                this.ot = t.slice(0);
                 return;
             }
             // SMALL-MOVE FAST PATH: extracted to its own function — inlining it
@@ -301,103 +381,108 @@ 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 (s <= this.ht && f - h > 64 && this.At === undefined && this.Mt === undefined) {
+                        if (e <= this.it && c - h > 64 && this.ct === undefined && this.lt === 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 e = h + (c - h >> 1);
-                const i = t[e];
-                const r = Math.min(f, e + 32);
-                let n = Math.max(h, e - 32);
-                while (n <= r && this.wt[n] !== i) n++;
-                if (n <= r && trySmallMove(this, t, s, h)) return;
-            }
-            const y = s - this.ht;
-            const A = new Array(s);
-            const M = new Array(s);
-            r = this.At ? new Array(s) : undefined;
-            n = this.Mt ? 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
-                        l = new Map;
-            p = new Array(c + 1);
-            for (i = c; i >= h; i--) {
-                a = t[i];
-                u = this.ot ? this.ot(a) : a;
-                e = l.get(u);
-                p[i] = e === undefined ? -1 : e;
-                l.set(u, i);
-            }
-            // 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 (e = h; e <= f; e++) {
-                a = this.wt[e];
-                u = this.ot ? this.ot(a) : a;
-                i = l.get(u);
-                if (i !== undefined && i !== -1) {
-                    A[i] = this.yt[e];
-                    M[i] = this.ln[e];
-                    r && (r[i] = this.At[e]);
-                    n && (n[i] = this.Mt[e]);
-                    i = p[i];
-                    l.set(u, i);
-                } else {
-                    (d ??= []).push(this.ln[e]);
-                    if (false && attrHooks !== null) ;
-                }
+                const i = h + (a - h >> 1);
+                const s = t[i];
+                const n = Math.min(c, i + 32);
+                let r = Math.max(h, i - 32);
+                while (r <= n && this.ot[r] !== s) r++;
+                if (r <= n && trySmallMove(this, t, e, h)) return;
             }
-            // 2) create new rows into the temp arrays; an abort disposes only these
-                        try {
-                for (i = h; i <= c; i++) {
-                    if (M[i] !== undefined) continue;
-                    (w ??= []).push(M[i] = createOwner());
-                    if (false && attrHooks !== null) ;
-                    A[i] = runWithOwner(M[i], o);
+            const g = e - this.it;
+            // 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
+            // arrays. Only the changed window [start, newEnd] is staged — the
+            // prefix and suffix are, by construction, the rows that did not move
+            // relative to each other — and at commit the bookkeeping arrays
+            // (`_nodes`, `_rows`, `_indexes`) take the window in place with the
+            // suffix shifted by a plain loop (`copyWithin` is a generic
+            // per-element builtin in V8 — 30× slower than the loop on 1k refs,
+            // measured 2026-10-15). `_mappings` alone is
+            // rebuilt: its fresh identity is the change signal downstream relies
+            // on. A one-row edit on a 500-row list used to allocate ~20 KB of
+            // 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 S = new Array(e);
+            const M = new Array(A);
+            r = this.ct ? new Array(A) : undefined;
+            o = this.lt ? new Array(A) : 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;
+            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) 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;
+                w = new Array(A);
+                for (s = a; s >= h; s--) {
+                    l = t[s];
+                    u = this.ze ? this.ze(l) : l;
+                    i = d.get(u);
+                    w[s - h] = i === undefined ? -1 : i;
+                    d.set(u, s);
                 }
-            } catch (t) {
-                if (w) for (e = 0; e < w.length; e++) w[e].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 (e = 0; e < h; e++) {
-                A[e] = this.yt[e];
-                M[e] = this.ln[e];
-                r && (r[e] = this.At[e]);
-                n && (n[e] = this.Mt[e]);
-            }
-            for (i = h; i <= c; i++) {
-                if (r) _(r[i], t[i]);
-                if (n) _(n[i], i);
-            }
-            for (i = c + 1; i < s; i++) {
-                A[i] = this.yt[i - y];
-                M[i] = this.ln[i - y];
-                if (r) {
-                    r[i] = this.At[i - y];
-                    _(r[i], t[i]);
+                // 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.ot[i];
+                    u = this.ze ? this.ze(l) : l;
+                    s = d.get(u);
+                    if (s !== undefined && s !== -1) {
+                        S[s] = this.ht[i];
+                        M[s - h] = this.tn[i];
+                        r && (r[s - h] = this.ct[i]);
+                        o && (o[s - h] = this.lt[i]);
+                        s = w[s - h];
+                        d.set(u, s);
+                    } else {
+                        (p ??= []).push(this.tn[i]);
+                        if (false && attrHooks !== null) ;
+                    }
                 }
-                if (n) {
-                    n[i] = this.Mt[i - y];
-                    if (y !== 0) _(n[i], i);
+                // 2) create new rows into the window stage; an abort disposes only these
+                                try {
+                    for (s = h; s <= a; s++) {
+                        if (M[s - h] !== undefined) continue;
+                        (m ??= []).push(M[s - h] = createOwner());
+                        if (false && attrHooks !== null) ;
+                        n = s - h;
+                        S[s] = runWithOwner(M[s - h], f);
+                    }
+                } catch (t) {
+                    if (m) for (i = 0; i < m.length; i++) m[i].dispose();
+                    throw t;
                 }
             }
-            this.yt = A;
-            this.ln = M;
-            r && (this.At = r);
-            n && (this.Mt = n);
-            this.ht = s;
+            // 3) commit: the retained prefix and suffix land in the fresh mapped
+            // 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.ht[i];
+            for (s = a + 1; s < e; s++) S[s] = this.ht[s - g];
+            commitWindow(this, t, e, h, c, a, M, r, o);
+            this.ht = S;
+            this.it = e;
             // save a copy of the mapped items for the next update
-                        this.wt = t.slice(0);
-            if (d) for (e = 0; e < d.length; e++) d[e].dispose();
-            if (false && attrHooks !== null && m !== undefined && O !== undefined) ;
+                        this.ot = t.slice(0);
+            if (p) for (i = 0; i < p.length; i++) p[i].dispose();
+            if (false && attrHooks !== null && O !== undefined && _ !== undefined) ;
         }
     });
-    return this.yt;
+    return this.ht;
 }
 
 /**
@@ -413,23 +498,23 @@ function updateKeyedMap() {
  * const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
- */ function repeat(t, s, e) {
-    const i = s;
-    const r = {
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/jsx-component-primitives/repeat
+ */ function repeat(t, e, i) {
+    const s = e;
+    const n = {
         L: createOwner(),
-        ht: 0,
-        St: 0,
-        kt: t,
-        Ot: i,
-        ln: [],
-        yt: [],
-        jt: e?.from,
-        v: e?.fallback
+        it: 0,
+        dt: 0,
+        wt: t,
+        ft: s,
+        tn: [],
+        ht: [],
+        Ot: i?.from,
+        H: i?.fallback
     };
-    const n = computed(updateRepeat.bind(r));
-    n.i &= ~CONFIG_AUTO_DISPOSE;
-    return accessor(n);
+    const r = computed(updateRepeat.bind(n));
+    r.l &= ~CONFIG_AUTO_DISPOSE;
+    return accessor(r);
 }
 
 // Same staged-commit discipline as `updateKeyedMap` (#2903): the retained
@@ -441,60 +526,60 @@ 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.L.et = getOwner();
-    const t = this.kt();
-    const s = this.jt?.() || 0;
+    this.L.Ye = getOwner();
+    const t = this.wt();
+    const e = this.Ot?.() || 0;
     runWithOwner(this.L, () => {
         if (t === 0) {
-            if (this.ht !== 0) {
+            if (this.it !== 0) {
                 this.L.dispose(false);
-                this.ln = [];
-                this.yt = [];
-                this.ht = 0;
+                this.tn = [];
+                this.ht = [];
+                this.it = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.St = 0;
+                                this.dt = 0;
             }
-            if (this.v && !this.yt[0]) {
+            if (this.H && !this.ht.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.ln[0]?.dispose();
-                this.yt[0] = runWithOwner(this.ln[0] = createOwner(), this.v);
+                this.tn[0]?.dispose();
+                this.ht[0] = runWithOwner(this.tn[0] = createOwner(), this.H);
             }
             return;
         }
-        const e = s + t;
-        const i = this.St + this.ht;
+        const i = e + t;
+        const s = this.dt + this.it;
         // 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.St);
-        const n = Math.min(e, i);
+                const n = Math.max(e, this.dt);
+        const r = Math.min(i, s);
         const o = new Array(t);
-        const h = new Array(t);
-        for (let t = r; t < n; t++) {
-            h[t - s] = this.ln[t - this.St];
-            o[t - s] = this.yt[t - this.St];
+        const f = new Array(t);
+        for (let t = n; t < r; t++) {
+            f[t - e] = this.tn[t - this.dt];
+            o[t - e] = this.ht[t - this.dt];
         }
         try {
-            for (let t = s; t < e; t++) {
-                if (t >= r && t < n) continue;
-                o[t - s] = runWithOwner(h[t - s] = createOwner(), () => this.Ot(t));
+            for (let t = e; t < i; t++) {
+                if (t >= n && t < r) continue;
+                o[t - e] = runWithOwner(f[t - e] = createOwner(), () => this.ft(t));
             }
         } catch (t) {
-            for (let t = s; t < e; t++) if ((t < r || t >= n) && h[t - s]) h[t - s].dispose();
+            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.ht === 0) this.ln[0]?.dispose(); else for (let t = this.St; t < i; t++) if (t < s || t >= e) this.ln[t - this.St].dispose();
-        this.yt = o;
-        this.ln = h;
-        this.St = s;
-        this.ht = t;
+                if (this.it === 0) this.tn[0]?.dispose(); else for (let t = this.dt; t < s; t++) if (t < e || t >= i) this.tn[t - this.dt].dispose();
+        this.ht = o;
+        this.tn = f;
+        this.dt = e;
+        this.it = t;
     });
-    return this.yt;
+    return this.ht;
 }
 
-function compare(t, s, e) {
-    return t ? t(s) === t(e) : true;
+function compare(t, e, i) {
+    return t ? t(e) === t(i) : true;
 }
 
 export { mapArray, repeat };