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

package/dist/prod/flatten.js

@@ -0,0 +1,77 @@
+import { NotReadyError } from "./core/error.js";
+
+import "./core/verdict.js";
+
+import "./core/core.js";
+
+import "./core/scheduler.js";
+
+import "./core/effect.js";
+
+// CARVE 4: `flatten` lived in boundaries.ts but is the general children
+// resolver the renderers (`web`, `universal`, `solid`'s `children()`) walk
+// through — not a boundary feature. Moved verbatim so the boundary carve
+// measures boundaries alone.
+/**
+ * Resolves nested accessors and arrays in a children tree to their rendered
+ * values. See the `children()` helper in solid-js for the memoized form.
+ */
+function flatten(r, t) {
+    if (typeof r === "function" && !r.length) {
+        if (t?.doNotUnwrap) return r;
+        do {
+            r = r();
+        } while (typeof r === "function" && !r.length);
+    }
+    if (t?.skipNonRendered && (r == null || r === true || r === false || r === "")) return;
+    if (Array.isArray(r)) {
+        let e = [];
+        if (flattenArray(r, e, t)) {
+            return () => {
+                let r = [];
+                flattenArray(e, r, {
+                    ...t,
+                    doNotUnwrap: false
+                });
+                return r;
+            };
+        }
+        return e;
+    }
+    return r;
+}
+
+function flattenArray(r, t = [], e) {
+    let o = null;
+    let f = false;
+    for (let n = 0; n < r.length; n++) {
+        try {
+            let o = r[n];
+            if (typeof o === "function" && !o.length) {
+                if (e?.doNotUnwrap) {
+                    t.push(o);
+                    f = true;
+                    continue;
+                }
+                do {
+                    o = o();
+                } while (typeof o === "function" && !o.length);
+            }
+            if (Array.isArray(o)) {
+                // OR, don't overwrite: an accessor already pushed under doNotUnwrap
+                // still needs the resolving wrapper even when a later sibling
+                // fragment contains no functions (#3133).
+                f = flattenArray(o, t, e) || f;
+            } else if (e?.skipNonRendered && (o == null || o === true || o === false || o === "")) {
+                // skip
+            } else t.push(o);
+        } catch (r) {
+            if (!(r instanceof NotReadyError)) throw r;
+            o = r;
+        }
+    }
+    if (o) throw o;
+    return f;
+}
+
+export { flatten };

package/dist/prod/index.js

@@ -1,5 +1,9 @@
 export { ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError } from "./core/error.js";
 
+export { isPending, latest } from "./core/verdict.js";
+
+export { action } from "./core/action.js";
+
 export { clearSnapshots, isEqual, markSnapshotScope, releaseSnapshotScope, runWithOwner, setSnapshotCapture, untrack } from "./core/core.js";
 
 export { enableExternalSource } from "./core/external.js";
@@ -10,39 +14,37 @@ export { createContext, getContext, setContext } from "./core/context.js";
 
 export { $REFRESH, SUPPORTS_PROXY } from "./core/constants.js";
 
-import "./core/invariants.js";
-
 export { setConsoleFooter } from "./core/dev.js";
 
 export { ROOT_ERROR_HOOK, enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
 
-export { isPending, latest } from "./core/verdict.js";
-
 import "./core/effect.js";
 
-export { action } from "./core/action.js";
-
 export { configureClientErrors } from "./core/error-hooks.js";
 
 export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, refresh, resolve, until } from "./signals.js";
 
-export { affects } from "./affects.js";
-
 export { mapArray, repeat } from "./map.js";
 
 export { createStore, deep, reconcile, snapshot } from "./store/index.js";
 
-export { createErrorBoundary, createLoadingBoundary, createRevealOrder, flatten } from "./boundaries.js";
+export { affects } from "./affects.js";
+
+export { flatten } from "./flatten.js";
+
+export { createErrorBoundary, createLoadingBoundary } from "./boundaries.js";
+
+export { createRevealOrder } from "./reveal.js";
 
