@solidjs/signals 2.0.0-rc.11 → 2.0.0-rc.14

package/dist/observe/map.js

@@ -1,54 +1,45 @@
-import { computed, runWithOwner, signal, currentOptimisticLane, setSignal } from "./core/core.js";
+import { computed, runWithOwner, signal, setSignal } from "./core/core.js";
 
-import { activeLanes } from "./core/lanes.js";
-
-import { createOwner } from "./core/owner.js";
-
-import { GlobalQueue } from "./core/scheduler.js";
+import "./core/verdict.js";
 
 import { CONFIG_AUTO_DISPOSE } from "./core/constants.js";
 
 import { attrHooks } from "./core/attribution-hooks.js";
 
-import "./core/invariants.js";
-
 import "./core/dev.js";
 
-import "./core/verdict.js";
+import "./core/scheduler.js";
+
+import { createOwner, getOwner } from "./core/owner.js";
 
 import "./core/effect.js";
 
 import { accessor } from "./signals.js";
 
-import { $TRACK } from "./store/store.js";
+import { $TRACK } from "./store/types.js";
 
-import "./store/next/store.js";
-
-function mapArray(t, e, i) {
-    const s = typeof i?.keyed === "function" ? i.keyed : undefined;
+function mapArray(t, e, s) {
+    const i = typeof s?.keyed === "function" ? s.keyed : undefined;
     const r = e.length > 1;
     const n = e;
     const o = {
-        ie: createOwner(),
-        oi: 0,
-        hi: t,
-        fi: [],
-        ci: n,
-        ai: [],
-        ui: [],
-        zt: s,
-        li: s || i?.keyed === false ? [] : undefined,
-        pi: r && i?.keyed !== false ? [] : undefined,
-        di: i?.keyed === false,
-        mi: i?.fallback
+        H: createOwner(),
+        wt: 0,
+        Mt: t,
+        $t: [],
+        qt: n,
+        zt: [],
+        nn: [],
+        bt: i,
+        Jt: i || s?.keyed === false ? [] : undefined,
+        Xt: r && s?.keyed !== false ? [] : undefined,
+        Yt: s?.keyed === false,
+        P: s?.fallback
     };
-    const h = computed(updateKeyedMap.bind(o), i?.name ? {
-        name: i.name
+    const h = computed(updateKeyedMap.bind(o), s?.name ? {
+        name: s.name
     } : undefined);
-    // Untracked reads inside the internal owner resolve via _parentComputed; routing
-    // them through node lets store-proxy lookups see pending writes (not stale _value).
-        o.ie.Yt = h;
-    h.C &= ~CONFIG_AUTO_DISPOSE;
+    h.u &= ~CONFIG_AUTO_DISPOSE;
     return accessor(h);
 }
 
@@ -56,21 +47,21 @@ const pureOptions = {
     ownedWrite: true
 };
 
-function trySmallMove(t, e, i, s) {
-    const r = t.fi;
-    const n = t.oi - 1;
+function trySmallMove(t, e, s, i) {
+    const r = t.$t;
+    const n = t.wt - 1;
     const o = [];
     const h = [];
     const f = [];
  // flat triples: oldStart, newStart, length
         let c = 256;
-    let a = s;
-    let u = s;
+    let a = i;
+    let u = i;
     let l = false;
-    while (a <= n && u <= i - 1) {
+    while (a <= n && u <= s - 1) {
         const t = r[a];
-        const s = e[u];
-        if (t === s) {
+        const i = e[u];
+        if (t === i) {
             if (!l) {
                 f.push(a, u, 0);
                 l = true;
@@ -82,30 +73,30 @@ function trySmallMove(t, e, i, s) {
         }
         l = 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] === s) {
-                p = t;
+                let d = -1;
+        let p = Math.min(32 - o.length, n - a, c);
+        for (let t = 1; t <= p; t++) {
+            if (r[a + t] === i) {
+                d = t;
                 break;
             }
         }
-        c -= p === -1 ? d : p;
-        let m = -1;
-        d = Math.min(32 - h.length, i - 1 - u, c);
-        for (let i = 1; i <= d; i++) {
-            if (e[u + i] === t) {
-                m = i;
+        c -= d === -1 ? p : d;
+        let w = -1;
+        p = Math.min(32 - h.length, s - 1 - u, c);
+        for (let s = 1; s <= p; s++) {
+            if (e[u + s] === t) {
+                w = s;
                 break;
             }
         }
-        c -= m === -1 ? d : m;
-        if (p !== -1 && (m === -1 || p <= m)) {
-            while (p-- > 0) o.push(a++);
+        c -= w === -1 ? p : w;
+        if (d !== -1 && (w === -1 || d <= w)) {
+            while (d-- > 0) o.push(a++);
             continue;
         }
-        if (m !== -1) {
-            while (m-- > 0) h.push(u++);
+        if (w !== -1) {
+            while (w-- > 0) h.push(u++);
             continue;
         }
         if (c <= 0 || o.length === 32 || h.length === 32) return false;
@@ -116,11 +107,11 @@ function trySmallMove(t, e, i, s) {
         if (o.length === 32) return false;
         o.push(a);
     }
-    for (;u <= i - 1; u++) {
+    for (;u <= s - 1; u++) {
         if (h.length === 32) return false;
         h.push(u);
     }
-    return commitSmallMove(t, e, i, o, h, f);
+    return commitSmallMove(t, e, s, o, h, f);
 }
 
 /** PHASE 2 of the small-move path, in its OWN function so that a pass which
@@ -129,17 +120,17 @@ function trySmallMove(t, e, i, s) {
  * 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, e, i, s, r, n) {
-    const o = t.fi;
+ * arrays, copy shifted runs, patch displaced pairs, dispose leftovers. */ function commitSmallMove(t, e, s, i, r, n) {
+    const o = t.$t;
     let h;
     let f;
     let c;
     if (r.length !== 0) {
-        c = new Array(s.length);
+        c = new Array(i.length);
         for (f = 0; f < r.length; f++) {
             let t = -1;
-            for (h = 0; h < s.length; h++) {
-                if (!c[h] && o[s[h]] === e[r[f]]) {
+            for (h = 0; h < i.length; h++) {
+                if (!c[h] && o[i[h]] === e[r[f]]) {
                     t = h;
                     break;
                 }
@@ -156,113 +147,120 @@ function trySmallMove(t, e, i, s) {
     // 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 (s.length !== 0 || r.length !== 0) {
+        if (i.length !== 0 || r.length !== 0) {
         const t = new Set;
-        for (h = 0; h < s.length; h++) t.add(o[s[h]]);
+        for (h = 0; h < i.length; h++) t.add(o[i[h]]);
         for (f = 0; f < r.length; f++) t.add(e[r[f] >> 6]);
         for (let e = 0; e < n.length; e += 3) {
-            const i = n[e];
-            for (let s = 0, r = n[e + 2]; s < r; s++) if (t.has(o[i + s])) return false;
+            const s = n[e];
+            for (let i = 0, r = n[e + 2]; i < r; i++) if (t.has(o[s + i])) return false;
         }
     }
-    const a = t.ai;
-    const u = t.ui;
-    const l = a.slice(0, i);
-    const p = u.slice(0, i);
+    const a = t.zt;
+    const u = t.nn;
+    const l = a.slice(0, s);
+    const d = u.slice(0, s);
     for (let t = 0; t < n.length; t += 3) {
         const e = n[t];
-        const i = n[t + 1];
-        if (e !== i) {
-            for (let s = 0; s < n[t + 2]; s++) {
-                l[i + s] = a[e + s];
-                p[i + s] = u[e + s];
+        const s = n[t + 1];
+        if (e !== s) {
+            for (let i = 0; i < n[t + 2]; i++) {
+                l[s + i] = a[e + i];
+                d[s + i] = u[e + i];
             }
         }
     }
     for (f = 0; f < r.length; f++) {
         const t = r[f] >> 6;
-        const e = s[r[f] & 63];
+        const e = i[r[f] & 63];
         l[t] = a[e];
-        p[t] = u[e];
+        d[t] = u[e];
     }
-    t.ai = l;
-    t.ui = p;
-    t.oi = i;
-    t.fi = e.slice(0);
+    t.zt = l;
+    t.nn = d;
+    t.wt = s;
+    t.$t = e.slice(0);
     // Dispose unmatched sources LAST (general-path ordering).
-        for (h = 0; h < s.length; h++) {
-        if (c === undefined || !c[h]) u[s[h]].dispose();
+        for (h = 0; h < i.length; h++) {
+        if (c === undefined || !c[h]) u[i[h]].dispose();
     }
     return true;
 }
 
 function updateKeyedMap() {
-    const t = this.hi() || [], e = t.length;
+    // Untracked reads inside the internal owner resolve via _parentComputed:
+    // routed through the node, a store-proxy lookup sees pending writes (not a
+    // stale _value) and an async read in a row callback registers the node as
+    // 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.gt = getOwner();
+    const t = this.Mt() || [], e = t.length;
     t[$TRACK];
- // top level tracking
-        runWithOwner(this.ie, () => {
-        let i, s, r, n, 
+ // top level tracking (a store array's container node)
+        runWithOwner(this.H, () => {
+        let s, i, r, n, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        o = this.li ? this.di ? () => {
-            r[s] = signal(t[s], pureOptions);
-            return this.ci(accessor(r[s]), s);
+        o = this.Jt ? this.Yt ? () => {
+            r[i] = signal(t[i], pureOptions);
+            return this.qt(accessor(r[i]), i);
         } : () => {
-            r[s] = signal(t[s], pureOptions);
-            n && (n[s] = signal(s, pureOptions));
-            return this.ci(accessor(r[s]), n ? accessor(n[s]) : undefined);
-        } : this.pi ? () => {
-            const e = t[s];
-            n[s] = signal(s, pureOptions);
-            return this.ci(e, accessor(n[s]));
+            r[i] = signal(t[i], pureOptions);
+            n && (n[i] = signal(i, pureOptions));
+            return this.qt(accessor(r[i]), n ? accessor(n[i]) : undefined);
+        } : this.Xt ? () => {
+            const e = t[i];
+            n[i] = signal(i, pureOptions);
+            return this.qt(e, accessor(n[i]));
         } : () => {
-            const e = t[s];
-            return this.ci(e);
+            const e = t[i];
+            return this.qt(e);
         };
         // fast path for empty arrays
                 if (e === 0) {
-            if (this.oi !== 0) {
-                this.ie.dispose(false);
-                this.ui = [];
-                this.fi = [];
-                this.ai = [];
-                this.oi = 0;
-                this.li && (this.li = []);
-                this.pi && (this.pi = []);
+            if (this.wt !== 0) {
+                this.H.dispose(false);
+                this.nn = [];
+                this.$t = [];
+                this.zt = [];
+                this.wt = 0;
+                this.Jt && (this.Jt = []);
+                this.Xt && (this.Xt = []);
             }
-            if (this.mi && !this.ai[0]) {
+            if (this.P && !this.zt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.ui[0]?.dispose();
-                this.ai[0] = runWithOwner(this.ui[0] = createOwner(), this.mi);
+                this.nn[0]?.dispose();
+                this.zt[0] = runWithOwner(this.nn[0] = createOwner(), this.P);
             }
         }
         // fast path for new create
-         else if (this.oi === 0) {
+         else if (this.wt === 0) {
             const h = new Array(e);
             const f = new Array(e);
-            r = this.li && new Array(e);
-            n = this.pi && new Array(e);
+            r = this.Jt && new Array(e);
+            n = this.Xt && new Array(e);
             try {
-                for (s = 0; s < e; s++) h[s] = runWithOwner(f[s] = createOwner(), o);
+                for (i = 0; i < e; i++) h[i] = runWithOwner(f[i] = createOwner(), o);
             } catch (t) {
-                for (i = 0; i <= s; i++) f[i]?.dispose();
+                for (s = 0; s <= i; s++) f[s]?.dispose();
                 throw t;
             }
             // commit
-                        if (this.ui[0]) this.ui[0].dispose();
+                        if (this.nn[0]) this.nn[0].dispose();
  // previous fallback
-                        this.ai = h;
-            this.ui = f;
-            r && (this.li = r);
-            n && (this.pi = n);
-            this.fi = t.slice(0);
-            this.oi = e;
+                        this.zt = h;
+            this.nn = f;
+            r && (this.Jt = r);
+            n && (this.Xt = n);
+            this.$t = t.slice(0);
+            this.wt = e;
         } else {
-            let h, f, c, a, u, l, p, d, m, 
+            let h, f, c, a, u, l, d, p, w, 
             // Dev (attribution engine installed): the items behind the exited and
             // entered rows, for the list-identity census.
-            w, O;
+            m, 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
@@ -283,20 +281,21 @@ function updateKeyedMap() {
             // knows the slots are clean and drops the mark — and an unmarked map
             // takes `setSignal` directly. The engine is installed whenever a lane
             // is active.
-                        const _ = (this.wi = currentOptimisticLane !== null || this.wi && activeLanes.size !== 0) ? GlobalQueue.Vn : setSignal;
+            // CARVE 2: the lane-slot arm (`_landOnOverride`, F1) went with the engine.
+                        const _ = setSignal;
             // skip common prefix
-                        for (h = 0, f = Math.min(this.oi, e); h < f && (this.fi[h] === t[h] || this.li && compare(this.zt, this.fi[h], t[h])); h++) {
-                if (this.li) _(this.li[h], t[h]);
+                        for (h = 0, f = Math.min(this.wt, e); h < f && (this.$t[h] === t[h] || this.Jt && compare(this.bt, this.$t[h], t[h])); h++) {
+                if (this.Jt) _(this.Jt[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.oi - 1, c = e - 1; f >= h && c >= h && (this.fi[f] === t[c] || this.li && compare(this.zt, this.fi[f], t[c])); f--, 
+                        for (f = this.wt - 1, c = e - 1; f >= h && c >= h && (this.$t[f] === t[c] || this.Jt && compare(this.bt, this.$t[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 (h === e && this.oi === e) {
-                this.fi = t.slice(0);
+                        if (h === e && this.wt === e) {
+                this.$t = t.slice(0);
                 return;
             }
             // SMALL-MOVE FAST PATH: extracted to its own function — inlining it
@@ -306,103 +305,103 @@ 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.oi && f - h > 64 && this.li === undefined && this.pi === undefined) {
+                        if (e <= this.wt && f - h > 64 && this.Jt === 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.
                 // ~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 s = t[i];
-                const r = Math.min(f, i + 32);
-                let n = Math.max(h, i - 32);
-                while (n <= r && this.fi[n] !== s) n++;
+                const s = h + (c - h >> 1);
+                const i = t[s];
+                const r = Math.min(f, s + 32);
+                let n = Math.max(h, s - 32);
+                while (n <= r && this.$t[n] !== i) n++;
                 if (n <= r && trySmallMove(this, t, e, h)) return;
             }
-            const y = e - this.oi;
+            const y = e - this.wt;
             const A = new Array(e);
             const M = new Array(e);
-            r = this.li ? new Array(e) : undefined;
-            n = this.pi ? new Array(e) : undefined;
+            r = this.Jt ? new Array(e) : undefined;
+            n = this.Xt ? new Array(e) : 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 (s = c; s >= h; s--) {
-                a = t[s];
-                u = this.zt ? this.zt(a) : a;
-                i = l.get(u);
-                p[s] = i === undefined ? -1 : i;
-                l.set(u, s);
+            d = new Array(c + 1);
+            for (i = c; i >= h; i--) {
+                a = t[i];
+                u = this.bt ? this.bt(a) : a;
+                s = l.get(u);
+                d[i] = s === undefined ? -1 : s;
+                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 (i = h; i <= f; i++) {
-                a = this.fi[i];
-                u = this.zt ? this.zt(a) : a;
-                s = l.get(u);
-                if (s !== undefined && s !== -1) {
-                    A[s] = this.ai[i];
-                    M[s] = this.ui[i];
-                    r && (r[s] = this.li[i]);
-                    n && (n[s] = this.pi[i]);
-                    s = p[s];
-                    l.set(u, s);
+                        for (s = h; s <= f; s++) {
+                a = this.$t[s];
+                u = this.bt ? this.bt(a) : a;
+                i = l.get(u);
+                if (i !== undefined && i !== -1) {
+                    A[i] = this.zt[s];
+                    M[i] = this.nn[s];
+                    r && (r[i] = this.Jt[s]);
+                    n && (n[i] = this.Xt[s]);
+                    i = d[i];
+                    l.set(u, i);
                 } else {
-                    (d ??= []).push(this.ui[i]);
-                    if (true && attrHooks !== null) (w ??= []).push(a);
+                    (p ??= []).push(this.nn[s]);
+                    if (true && attrHooks !== null) (m ??= []).push(a);
                 }
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
-                for (s = h; s <= c; s++) {
-                    if (M[s] !== undefined) continue;
-                    (m ??= []).push(M[s] = createOwner());
-                    if (true && attrHooks !== null) (O ??= []).push(t[s]);
-                    A[s] = runWithOwner(M[s], o);
+                for (i = h; i <= c; i++) {
+                    if (M[i] !== undefined) continue;
+                    (w ??= []).push(M[i] = createOwner());
+                    if (true && attrHooks !== null) (O ??= []).push(t[i]);
+                    A[i] = runWithOwner(M[i], o);
                 }
             } catch (t) {
-                if (m) for (i = 0; i < m.length; i++) m[i].dispose();
+                if (w) for (s = 0; s < w.length; s++) w[s].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 < h; i++) {
-                A[i] = this.ai[i];
-                M[i] = this.ui[i];
-                r && (r[i] = this.li[i]);
-                n && (n[i] = this.pi[i]);
+                        for (s = 0; s < h; s++) {
+                A[s] = this.zt[s];
+                M[s] = this.nn[s];
+                r && (r[s] = this.Jt[s]);
+                n && (n[s] = this.Xt[s]);
             }
-            for (s = h; s <= c; s++) {
-                if (r) _(r[s], t[s]);
-                if (n) _(n[s], s);
+            for (i = h; i <= c; i++) {
+                if (r) _(r[i], t[i]);
+                if (n) _(n[i], i);
             }
-            for (s = c + 1; s < e; s++) {
-                A[s] = this.ai[s - y];
-                M[s] = this.ui[s - y];
+            for (i = c + 1; i < e; i++) {
+                A[i] = this.zt[i - y];
+                M[i] = this.nn[i - y];
                 if (r) {
-                    r[s] = this.li[s - y];
-                    _(r[s], t[s]);
+                    r[i] = this.Jt[i - y];
+                    _(r[i], t[i]);
                 }
                 if (n) {
-                    n[s] = this.pi[s - y];
-                    if (y !== 0) _(n[s], s);
+                    n[i] = this.Xt[i - y];
+                    if (y !== 0) _(n[i], i);
                 }
             }
-            this.ai = A;
-            this.ui = M;
-            r && (this.li = r);
-            n && (this.pi = n);
-            this.oi = e;
+            this.zt = A;
+            this.nn = M;
+            r && (this.Jt = r);
+            n && (this.Xt = n);
+            this.wt = e;
             // save a copy of the mapped items for the next update
-                        this.fi = t.slice(0);
-            if (d) for (i = 0; i < d.length; i++) d[i].dispose();
-            if (true && attrHooks !== null && w !== undefined && O !== undefined) attrHooks.listChurn(this.ie.Yt, w, O, e, this.zt !== undefined);
+                        this.$t = t.slice(0);
+            if (p) for (s = 0; s < p.length; s++) p[s].dispose();
+            if (true && attrHooks !== null && m !== undefined && O !== undefined) attrHooks.listChurn(this.H.gt, m, O, e, this.bt !== undefined);
         }
     });
-    return this.ai;
+    return this.zt;
 }
 
 /**
@@ -419,25 +418,21 @@ function updateKeyedMap() {
  * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
- */ function repeat(t, e, i) {
-    const s = e;
+ */ function repeat(t, e, s) {
+    const i = e;
     const r = {
-        ie: createOwner(),
-        oi: 0,
-        Oi: 0,
-        _i: t,
-        ci: s,
-        ui: [],
-        ai: [],
-        yi: i?.from,
-        mi: i?.fallback
+        H: createOwner(),
+        wt: 0,
+        ts: 0,
+        es: t,
+        qt: i,
+        nn: [],
+        zt: [],
+        ss: s?.from,
+        P: s?.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.ie.Yt = n;
-    n.C &= ~CONFIG_AUTO_DISPOSE;
+    n.u &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
 
@@ -449,59 +444,61 @@ 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._i();
-    const e = this.yi?.() || 0;
-    runWithOwner(this.ie, () => {
+    // As in updateKeyedMap: the node is the row callbacks' reader, per pass.
+    this.H.gt = getOwner();
+    const t = this.es();
+    const e = this.ss?.() || 0;
+    runWithOwner(this.H, () => {
         if (t === 0) {
-            if (this.oi !== 0) {
-                this.ie.dispose(false);
-                this.ui = [];
-                this.ai = [];
-                this.oi = 0;
+            if (this.wt !== 0) {
+                this.H.dispose(false);
+                this.nn = [];
+                this.zt = [];
+                this.wt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.Oi = 0;
+                                this.ts = 0;
             }
-            if (this.mi && !this.ai[0]) {
+            if (this.P && !this.zt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.ui[0]?.dispose();
-                this.ai[0] = runWithOwner(this.ui[0] = createOwner(), this.mi);
+                this.nn[0]?.dispose();
+                this.zt[0] = runWithOwner(this.nn[0] = createOwner(), this.P);
             }
             return;
         }
-        const i = e + t;
-        const s = this.Oi + this.oi;
+        const s = e + t;
+        const i = this.ts + this.wt;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
-                const r = Math.max(e, this.Oi);
-        const n = Math.min(i, s);
+                const r = Math.max(e, this.ts);
+        const n = Math.min(s, i);
         const o = new Array(t);
         const h = new Array(t);
         for (let t = r; t < n; t++) {
-            h[t - e] = this.ui[t - this.Oi];
-            o[t - e] = this.ai[t - this.Oi];
+            h[t - e] = this.nn[t - this.ts];
+            o[t - e] = this.zt[t - this.ts];
         }
         try {
-            for (let t = e; t < i; t++) {
+            for (let t = e; t < s; t++) {
                 if (t >= r && t < n) continue;
-                o[t - e] = runWithOwner(h[t - e] = createOwner(), () => this.ci(t));
+                o[t - e] = runWithOwner(h[t - e] = createOwner(), () => this.qt(t));
             }
         } catch (t) {
-            for (let t = e; t < i; t++) if ((t < r || t >= n) && h[t - e]) h[t - e].dispose();
+            for (let t = e; t < s; t++) if ((t < r || t >= n) && h[t - e]) h[t - e].dispose();
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.oi === 0) this.ui[0]?.dispose(); else for (let t = this.Oi; t < s; t++) if (t < e || t >= i) this.ui[t - this.Oi].dispose();
-        this.ai = o;
-        this.ui = h;
-        this.Oi = e;
-        this.oi = t;
+                if (this.wt === 0) this.nn[0]?.dispose(); else for (let t = this.ts; t < i; t++) if (t < e || t >= s) this.nn[t - this.ts].dispose();
+        this.zt = o;
+        this.nn = h;
+        this.ts = e;
+        this.wt = t;
     });
-    return this.ai;
+    return this.zt;
 }
 
-function compare(t, e, i) {
-    return t ? t(e) === t(i) : true;
+function compare(t, e, s) {
+    return t ? t(e) === t(s) : true;
 }
 
 export { mapArray, repeat };