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

package/dist/prod/core/verdict.js

@@ -1,6 +1,6 @@
 import { CONFIG_VERDICT, REACTIVE_PROBED, CONFIG_INPUTS_PUBLISHED, CONFIG_HELD, REACTIVE_JOINED, REACTIVE_STAGED_READ, REACTIVE_LANE_READ, CONFIG_CHILDREN_FORBIDDEN, CONFIG_OVERRIDE, STATUS_PENDING, CONFIG_GUESS, NOT_PENDING, STATUS_UNINITIALIZED, EFFECT_RENDER, STATUS_ERROR, REACTIVE_PROBE_UNANSWERED } from "./constants.js";
 
-import { context, setVerdict, verdict, tracking, pullComputed, markLateLinker, spectating, unflushedValue } from "./core.js";
+import { context, tracking, setVerdict, bornInto, verdict, pullComputed, joinPass, markLateLinker, spectating, unflushedValue } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -8,7 +8,7 @@ import { link } from "./graph.js";
 
 import { verdictLane, laneValueOf, display } from "./lanes.js";
 
-import { GlobalQueue, globalQueue, joinFuture, queuePendingNode, staleReader, passLane, setPassLane, flushTransaction, txOf, stagedReaders } from "./scheduler.js";
+import { GlobalQueue, txOf, globalQueue, joinFuture, queuePendingNode, staleReader, passLane, setPassLane, flushTransaction, stagedReaders } from "./scheduler.js";
 
 // Verdicts (plan sec. 28 replay, 2026-10-02; maintainer, 2026-10-01: verdicts are
 // optimistic state the system supplies). `isPending(fn)` asks whether what