-export { $PROXY, $RECORD, $TARGET, $TRACK, isWrappable } from "./store/store.js";
+export { $PROXY, $RECORD, $TARGET, $TRACK, isWrappable, markRaw } from "./store/types.js";
 
 export { MergeView, OmitView, SOURCE_MEMO, SOURCE_MERGE, SOURCE_OMIT, SOURCE_PLAIN, SOURCE_PROXY, hasStaticKeys, isStatic, merge, mergeSources, mergeView, omit, omitView, resolvedTable, sourceGet, sourceHas, sourceKeys, sourceOwners, viewOf } from "./store/utils.js";
 
-export { createOptimisticStoreNext as createOptimisticStore } from "./store/next/optimistic.js";
+export { createOptimisticStore } from "./store/optimistic.js";
 
-export { createProjectionNext as createProjection } from "./store/next/projection.js";
+export { createProjection } from "./store/projection.js";
 
-export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store/next/store.js";
+export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store/store.js";
 
 export { storePath } from "./store/storePath.js";
 

package/dist/prod/map.js

@@ -1,50 +1,41 @@
-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/scheduler.js";
 
-import "./core/verdict.js";
+import { createOwner, getOwner } from "./core/owner.js";
 
 import "./core/effect.js";
 
 import { accessor } from "./signals.js";
 
-import { $TRACK } from "./store/store.js";
-
-import "./store/next/store.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;
     const o = {
-        ie: createOwner(),
-        wt: 0,
-        Ot: t,
+        v: createOwner(),
+        ht: 0,
+        ct: t,
+        wt: [],
+        Ot: n,
         yt: [],
-        At: n,
-        Mt: [],
-        St: [],
-        Kn: i,
-        jt: i || e?.keyed === false ? [] : undefined,
-        kt: r && e?.keyed !== false ? [] : undefined,
-        gt: e?.keyed === false,
-        bt: e?.fallback
+        un: [],
+        rt: i,
+        Mt: i || e?.keyed === false ? [] : undefined,
+        gt: r && e?.keyed !== false ? [] : undefined,
+        St: e?.keyed === false,
+        P: e?.fallback
     };
     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).
-        o.ie.qn = h;
-    h.C &= ~CONFIG_AUTO_DISPOSE;
+    h.u &= ~CONFIG_AUTO_DISPOSE;
     return accessor(h);
 }
 
@@ -53,8 +44,8 @@ const pureOptions = {
 };
 
 function trySmallMove(t, s, e, i) {
-    const r = t.yt;
-    const n = t.wt - 1;
+    const r = t.wt;
+    const n = t.ht - 1;
     const o = [];
     const h = [];
     const f = [];
@@ -87,21 +78,21 @@ function trySmallMove(t, s, e, i) {
             }
         }
         c -= p === -1 ? d : p;
-        let m = -1;
+        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) {
-                m = e;
+                w = e;
                 break;
             }
         }
-        c -= m === -1 ? d : m;
-        if (p !== -1 && (m === -1 || p <= m)) {
+        c -= w === -1 ? d : w;
+        if (p !== -1 && (w === -1 || p <= w)) {
             while (p-- > 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;
@@ -126,7 +117,7 @@ function trySmallMove(t, s, e, i) {
  * 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.yt;
+    const o = t.wt;
     let h;
     let f;
     let c;
@@ -161,8 +152,8 @@ function trySmallMove(t, s, e, i) {
             for (let i = 0, r = n[s + 2]; i < r; i++) if (t.has(o[e + i])) return false;
         }
     }
-    const a = t.Mt;
-    const u = t.St;
+    const a = t.yt;
+    const u = t.un;
     const l = a.slice(0, e);
     const p = u.slice(0, e);
     for (let t = 0; t < n.length; t += 3) {
@@ -181,10 +172,10 @@ function trySmallMove(t, s, e, i) {
         l[t] = a[s];
         p[t] = u[s];
     }
-    t.Mt = l;
-    t.St = p;
-    t.wt = e;
-    t.yt = s.slice(0);
+    t.yt = l;
+    t.un = p;
+    t.ht = e;
+    t.wt = s.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();
@@ -193,52 +184,59 @@ function trySmallMove(t, s, e, i) {
 }
 
 function updateKeyedMap() {
-    const t = this.Ot() || [], s = 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.v.ut = getOwner();
+    const t = this.ct() || [], s = t.length;
     t[$TRACK];
- // top level tracking
-        runWithOwner(this.ie, () => {
+ // top level tracking (a store array's container node)
+        runWithOwner(this.v, () => {
         let e, i, r, n, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        o = this.jt ? this.gt ? () => {
+        o = this.Mt ? this.St ? () => {
             r[i] = signal(t[i], pureOptions);
-            return this.At(accessor(r[i]), i);
+            return this.Ot(accessor(r[i]), i);
         } : () => {
             r[i] = signal(t[i], pureOptions);
             n && (n[i] = signal(i, pureOptions));
-            return this.At(accessor(r[i]), n ? accessor(n[i]) : undefined);
-        } : this.kt ? () => {
+            return this.Ot(accessor(r[i]), n ? accessor(n[i]) : undefined);
+        } : this.gt ? () => {
             const s = t[i];
             n[i] = signal(i, pureOptions);
-            return this.At(s, accessor(n[i]));
+            return this.Ot(s, accessor(n[i]));
         } : () => {
             const s = t[i];
-            return this.At(s);
+            return this.Ot(s);
         };
         // fast path for empty arrays
                 if (s === 0) {
-            if (this.wt !== 0) {
-                this.ie.dispose(false);
-                this.St = [];
+            if (this.ht !== 0) {
+                this.v.dispose(false);
+                this.un = [];
+                this.wt = [];
                 this.yt = [];
-                this.Mt = [];
-                this.wt = 0;
-                this.jt && (this.jt = []);
-                this.kt && (this.kt = []);
+                this.ht = 0;
+                this.Mt && (this.Mt = []);
+                this.gt && (this.gt = []);
             }
-            if (this.bt && !this.Mt[0]) {
+            if (this.P && !this.yt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.St[0]?.dispose();
-                this.Mt[0] = runWithOwner(this.St[0] = createOwner(), this.bt);
+                this.un[0]?.dispose();
+                this.yt[0] = runWithOwner(this.un[0] = createOwner(), this.P);
             }
         }
         // fast path for new create
-         else if (this.wt === 0) {
+         else if (this.ht === 0) {
             const h = new Array(s);
             const f = new Array(s);
-            r = this.jt && new Array(s);
-            n = this.kt && new Array(s);
+            r = this.Mt && new Array(s);
+            n = this.gt && new Array(s);
             try {
                 for (i = 0; i < s; i++) h[i] = runWithOwner(f[i] = createOwner(), o);
             } catch (t) {
@@ -246,19 +244,19 @@ function updateKeyedMap() {
                 throw t;
             }
             // commit
-                        if (this.St[0]) this.St[0].dispose();
+                        if (this.un[0]) this.un[0].dispose();
  // previous fallback
-                        this.Mt = h;
-            this.St = f;
-            r && (this.jt = r);
-            n && (this.kt = n);
-            this.yt = t.slice(0);
-            this.wt = s;
+                        this.yt = h;
+            this.un = f;
+            r && (this.Mt = r);
+            n && (this.gt = n);
+            this.wt = t.slice(0);
+            this.ht = s;
         } else {
-            let h, f, c, a, u, l, p, d, m, 
+            let h, f, c, a, u, l, p, d, 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
@@ -279,20 +277,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.Wt = currentOptimisticLane !== null || this.Wt && activeLanes.size !== 0) ? GlobalQueue.st : 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.wt, s); h < f && (this.yt[h] === t[h] || this.jt && compare(this.Kn, this.yt[h], t[h])); h++) {
-                if (this.jt) _(this.jt[h], t[h]);
+                        for (h = 0, f = Math.min(this.ht, s); h < f && (this.wt[h] === t[h] || this.Mt && compare(this.rt, this.wt[h], t[h])); h++) {
+                if (this.Mt) _(this.Mt[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.wt - 1, c = s - 1; f >= h && c >= h && (this.yt[f] === t[c] || this.jt && compare(this.Kn, this.yt[f], t[c])); f--, 
+                        for (f = this.ht - 1, c = s - 1; f >= h && c >= h && (this.wt[f] === t[c] || this.Mt && compare(this.rt, this.wt[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 === s && this.wt === s) {
-                this.yt = t.slice(0);
+                        if (h === s && this.ht === s) {
+                this.wt = t.slice(0);
                 return;
             }
             // SMALL-MOVE FAST PATH: extracted to its own function — inlining it
@@ -302,7 +301,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 (s <= this.wt && f - h > 64 && this.jt === undefined && this.kt === undefined) {
+                        if (s <= this.ht && f - h > 64 && this.Mt === undefined && this.gt === 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.
@@ -312,21 +311,21 @@ function updateKeyedMap() {
                 const i = t[e];
                 const r = Math.min(f, e + 32);
                 let n = Math.max(h, e - 32);
-                while (n <= r && this.yt[n] !== i) n++;
+                while (n <= r && this.wt[n] !== i) n++;
                 if (n <= r && trySmallMove(this, t, s, h)) return;
             }
-            const y = s - this.wt;
+            const y = s - this.ht;
             const A = new Array(s);
             const M = new Array(s);
-            r = this.jt ? new Array(s) : undefined;
-            n = this.kt ? new Array(s) : undefined;
+            r = this.Mt ? new Array(s) : undefined;
+            n = this.gt ? 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.Kn ? this.Kn(a) : a;
+                u = this.rt ? this.rt(a) : a;
                 e = l.get(u);
                 p[i] = e === undefined ? -1 : e;
                 l.set(u, i);
@@ -335,18 +334,18 @@ function updateKeyedMap() {
             // 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.yt[e];
-                u = this.Kn ? this.Kn(a) : a;
+                a = this.wt[e];
+                u = this.rt ? this.rt(a) : a;
                 i = l.get(u);
                 if (i !== undefined && i !== -1) {
-                    A[i] = this.Mt[e];
-                    M[i] = this.St[e];
-                    r && (r[i] = this.jt[e]);
-                    n && (n[i] = this.kt[e]);
+                    A[i] = this.yt[e];
+                    M[i] = this.un[e];
+                    r && (r[i] = this.Mt[e]);
+                    n && (n[i] = this.gt[e]);
                     i = p[i];
                     l.set(u, i);
                 } else {
-                    (d ??= []).push(this.St[e]);
+                    (d ??= []).push(this.un[e]);
                     if (false && attrHooks !== null) ;
                 }
             }
@@ -354,51 +353,51 @@ function updateKeyedMap() {
                         try {
                 for (i = h; i <= c; i++) {
                     if (M[i] !== undefined) continue;
-                    (m ??= []).push(M[i] = createOwner());
+                    (w ??= []).push(M[i] = createOwner());
                     if (false && attrHooks !== null) ;
                     A[i] = runWithOwner(M[i], o);
                 }
             } catch (t) {
-                if (m) for (e = 0; e < m.length; e++) m[e].dispose();
+                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.Mt[e];
-                M[e] = this.St[e];
-                r && (r[e] = this.jt[e]);
-                n && (n[e] = this.kt[e]);
+                A[e] = this.yt[e];
+                M[e] = this.un[e];
+                r && (r[e] = this.Mt[e]);
+                n && (n[e] = this.gt[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.Mt[i - y];
-                M[i] = this.St[i - y];
+                A[i] = this.yt[i - y];
+                M[i] = this.un[i - y];
                 if (r) {
-                    r[i] = this.jt[i - y];
+                    r[i] = this.Mt[i - y];
                     _(r[i], t[i]);
                 }
                 if (n) {
-                    n[i] = this.kt[i - y];
+                    n[i] = this.gt[i - y];
                     if (y !== 0) _(n[i], i);
                 }
             }
-            this.Mt = A;
-            this.St = M;
-            r && (this.jt = r);
-            n && (this.kt = n);
-            this.wt = s;
+            this.yt = A;
+            this.un = M;
+            r && (this.Mt = r);
+            n && (this.gt = n);
+            this.ht = s;
             // save a copy of the mapped items for the next update
-                        this.yt = t.slice(0);
+                        this.wt = t.slice(0);
             if (d) for (e = 0; e < d.length; e++) d[e].dispose();
-            if (false && attrHooks !== null && w !== undefined && O !== undefined) ;
+            if (false && attrHooks !== null && m !== undefined && O !== undefined) ;
         }
     });
-    return this.Mt;
+    return this.yt;
 }
 
 /**
@@ -418,22 +417,18 @@ function updateKeyedMap() {
  */ function repeat(t, s, e) {
     const i = s;
     const r = {
-        ie: createOwner(),
-        wt: 0,
-        vt: 0,
-        It: t,
-        At: i,
-        St: [],
-        Mt: [],
-        Ct: e?.from,
-        bt: e?.fallback
+        v: createOwner(),
+        ht: 0,
+        kt: 0,
+        jt: t,
+        Ot: i,
+        un: [],
+        yt: [],
+        Wt: e?.from,
+        P: e?.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.qn = n;
-    n.C &= ~CONFIG_AUTO_DISPOSE;
+    n.u &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
 
@@ -445,55 +440,57 @@ 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.It();
-    const s = this.Ct?.() || 0;
-    runWithOwner(this.ie, () => {
+    // As in updateKeyedMap: the node is the row callbacks' reader, per pass.
+    this.v.ut = getOwner();
+    const t = this.jt();
+    const s = this.Wt?.() || 0;
+    runWithOwner(this.v, () => {
         if (t === 0) {
-            if (this.wt !== 0) {
-                this.ie.dispose(false);
-                this.St = [];
-                this.Mt = [];
-                this.wt = 0;
+            if (this.ht !== 0) {
+                this.v.dispose(false);
+                this.un = [];
+                this.yt = [];
+                this.ht = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.vt = 0;
+                                this.kt = 0;
             }
-            if (this.bt && !this.Mt[0]) {
+            if (this.P && !this.yt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.St[0]?.dispose();
-                this.Mt[0] = runWithOwner(this.St[0] = createOwner(), this.bt);
+                this.un[0]?.dispose();
+                this.yt[0] = runWithOwner(this.un[0] = createOwner(), this.P);
             }
             return;
         }
         const e = s + t;
-        const i = this.vt + this.wt;
+        const i = this.kt + this.ht;
         // 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.vt);
+                const r = Math.max(s, this.kt);
         const n = Math.min(e, i);
         const o = new Array(t);
         const h = new Array(t);
         for (let t = r; t < n; t++) {
-            h[t - s] = this.St[t - this.vt];
-            o[t - s] = this.Mt[t - this.vt];
+            h[t - s] = this.un[t - this.kt];
+            o[t - s] = this.yt[t - this.kt];
         }
         try {
             for (let t = s; t < e; t++) {
                 if (t >= r && t < n) continue;
-                o[t - s] = runWithOwner(h[t - s] = createOwner(), () => this.At(t));
+                o[t - s] = runWithOwner(h[t - s] = createOwner(), () => this.Ot(t));
             }
         } catch (t) {
             for (let t = s; t < e; 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.wt === 0) this.St[0]?.dispose(); else for (let t = this.vt; t < i; t++) if (t < s || t >= e) this.St[t - this.vt].dispose();
-        this.Mt = o;
-        this.St = h;
-        this.vt = s;
-        this.wt = t;
+                if (this.ht === 0) this.un[0]?.dispose(); else for (let t = this.kt; t < i; t++) if (t < s || t >= e) this.un[t - this.kt].dispose();
+        this.yt = o;
+        this.un = h;
+        this.kt = s;
+        this.ht = t;
     });
-    return this.Mt;
+    return this.yt;
 }
 
 function compare(t, s, e) {