@@ -59,11 +59,13 @@ function watchVerdict(e, t = false) {
  * every flush (fuzzer F12). True when the reader is served the committed
  * value — not over a flight committed beneath inputs already on screen (A15
  * reveal corollary, #3305): that value would tear against them, and the
- * reveal observes the flight. */ function observeFlight(e, t) {
-    if (t.u & CONFIG_INPUTS_PUBLISHED) return false;
-    if (globalQueue.ee) {
+ * reveal observes the flight. Nor for a reader born into the flight's
+ * transaction (`bornInto`, #4010): it has no screen — it waits on the flight
+ * with the rest of its frame. */ function observeFlight(e, t) {
+    if (t.i & CONFIG_INPUTS_PUBLISHED || t.i & CONFIG_HELD && bornInto(e, txOf(t))) return false;
+    if (globalQueue.X) {
         joinFuture(null);
-        if (!(t.u & CONFIG_HELD)) queuePendingNode(t);
+        if (!(t.i & CONFIG_HELD)) queuePendingNode(t);
         verdictRead(e, flushTransaction, true);
     }
     return true;
@@ -86,9 +88,9 @@ let probeFound = false;
  * value notifying anyone (a held write's commit; a held landing's): its
  * reader re-derives there. `latest` shows the proposal that lands — a
  * rewrite or a landing reaches its reader through the link it holds — so a
- * re-run would only repeat the frame. */ function verdictRead(e, t, n = probing) {
+ * re-run would only repeat the frame. */ function verdictRead(e, t, n) {
     route(e, t);
-    if (n) staleReader(e, t);
+    if (n) staleReader(e, t); else if (probing && t.fn[t.fn.length - 1] !== e) t.fn.push(e);
 }
 
 /** A verdict read of a node staged or in flight but not held yet: whether it
@@ -134,10 +136,10 @@ let probeFound = false;
     const t = e.m;
     if (t === null) return false;
     if (t.Se !== undefined) {
-        for (const e of t.Se) if (!e.m?.be) return false;
+        for (const e of t.Se) if (!e.m?.ke) return false;
         return true;
     }
-    return t.be;
+    return t.ke;
 }
 
 /** `isPending`'s answer for a held node (A19), relative to what the reader
@@ -152,25 +154,28 @@ let probeFound = false;
  * frame with neither is final. A24: pending iff a value change is in
  * flight — a staging equal to what is displayed changes nothing when it
  * lands: final now (maintainer, 2026-10-02). */ function heldNotFinal(e) {
-    if ((e.G & STATUS_PENDING) !== 0 && !quietPending(e)) return true;
-    return e.Ae !== NOT_PENDING && !latestActive && !e.m.be && !(e.G & STATUS_UNINITIALIZED) && (!e.We || !e.We(e.pe, e.Ae));
+    if ((e.S & STATUS_PENDING) !== 0 && !quietPending(e)) return true;
+    return e.Oe !== NOT_PENDING && !latestActive && !e.m.ke && !(e.S & STATUS_UNINITIALIZED) && (!e.ye || !e.ye(e.Ae, e.Oe));
 }
 
 /** `isPending`'s answer for an unheld node whose flight is up (cause ii). */ function pendingVerdict(e, t) {
-    if (t.G & STATUS_UNINITIALIZED) return;
+    if (t.S & STATUS_UNINITIALIZED) return;
     if (probing && !quietPending(t)) probeFound = true;
     if (e !== null && tracking) {
-        if (t.u & CONFIG_HELD) verdictRead(e, txOf(t)); else if (globalQueue.ee) provisionalVerdict(e, false);
+        if (t.i & CONFIG_HELD) verdictRead(e, txOf(t)); else if (globalQueue.X) provisionalVerdict(e, false);
  // decided above
         }
 }
 
 /** The pass entering a verdict window is a verdict reader (CONFIG_VERDICT):
- * a dependency going pending re-derives it, the verdict having changed. */ function markVerdictReader(e) {
+ * a dependency going pending re-derives it, the verdict having changed. Not
+ * an untracked window: that is a snapshot, like any untracked read (#3946 —
+ * a router's link claim probing inside the computation that creates the
+ * anchor). A throw still reaches the pass through `untrack`. */ function markVerdictReader(e) {
     let t = context;
-    if (t?.Et) t = t.ut;
-    if (t !== null) {
-        t.u |= CONFIG_VERDICT;
+    if (t?.$e) t = t.et;
+    if (t !== null && tracking) {
+        t.i |= CONFIG_VERDICT;
         t.R |= REACTIVE_PROBED;
     }
 }
@@ -221,7 +226,7 @@ function isPending(e) {
  * a tracked reader of a rewrite not yet flushed, the late-linker re-run in
  * the flush that carries it. */ function heldLatest(e, t) {
     const n = unflushedValue(e);
-    if (n === NOT_PENDING) return e.Ae;
+    if (n === NOT_PENDING) return e.Oe;
     if (t !== null) markLateLinker(t);
     return n;
 }
@@ -248,10 +253,11 @@ function isPending(e) {
  *   uninitialized one throws NotReady: loading, not pending (A19 exc. 1);
  * - an errored derivation throws for every reader (#2897). */ function verdictValue(e, t) {
     const n = e;
-    const r = t !== null && tracking && !(t.u & CONFIG_CHILDREN_FORBIDDEN);
+    const r = t !== null && !(t.i & CONFIG_CHILDREN_FORBIDDEN);
+    const i = r && tracking;
     if (t !== null && tracking) {
         link(e, t);
-        if (n.re !== undefined) {
+        if (n.ee !== undefined) {
             // A31: the pulled memo's pass is its own, not the probe's — it reads
             // outside the window, and the probe's read below answers for what
             // the pass produced.
@@ -264,86 +270,92 @@ function isPending(e) {
     // final by declaration — the value itself is read as below. The verdict is
     // display-ahead like any: in a transaction's flush (the declaring action's
     // body) the reader is its verdict lane's, not a staging the frame parks.
-        if (probing && GlobalQueue.C !== undefined && GlobalQueue.C(n)) {
+        if (probing && GlobalQueue.N !== undefined && GlobalQueue.N(n)) {
         probeFound = true;
-        if (r && flushTransaction !== null) verdictRead(t, flushTransaction);
+        if (i && flushTransaction !== null) verdictRead(t, flushTransaction);
     }
-    if (e.u & CONFIG_OVERRIDE) {
-        const i = txOf(e);
-        if (r) verdictRead(t, i._parent ?? i);
-        const u = (n.G & STATUS_PENDING) !== 0 && !quietPending(n);
-        if (e.u & CONFIG_GUESS) {
-            if (probing && (u || e.Ae !== NOT_PENDING && (!e.We || !e.We(e.m.Z, e.Ae)))) probeFound = true;
-            return e.m.Z;
+    if (e.i & CONFIG_OVERRIDE) {
+        const r = txOf(e);
+        if (i) verdictRead(t, r._parent ?? r);
+        const u = (n.S & STATUS_PENDING) !== 0 && !quietPending(n);
+        if (e.i & CONFIG_GUESS) {
+            if (probing && (u || e.Oe !== NOT_PENDING && (!e.ye || !e.ye(e.m.B, e.Oe)))) probeFound = true;
+            return e.m.B;
         }
         if (probing && u) probeFound = true;
         return latestActive && !u ? laneValueOf(e) : display(e);
     }
-    const i = (n.G & STATUS_UNINITIALIZED) !== 0;
-    if (e.u & CONFIG_HELD) {
-        if (!i) {
-            const i = txOf(e);
+    const u = (n.S & STATUS_UNINITIALIZED) !== 0;
+    if (e.i & CONFIG_HELD) {
+        if (!u) {
+            const r = txOf(e);
             // A render effect re-run (or mounted) outside the verdict lane's flush
             // while the lane is blocked — its display held on its own derivation
             // in flight — is a stale reader of the lane (#3460, as `laneRead`): the
             // committed value now, re-derived at the reveal. Not inside a probe:
             // `isPending` is answered below either way.
-                        if (r && !probing && t.i === EFFECT_RENDER && passLane === null && i.ye !== null && i.ye.ln && flushTransaction !== i) {
-                staleReader(t, i.ye);
-                return e.pe;
+                        if (i && !probing && t.u === EFFECT_RENDER && passLane === null && r.xe !== null && r.xe.sn && flushTransaction !== r) {
+                staleReader(t, r.xe);
+                return e.Ae;
             }
-            if (r) verdictRead(t, i);
+            if (i) verdictRead(t, r);
             if (probing && heldNotFinal(n)) probeFound = true;
-            if (latestActive && e.Ae !== NOT_PENDING) {
+            if (latestActive && e.Oe !== NOT_PENDING) {
                 // An action body reading another transaction's proposal derives
                 // from it: the two settle as one (A15; posture C, 2026-09-15). An
                 // untracked read elsewhere has no transaction to entangle.
-                if (!r && flushTransaction !== null && !globalQueue.ee) joinFuture(txOf(e));
-                return heldLatest(e, r ? t : null);
+                if (!i && flushTransaction !== null && !globalQueue.X) joinFuture(txOf(e));
+                return heldLatest(e, i ? t : null);
             }
-            return e.pe;
+            return e.Ae;
+        }
+        // Born into the future: its staging is its only value. It has no
+        // committed value, so no verdict: `isPending` reads it as its read does —
+        // the owner joins the hold (held with it, or caught by a boundary that
+        // has not shown content) and answers for the commit, where it is final.
+                if (e.Oe !== NOT_PENDING && !(n.S & STATUS_PENDING)) {
+            if (probing && r) joinPass(t, e);
+            return e.Oe;
         }
-        // Born into the future: its staging is its only value.
-                if (e.Ae !== NOT_PENDING && !(n.G & STATUS_PENDING)) return e.Ae;
-    } else if (e.Ae !== NOT_PENDING) {
-        if (n.G & STATUS_PENDING && !i) pendingVerdict(r ? t : null, n); else if (r && globalQueue.ee) provisionalVerdict(t, !latestActive && !i);
+    } else if (e.Oe !== NOT_PENDING) {
+        if (n.S & STATUS_PENDING && !u) pendingVerdict(i ? t : null, n); else if (i && globalQueue.X) provisionalVerdict(t, !latestActive && !u);
         // Outside a flush, the staging is an unflushed write (A28): the probe
         // answers for the flushed world, and watches the seam of the flush that
         // carries the write — a memo of `isPending(x)` created after the write
         // flips if that flush parks (#3078). (The write's own fan-out ran before
         // the reader existed; nothing else would re-derive it.)
-         else if (r && probing) watchVerdict(t);
+         else if (i && probing) watchVerdict(t);
         if (latestActive) {
             // A28: an unflushed write is not what `latest` serves; a tracked
             // reader derived from the flushed world runs again in the carrying
             // flush.
-            if (globalQueue.ee) return e.Ae;
+            if (globalQueue.X) return e.Oe;
             if (t !== null) markLateLinker(t);
         }
-        return e.pe;
+        return e.Ae;
     }
-    if (n.G & STATUS_PENDING) {
-        if (!i) {
-            pendingVerdict(r ? t : null, n);
-            return e.pe;
+    if (n.S & STATUS_PENDING) {
+        if (!u) {
+            pendingVerdict(i ? t : null, n);
+            return e.Ae;
         }
         // As `read()`: an untracked read of a pending node still re-runs its
         // reader when the node settles (a projection's pull reads its firewall
         // untracked, store/store.ts).
                 if (t !== null && !tracking && !spectating && e !== t) link(e, t);
-        throw n.m?.V;
+        throw n.m?.F;
     }
-    if (n.re !== undefined && n.G & STATUS_ERROR) throw n.m.V;
-    return e.pe;
+    if (n.ee !== undefined && n.S & STATUS_ERROR) throw n.m.F;
+    return e.Ae;
 }
 
 // Installed at module evaluation — present exactly when something imports
 // `latest` or `isPending`. (`read` dispatches to `verdictValue` through
 // `verdict`, set while a window is open.)
-GlobalQueue.ft = observeFlight;
+GlobalQueue.It = observeFlight;
 
 /** A store read inside an untracked `isPending` probe found a live mark on
- * a record with no node to carry it (store/affects.ts): not final. */ GlobalQueue.dt = () => {
+ * a record with no node to carry it (store/affects.ts): not final. */ GlobalQueue.ct = () => {
     if (probing) probeFound = true;
 };
 

package/dist/prod/map.js

@@ -21,21 +21,21 @@ function mapArray(t, s, e) {
     const r = s.length > 1;
     const n = s;
     const o = {
-        v: createOwner(),
+        L: createOwner(),
         ht: 0,
-        ct: t,
+        dt: t,
         wt: [],
         Ot: n,
         yt: [],
-        un: [],
-        rt: i,
-        Mt: i || e?.keyed === false ? [] : undefined,
-        gt: r && e?.keyed !== false ? [] : undefined,
-        St: e?.keyed === false,
-        P: e?.fallback
+        ln: [],
+        ot: i,
+        At: i || e?.keyed === false ? [] : undefined,
+        Mt: r && e?.keyed !== false ? [] : undefined,
+        gt: e?.keyed === false,
+        v: e?.fallback
     };
     const h = computed(updateKeyedMap.bind(o), undefined);
-    h.u &= ~CONFIG_AUTO_DISPOSE;
+    h.i &= ~CONFIG_AUTO_DISPOSE;
     return accessor(h);
 }
 
@@ -153,7 +153,7 @@ function trySmallMove(t, s, e, i) {
         }
     }
     const a = t.yt;
-    const u = t.un;
+    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) {
@@ -173,7 +173,7 @@ function trySmallMove(t, s, e, i) {
         p[t] = u[s];
     }
     t.yt = l;
-    t.un = p;
+    t.ln = p;
     t.ht = e;
     t.wt = s.slice(0);
     // Dispose unmatched sources LAST (general-path ordering).
@@ -190,22 +190,22 @@ 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.v.ut = getOwner();
-    const t = this.ct() || [], s = t.length;
+    this.L.et = getOwner();
+    const t = this.dt() || [], s = t.length;
     t[$TRACK];
  // top level tracking (a store array's container node)
-        runWithOwner(this.v, () => {
+        runWithOwner(this.L, () => {
         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.Mt ? this.St ? () => {
+        o = this.At ? this.gt ? () => {
             r[i] = signal(t[i], pureOptions);
             return this.Ot(accessor(r[i]), i);
         } : () => {
             r[i] = signal(t[i], pureOptions);
             n && (n[i] = signal(i, pureOptions));
             return this.Ot(accessor(r[i]), n ? accessor(n[i]) : undefined);
-        } : this.gt ? () => {
+        } : this.Mt ? () => {
             const s = t[i];
             n[i] = signal(i, pureOptions);
             return this.Ot(s, accessor(n[i]));
@@ -216,27 +216,27 @@ function updateKeyedMap() {
         // fast path for empty arrays
                 if (s === 0) {
             if (this.ht !== 0) {
-                this.v.dispose(false);
-                this.un = [];
+                this.L.dispose(false);
+                this.ln = [];
                 this.wt = [];
                 this.yt = [];
                 this.ht = 0;
+                this.At && (this.At = []);
                 this.Mt && (this.Mt = []);
-                this.gt && (this.gt = []);
             }
-            if (this.P && !this.yt[0]) {
+            if (this.v && !this.yt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.un[0]?.dispose();
-                this.yt[0] = runWithOwner(this.un[0] = createOwner(), this.P);
+                this.ln[0]?.dispose();
+                this.yt[0] = runWithOwner(this.ln[0] = createOwner(), this.v);
             }
         }
         // fast path for new create
          else if (this.ht === 0) {
             const h = new Array(s);
             const f = new Array(s);
-            r = this.Mt && new Array(s);
-            n = this.gt && new Array(s);
+            r = this.At && new Array(s);
+            n = this.Mt && new Array(s);
             try {
                 for (i = 0; i < s; i++) h[i] = runWithOwner(f[i] = createOwner(), o);
             } catch (t) {
@@ -244,12 +244,12 @@ function updateKeyedMap() {
                 throw t;
             }
             // commit
-                        if (this.un[0]) this.un[0].dispose();
+                        if (this.ln[0]) this.ln[0].dispose();
  // previous fallback
                         this.yt = h;
-            this.un = f;
-            r && (this.Mt = r);
-            n && (this.gt = n);
+            this.ln = f;
+            r && (this.At = r);
+            n && (this.Mt = n);
             this.wt = t.slice(0);
             this.ht = s;
         } else {
@@ -280,12 +280,12 @@ function updateKeyedMap() {
             // CARVE 2: the lane-slot arm (`_landOnOverride`, F1) went with the engine.
                         const _ = setSignal;
             // skip common prefix
-                        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]);
+                        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]);
             }
             // 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.Mt && compare(this.rt, this.wt[f], t[c])); f--, 
+                        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--) ;
             // no structural change (every position matched in place at equal
             // length — the common post-reconcile shape): keep the same mapped
@@ -301,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.ht && f - h > 64 && this.Mt === undefined && this.gt === undefined) {
+                        if (s <= this.ht && f - h > 64 && this.At === undefined && this.Mt === 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.
@@ -317,15 +317,15 @@ function updateKeyedMap() {
             const y = s - this.ht;
             const A = new Array(s);
             const M = new Array(s);
-            r = this.Mt ? new Array(s) : undefined;
-            n = this.gt ? new Array(s) : undefined;
+            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.rt ? this.rt(a) : a;
+                u = this.ot ? this.ot(a) : a;
                 e = l.get(u);
                 p[i] = e === undefined ? -1 : e;
                 l.set(u, i);
@@ -335,17 +335,17 @@ function updateKeyedMap() {
             // queue them for disposal at commit
                         for (e = h; e <= f; e++) {
                 a = this.wt[e];
-                u = this.rt ? this.rt(a) : a;
+                u = this.ot ? this.ot(a) : a;
                 i = l.get(u);
                 if (i !== undefined && i !== -1) {
                     A[i] = this.yt[e];
-                    M[i] = this.un[e];
-                    r && (r[i] = this.Mt[e]);
-                    n && (n[i] = this.gt[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.un[e]);
+                    (d ??= []).push(this.ln[e]);
                     if (false && attrHooks !== null) ;
                 }
             }
@@ -366,9 +366,9 @@ function updateKeyedMap() {
             // change propagation), then dispose exited rows
                         for (e = 0; e < h; e++) {
                 A[e] = this.yt[e];
-                M[e] = this.un[e];
-                r && (r[e] = this.Mt[e]);
-                n && (n[e] = this.gt[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]);
@@ -376,20 +376,20 @@ function updateKeyedMap() {
             }
             for (i = c + 1; i < s; i++) {
                 A[i] = this.yt[i - y];
-                M[i] = this.un[i - y];
+                M[i] = this.ln[i - y];
                 if (r) {
-                    r[i] = this.Mt[i - y];
+                    r[i] = this.At[i - y];
                     _(r[i], t[i]);
                 }
                 if (n) {
-                    n[i] = this.gt[i - y];
+                    n[i] = this.Mt[i - y];
                     if (y !== 0) _(n[i], i);
                 }
             }
             this.yt = A;
-            this.un = M;
-            r && (this.Mt = r);
-            n && (this.gt = n);
+            this.ln = M;
+            r && (this.At = r);
+            n && (this.Mt = n);
             this.ht = s;
             // save a copy of the mapped items for the next update
                         this.wt = t.slice(0);
@@ -417,18 +417,18 @@ function updateKeyedMap() {
  */ function repeat(t, s, e) {
     const i = s;
     const r = {
-        v: createOwner(),
+        L: createOwner(),
         ht: 0,
-        kt: 0,
-        jt: t,
+        St: 0,
+        kt: t,
         Ot: i,
-        un: [],
+        ln: [],
         yt: [],
-        Wt: e?.from,
-        P: e?.fallback
+        jt: e?.from,
+        v: e?.fallback
     };
     const n = computed(updateRepeat.bind(r));
-    n.u &= ~CONFIG_AUTO_DISPOSE;
+    n.i &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
 
@@ -441,38 +441,38 @@ 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.v.ut = getOwner();
-    const t = this.jt();
-    const s = this.Wt?.() || 0;
-    runWithOwner(this.v, () => {
+    this.L.et = getOwner();
+    const t = this.kt();
+    const s = this.jt?.() || 0;
+    runWithOwner(this.L, () => {
         if (t === 0) {
             if (this.ht !== 0) {
-                this.v.dispose(false);
-                this.un = [];
+                this.L.dispose(false);
+                this.ln = [];
                 this.yt = [];
                 this.ht = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.kt = 0;
+                                this.St = 0;
             }
-            if (this.P && !this.yt[0]) {
+            if (this.v && !this.yt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.un[0]?.dispose();
-                this.yt[0] = runWithOwner(this.un[0] = createOwner(), this.P);
+                this.ln[0]?.dispose();
+                this.yt[0] = runWithOwner(this.ln[0] = createOwner(), this.v);
             }
             return;
         }
         const e = s + t;
-        const i = this.kt + this.ht;
+        const i = this.St + 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.kt);
+                const r = Math.max(s, this.St);
         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.un[t - this.kt];
-            o[t - s] = this.yt[t - this.kt];
+            h[t - s] = this.ln[t - this.St];
+            o[t - s] = this.yt[t - this.St];
         }
         try {
             for (let t = s; t < e; t++) {
@@ -484,10 +484,10 @@ function updateRepeat() {
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                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();
+                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.un = h;
-        this.kt = s;
+        this.ln = h;
+        this.St = s;
         this.ht = t;
     });
     return this.yt;