@solidjs/signals 2.0.0-rc.5 → 2.0.0-rc.7

package/dist/prod/core/verdict.js

@@ -10,7 +10,7 @@ import { insertIntoHeap, queueFor, markHeap, enqueueSub } from "./heap.js";
 
 import "./invariants.js";
 
-import { findLane, hasActiveOverride, assignOrMergeLane } from "./lanes.js";
+import { findLane, laneHeld, hasActiveOverride, assignOrMergeLane } from "./lanes.js";
 
 import { installOptimisticEngine } from "./optimistic.js";
 
@@ -47,10 +47,10 @@ let pendingProbe = null;
  * O(all-leaves-ever-read)-per-update pathology). Entries are permanent like
  * the companions themselves; a store with no leaf-level isPending()/latest()
  * reads never allocates the set or pays the walk. */ function markFirewallChildCompanions(e) {
-    const t = e.st;
+    const t = e.rt;
     if (!t) return;
     t.T |= CONFIG_CHILD_COMPANIONS;
-    (ext(t).St ??= new Set).add(e);
+    (ext(t).dt ??= new Set).add(e);
 }
 
 function getPendingSignal(e) {
@@ -63,7 +63,7 @@ function getPendingSignal(e) {
         ext(e).ye = t;
         e.T |= CONFIG_HAS_COMPANIONS;
         markFirewallChildCompanions(e);
-        ext(t).Tt = e;
+        ext(t).St = e;
         if (computePendingState(e)) setSignal(t, true);
     }
     return t;
@@ -72,7 +72,7 @@ function getPendingSignal(e) {
 function collectPendingSources(e) {
     if (!pendingProbe) return;
     pendingProbe.sources.add(e);
-    const t = e.st || e;
+    const t = e.rt || e;
     if (t !== e) pendingProbe.sources.add(t);
 }
 
@@ -105,33 +105,29 @@ function collectPendingSources(e) {
         if (e.S & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
-    const n = e.st;
+    const n = e.rt;
     if (n && markWalk(n, t)) return true;
     // Mid-recompute (the clearStatus companion poke runs before
     // trimStaleDeps), only the validated prefix [_deps.._depsTail] is this
     // pass's dependency set — walking past it would read dropped deps and
     // latch a stale verdict on the companion.
         const i = e;
-    const r = i.ie & REACTIVE_RECOMPUTING_DEPS ? i.je : undefined;
+    const r = i.ie & REACTIVE_RECOMPUTING_DEPS ? i.Be : undefined;
     if (r !== null) {
-        for (let e = i.ut ?? null; e !== null; e = e.lt) {
-            if (!e.ve && markWalk(e.ot, t)) return true;
+        for (let e = i.lt ?? null; e !== null; e = e.ot) {
+            if (!e.ve && markWalk(e.st, t)) return true;
             if (e === r) break;
         }
     }
     return false;
 }
 
-/** Gated entry: apps with no live mark pay one integer compare. */ function markCovered(e) {
-    return activeAffectsMarks !== 0 && markWalk(e, new Set);
-}
-
 function quietPending(e) {
     if (e.o?.le) {
-        for (const t of e.o.le) if (!t.o?.Ge) return false;
+        for (const t of e.o.le) if (!t.o?.De) return false;
         return true;
     }
-    return e.o?.Ge ?? false;
+    return e.o?.De ?? false;
 }
 
 // NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
@@ -151,23 +147,28 @@ function computePendingState(e) {
     // Mark coverage is transitive by dep-graph reachability: a latest() shadow
     // reaches its owner (and a store leaf its firewall) through its own deps,
     // so the one walk covers direct marks, derivation, and companion chains.
-        if (markCovered(e)) return true;
-    const n = e.st;
-    if (e.o?.Tt) {
-        const t = e.o?.Tt;
-        const n = t.st || t;
+    // Gated: apps with no live mark pay one integer compare.
+        if (activeAffectsMarks !== 0 && markWalk(e, new Set)) return true;
+    const n = e.rt;
+    if (e.o?.St) {
+        const t = e.o?.St;
+        const n = t.rt || t;
         return newQuestionInFlight(n);
     }
-    if (n && e.Pe !== NOT_PENDING && !hasActiveOverride(e)) {
+    if (n && e.Re !== NOT_PENDING && !hasActiveOverride(e)) {
         return !!(n.ie & REACTIVE_MANUAL_WRITE) || !n.o?.Ie && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
     }
     // `!comp._loading`: a hold created while the loading window is still open is
     // the window's own landing in flight to its commit — verdict-quiet like the
     // rest of the window (the UNINITIALIZED check suppresses exactly this frame
     // for windowless first loads; born-committed nodes need their own gate, #2990).
-        if (e.Pe !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ne) {
-        if (hasActiveOverride(e)) return !e.ge || !e.ge(e.Pe, unwrapOverride(e.o?.Oe));
-        return true;
+        if (e.Re !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ne) {
+        if (hasActiveOverride(e)) return !e.pe || !e.pe(e.Re, unwrapOverride(e.o?.Pe));
+        // A quiet re-ask's held landing still answers the same question: the
+        // classification survives the landing (asyncWrite) and dies with the
+        // commit (commitPendingNode) — verdict-quiet through the reveal, like
+        // the loading window above (#3178).
+                if (!t.o?.De) return true;
     }
     return newQuestionInFlight(t);
 }
@@ -185,7 +186,7 @@ function updatePendingSignal(e) {
 }
 
 function updateChildCompanions(e) {
-    const t = e.o?.St;
+    const t = e.o?.dt;
     if (t === undefined) return;
     for (const e of t) updatePendingSignal(e);
 }
@@ -235,11 +236,11 @@ function updateChildCompanions(e) {
         }
         if (s !== e) continue;
         suppressedProbes.delete(n);
-        const o = n.o?.ye?.o?.Je;
+        const o = n.o?.ye?.o?.$e;
         for (const e of i) {
             if (e.ie & REACTIVE_DISPOSED) continue;
             e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
-            if (o) assignOrMergeLane(e, o); else if (e.o !== null) e.o.Je = undefined;
+            if (o) assignOrMergeLane(e, o); else if (e.o !== null) e.o.$e = undefined;
             enqueueSub(e);
             t = true;
         }
@@ -250,18 +251,18 @@ function updateChildCompanions(e) {
 function snapCompanionsToState(e) {
     suppressedProbes.size !== 0 && suppressedProbes.delete(e);
     const t = e.o?.ye;
-    if (t && (t.o?.Oe === undefined || t.o?.Oe === NOT_PENDING)) {
+    if (t && (t.o?.Pe === undefined || t.o?.Pe === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.be !== n || t.Pe !== NOT_PENDING) {
+        if (t.be !== n || t.Re !== NOT_PENDING) {
             t.be = n;
-            t.Pe = NOT_PENDING;
+            t.Re = NOT_PENDING;
             insertSubs(t);
             schedule();
         }
     }
     const n = e.o?.Ce;
     if (n && !(n.ie & REACTIVE_DISPOSED)) {
-        if ((n.o?.Oe === undefined || n.o?.Oe === NOT_PENDING) && n.Pe === NOT_PENDING && !Object.is(n.be, e.be) && !(n.ie & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n.o?.Pe === undefined || n.o?.Pe === NOT_PENDING) && n.Re === NOT_PENDING && !Object.is(n.be, e.be) && !(n.ie & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
             n.ie |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
@@ -292,13 +293,13 @@ function getLatestValueComputed(e) {
         ext(e).Ce = t;
         e.T |= CONFIG_HAS_COMPANIONS;
         markFirewallChildCompanions(e);
-        ext(t).Tt = e;
+        ext(t).St = e;
  // Parent-child lane relationship
         // Backfill an in-flight write (mirrors getPendingSignal): the companion is
         // created lazily, possibly after the write was processed — syncCompanions
         // only pushes into companions that already exist, so the first latest()
         // read inside a held transition showed the committed value (#3041).
-                if (e.Pe !== NOT_PENDING && !hasActiveOverride(e)) setSignal(t, e.Pe);
+                if (e.Re !== NOT_PENDING && !hasActiveOverride(e)) setSignal(t, e.Re);
         setContextInternal(r);
         setPendingCheckActive(i);
         setLatestReadActive(n);
@@ -310,7 +311,7 @@ function getLatestValueComputed(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e.o?.Oe !== undefined && e.o?.Oe !== NOT_PENDING ? unwrapOverride(e.o?.Oe) : e.be;
+    const i = e.o?.Pe !== undefined && e.o?.Pe !== NOT_PENDING ? unwrapOverride(e.o?.Pe) : e.be;
     let r;
     try {
         // An untracked latest() read has no reading context, so read() never
@@ -319,7 +320,7 @@ function getLatestValueComputed(e) {
         // until the flush (#2922). Mirror the tracked-read pull here: mark the
         // queued staleness through the graph, then bring the shadow up to date.
         const e = queueFor(t);
-        if (t.Me >= e.Qe && !(t.ie & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.qe >= e.Me && !(t.ie & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             // Suspend probe collection during the pull (mirrors pendingCheckRead's
             // prepare): a probe through latest() answers for the SHADOW — the
@@ -346,10 +347,10 @@ function getLatestValueComputed(e) {
         setLatestReadActive(n);
     }
     if (t.S & STATUS_PENDING) return i;
-    if (stale && currentOptimisticLane && t.o?.Je) {
-        const e = findLane(t.o?.Je);
+    if (stale && currentOptimisticLane && t.o?.$e) {
+        const e = findLane(t.o?.$e);
         const n = findLane(currentOptimisticLane);
-        if (e !== n && e.De.size > 0) {
+        if (e !== n && laneHeld(e)) {
             return i;
         }
     }
@@ -357,7 +358,7 @@ function getLatestValueComputed(e) {
     // speculative value in _pendingValue; a contextless read() only surfaces
     // _value. Overrides stay authoritative (A17), and stale readers keep the
     // other transition's committed view, matching read()'s own selection.
-        if (t.Pe !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ae && activeTransition !== t.Ae)) return t.Pe;
+        if (t.Re !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ae && activeTransition !== t.Ae)) return t.Re;
     return r;
 }
 
@@ -371,9 +372,9 @@ function getLatestValueComputed(e) {
  * so the `_fn` check is belt-and-braces for this call site.
  */ function latestShadowWithInitializedParent(e) {
     if (typeof e.oe !== "function") return false;
-    const t = e.o?.Tt;
+    const t = e.o?.St;
     if (t === undefined) return false;
-    const n = t.st || t;
+    const n = t.rt || t;
     return !(n.S & STATUS_UNINITIALIZED);
 }
 
@@ -433,7 +434,7 @@ function getLatestValueComputed(e) {
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e.Pe !== NOT_PENDING && t === e.Pe) {
+    if (pendingProbe !== null && e.Re !== NOT_PENDING && t === e.Re) {
         if (heldAwaitingAsync(e)) return;
         pendingProbe.freshReads.add(e);
     }
@@ -441,10 +442,10 @@ function recordFreshRead(e, t) {
 
 function applyReask(e, t) {
     const n = !!(e.S & STATUS_PENDING);
-    const i = t && !(n && !e.o?.Ge);
-    const r = n && (e.o?.Ge ?? false) !== i;
+    const i = t && !(n && !e.o?.De);
+    const r = n && (e.o?.De ?? false) !== i;
     // Allocation-free for the quiet case: false is the extension default.
-        if (i) ext(e).Ge = true; else if (e.o !== null) e.o.Ge = false;
+        if (i) ext(e).De = true; else if (e.o !== null) e.o.De = false;
     return r;
 }
 
@@ -525,7 +526,7 @@ function isPending(e) {
 // Hook installation (same late-binding pattern as GlobalQueue._update /
 // _propagateAffects): core call sites fire these behind the same guards the
 // direct calls used, so behavior is identical once this module loads.
-GlobalQueue.Re = syncCompanions;
+GlobalQueue.Ue = syncCompanions;
 
 GlobalQueue.de = updatePendingSignal;
 
@@ -533,18 +534,18 @@ GlobalQueue.me = updateChildCompanions;
 
 GlobalQueue.un = snapCompanionsToState;
 
-GlobalQueue.gt = latestRead;
+GlobalQueue.Vt = latestRead;
 
-GlobalQueue.Ht = pendingCheckRead;
+GlobalQueue.bt = pendingCheckRead;
 
-GlobalQueue.kt = recordFreshRead;
+GlobalQueue.Lt = recordFreshRead;
 
-GlobalQueue.et = applyReask;
+GlobalQueue.nt = applyReask;
 
 GlobalQueue.k = repollDownstreamVerdicts;
 
-GlobalQueue.Wt = witnessAffects;
+GlobalQueue.zt = witnessAffects;
 
-GlobalQueue.zt = wakeSuppressedProbes;
+GlobalQueue.Kt = wakeSuppressedProbes;
 
 export { isPending, latest };

package/dist/prod/index.js

@@ -38,8 +38,6 @@ export { createProjectionNext as createProjection } from "./store/next/projectio
 
 export { merge, omit } from "./store/utils.js";
 
-export { patchableRaw, registerPatch, registerRowOps, registerSlotPatchNext as registerSlotPatch } from "./store/next/patch.js";
-
 export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store/next/store.js";
 
 export { storePath } from "./store/storePath.js";

package/dist/prod/map.js

@@ -6,6 +6,8 @@ import "./core/scheduler.js";
 
 import { CONFIG_AUTO_DISPOSE } from "./core/constants.js";
 
+import { attrHooks } from "./core/attribution-hooks.js";
+
 import "./core/invariants.js";
 
 import "./core/verdict.js";
@@ -23,23 +25,23 @@ function mapArray(t, s, i) {
     const r = s.length > 1;
     const n = s;
     const h = {
-        Kt: createOwner(),
-        $t: 0,
-        Jt: t,
-        Xt: [],
-        Yt: n,
-        Zt: [],
+        $t: createOwner(),
+        Jt: 0,
+        Xt: t,
+        Yt: [],
+        Zt: n,
         ts: [],
-        ss: e,
+        ss: [],
+        Ht: e,
         es: e || i?.keyed === false ? [] : undefined,
         rs: r && i?.keyed !== false ? [] : undefined,
         ns: i?.keyed === false,
         hs: i?.fallback
     };
-    const o = computed(updateKeyedMap.bind(h));
+    const o = computed(updateKeyedMap.bind(h), undefined);
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
     // them through node lets store-proxy lookups see pending writes (not stale _value).
-        h.Kt.Dt = o;
+        h.$t.Pt = o;
     o.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(o);
 }
@@ -58,163 +60,171 @@ const pureOptions = {
 // strong-abort ordering: removed rows now dispose AFTER the pass's new rows
 // are created (you cannot destroy state before knowing the pass will land).
 function updateKeyedMap() {
-    const t = this.Jt() || [], s = t.length;
+    const t = this.Xt() || [], s = t.length;
     t[$TRACK];
  // top level tracking
-        runWithOwner(this.Kt, () => {
+        runWithOwner(this.$t, () => {
         let i, e, r, n, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
         h = this.es ? this.ns ? () => {
             r[e] = signal(t[e], pureOptions);
-            return this.Yt(accessor(r[e]), e);
+            return this.Zt(accessor(r[e]), e);
         } : () => {
             r[e] = signal(t[e], pureOptions);
             n && (n[e] = signal(e, pureOptions));
-            return this.Yt(accessor(r[e]), n ? accessor(n[e]) : undefined);
+            return this.Zt(accessor(r[e]), n ? accessor(n[e]) : undefined);
         } : this.rs ? () => {
             const s = t[e];
             n[e] = signal(e, pureOptions);
-            return this.Yt(s, accessor(n[e]));
+            return this.Zt(s, accessor(n[e]));
         } : () => {
             const s = t[e];
-            return this.Yt(s);
+            return this.Zt(s);
         };
         // fast path for empty arrays
                 if (s === 0) {
-            if (this.$t !== 0) {
-                this.Kt.dispose(false);
+            if (this.Jt !== 0) {
+                this.$t.dispose(false);
+                this.ss = [];
+                this.Yt = [];
                 this.ts = [];
-                this.Xt = [];
-                this.Zt = [];
-                this.$t = 0;
+                this.Jt = 0;
                 this.es && (this.es = []);
                 this.rs && (this.rs = []);
             }
-            if (this.hs && !this.Zt[0]) {
+            if (this.hs && !this.ts[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.ts[0]?.dispose();
-                this.Zt[0] = runWithOwner(this.ts[0] = createOwner(), this.hs);
+                this.ss[0]?.dispose();
+                this.ts[0] = runWithOwner(this.ss[0] = createOwner(), this.hs);
             }
         }
         // fast path for new create
-         else if (this.$t === 0) {
+         else if (this.Jt === 0) {
             const o = new Array(s);
-            const c = new Array(s);
+            const a = new Array(s);
             r = this.es && new Array(s);
             n = this.rs && new Array(s);
             try {
-                for (e = 0; e < s; e++) o[e] = runWithOwner(c[e] = createOwner(), h);
+                for (e = 0; e < s; e++) o[e] = runWithOwner(a[e] = createOwner(), h);
             } catch (t) {
-                for (i = 0; i <= e; i++) c[i]?.dispose();
+                for (i = 0; i <= e; i++) a[i]?.dispose();
                 throw t;
             }
             // commit
-                        if (this.ts[0]) this.ts[0].dispose();
+                        if (this.ss[0]) this.ss[0].dispose();
  // previous fallback
-                        this.Zt = o;
-            this.ts = c;
+                        this.ts = o;
+            this.ss = a;
             r && (this.es = r);
             n && (this.rs = n);
-            this.Xt = t.slice(0);
-            this.$t = s;
+            this.Yt = t.slice(0);
+            this.Jt = s;
         } else {
-            let o, c, a, f, u, p, w, l, d;
+            let o, a, c, f, u, p, l, d, w, 
+            // Dev (attribution engine installed): the items behind the exited and
+            // entered rows, for the list-identity census.
+            m, O;
             // skip common prefix
-                        for (o = 0, c = Math.min(this.$t, s); o < c && (this.Xt[o] === t[o] || this.es && compare(this.ss, this.Xt[o], t[o])); o++) {
+                        for (o = 0, a = Math.min(this.Jt, s); o < a && (this.Yt[o] === t[o] || this.es && compare(this.Ht, this.Yt[o], t[o])); o++) {
                 if (this.es) setSignal(this.es[o], t[o]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (c = this.$t - 1, a = s - 1; c >= o && a >= o && (this.Xt[c] === t[a] || this.es && compare(this.ss, this.Xt[c], t[a])); c--, 
-            a--) ;
+                        for (a = this.Jt - 1, c = s - 1; a >= o && c >= o && (this.Yt[a] === t[c] || this.es && compare(this.Ht, this.Yt[a], t[c])); a--, 
+            c--) ;
             // no structural change (every position matched in place at equal
             // length — the common post-reconcile shape): keep the same mapped
             // array identity so downstream consumers don't re-run at all
-                        if (o === s && this.$t === s) {
-                this.Xt = t.slice(0);
+                        if (o === s && this.Jt === s) {
+                this.Yt = t.slice(0);
                 return;
             }
-            const O = s - this.$t;
-            const m = new Array(s);
-            const _ = new Array(s);
+            const _ = s - this.Jt;
+            const y = new Array(s);
+            const A = new Array(s);
             r = this.es ? new Array(s) : undefined;
             n = this.rs ? new Array(s) : undefined;
             // 0) prepare a map of all indices in the changed window of newItems,
             // scanning backwards so we encounter them in natural order
                         p = new Map;
-            w = new Array(a + 1);
-            for (e = a; e >= o; e--) {
+            l = new Array(c + 1);
+            for (e = c; e >= o; e--) {
                 f = t[e];
-                u = this.ss ? this.ss(f) : f;
+                u = this.Ht ? this.Ht(f) : f;
                 i = p.get(u);
-                w[e] = i === undefined ? -1 : i;
+                l[e] = i === undefined ? -1 : i;
                 p.set(u, e);
             }
             // 1) step through the old changed window and see if items can be found
             // in the new set; if so, stage them at their new positions; if not,
             // queue them for disposal at commit
-                        for (i = o; i <= c; i++) {
-                f = this.Xt[i];
-                u = this.ss ? this.ss(f) : f;
+                        for (i = o; i <= a; i++) {
+                f = this.Yt[i];
+                u = this.Ht ? this.Ht(f) : f;
                 e = p.get(u);
                 if (e !== undefined && e !== -1) {
-                    m[e] = this.Zt[i];
-                    _[e] = this.ts[i];
+                    y[e] = this.ts[i];
+                    A[e] = this.ss[i];
                     r && (r[e] = this.es[i]);
                     n && (n[e] = this.rs[i]);
-                    e = w[e];
+                    e = l[e];
                     p.set(u, e);
-                } else (l ??= []).push(this.ts[i]);
+                } else {
+                    (d ??= []).push(this.ss[i]);
+                    if (false && attrHooks !== null) ;
+                }
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
-                for (e = o; e <= a; e++) {
-                    if (_[e] !== undefined) continue;
-                    (d ??= []).push(_[e] = createOwner());
-                    m[e] = runWithOwner(_[e], h);
+                for (e = o; e <= c; e++) {
+                    if (A[e] !== undefined) continue;
+                    (w ??= []).push(A[e] = createOwner());
+                    if (false && attrHooks !== null) ;
+                    y[e] = runWithOwner(A[e], h);
                 }
             } catch (t) {
-                if (d) for (i = 0; i < d.length; i++) d[i].dispose();
+                if (w) for (i = 0; i < w.length; i++) w[i].dispose();
                 throw t;
             }
             // 3) commit: land the retained prefix and suffix plus the staged window
             // into the fresh arrays, swap them in (new identity for downstream
             // change propagation), then dispose exited rows
                         for (i = 0; i < o; i++) {
-                m[i] = this.Zt[i];
-                _[i] = this.ts[i];
+                y[i] = this.ts[i];
+                A[i] = this.ss[i];
                 r && (r[i] = this.es[i]);
                 n && (n[i] = this.rs[i]);
             }
-            for (e = o; e <= a; e++) {
+            for (e = o; e <= c; e++) {
                 if (r) setSignal(r[e], t[e]);
                 if (n) setSignal(n[e], e);
             }
-            for (e = a + 1; e < s; e++) {
-                m[e] = this.Zt[e - O];
-                _[e] = this.ts[e - O];
+            for (e = c + 1; e < s; e++) {
+                y[e] = this.ts[e - _];
+                A[e] = this.ss[e - _];
                 if (r) {
-                    r[e] = this.es[e - O];
+                    r[e] = this.es[e - _];
                     setSignal(r[e], t[e]);
                 }
                 if (n) {
-                    n[e] = this.rs[e - O];
-                    if (O !== 0) setSignal(n[e], e);
+                    n[e] = this.rs[e - _];
+                    if (_ !== 0) setSignal(n[e], e);
                 }
             }
-            this.Zt = m;
-            this.ts = _;
+            this.ts = y;
+            this.ss = A;
             r && (this.es = r);
             n && (this.rs = n);
-            this.$t = s;
+            this.Jt = s;
             // save a copy of the mapped items for the next update
-                        this.Xt = t.slice(0);
-            if (l) for (i = 0; i < l.length; i++) l[i].dispose();
+                        this.Yt = t.slice(0);
+            if (d) for (i = 0; i < d.length; i++) d[i].dispose();
+            if (false && attrHooks !== null && m !== undefined && O !== undefined) ;
         }
     });
-    return this.Zt;
+    return this.ts;
 }
 
 /**
@@ -234,13 +244,13 @@ function updateKeyedMap() {
  */ function repeat(t, s, i) {
     const e = s;
     const r = {
-        Kt: createOwner(),
-        $t: 0,
+        $t: createOwner(),
+        Jt: 0,
         cs: 0,
         fs: t,
-        Yt: e,
+        Zt: e,
+        ss: [],
         ts: [],
-        Zt: [],
         us: i?.from,
         hs: i?.fallback
     };
@@ -248,7 +258,7 @@ function updateKeyedMap() {
     // Same as mapArray: untracked reads inside the internal owner resolve via
     // _parentComputed, so async reads in row callbacks register with the node
     // (pending tracking + post-settle retry) instead of vanishing.
-        r.Kt.Dt = n;
+        r.$t.Pt = n;
     n.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
@@ -263,26 +273,26 @@ function updateKeyedMap() {
 function updateRepeat() {
     const t = this.fs();
     const s = this.us?.() || 0;
-    runWithOwner(this.Kt, () => {
+    runWithOwner(this.$t, () => {
         if (t === 0) {
-            if (this.$t !== 0) {
-                this.Kt.dispose(false);
+            if (this.Jt !== 0) {
+                this.$t.dispose(false);
+                this.ss = [];
                 this.ts = [];
-                this.Zt = [];
-                this.$t = 0;
+                this.Jt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
                                 this.cs = 0;
             }
-            if (this.hs && !this.Zt[0]) {
+            if (this.hs && !this.ts[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.ts[0]?.dispose();
-                this.Zt[0] = runWithOwner(this.ts[0] = createOwner(), this.hs);
+                this.ss[0]?.dispose();
+                this.ts[0] = runWithOwner(this.ss[0] = createOwner(), this.hs);
             }
             return;
         }
         const i = s + t;
-        const e = this.cs + this.$t;
+        const e = this.cs + this.Jt;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
                 const r = Math.max(s, this.cs);
@@ -290,26 +300,26 @@ function updateRepeat() {
         const h = new Array(t);
         const o = new Array(t);
         for (let t = r; t < n; t++) {
-            o[t - s] = this.ts[t - this.cs];
-            h[t - s] = this.Zt[t - this.cs];
+            o[t - s] = this.ss[t - this.cs];
+            h[t - s] = this.ts[t - this.cs];
         }
         try {
             for (let t = s; t < i; t++) {
                 if (t >= r && t < n) continue;
-                h[t - s] = runWithOwner(o[t - s] = createOwner(), () => this.Yt(t));
+                h[t - s] = runWithOwner(o[t - s] = createOwner(), () => this.Zt(t));
             }
         } catch (t) {
             for (let t = s; t < i; t++) if ((t < r || t >= n) && o[t - s]) o[t - s].dispose();
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.$t === 0) this.ts[0]?.dispose(); else for (let t = this.cs; t < e; t++) if (t < s || t >= i) this.ts[t - this.cs].dispose();
-        this.Zt = h;
-        this.ts = o;
+                if (this.Jt === 0) this.ss[0]?.dispose(); else for (let t = this.cs; t < e; t++) if (t < s || t >= i) this.ss[t - this.cs].dispose();
+        this.ts = h;
+        this.ss = o;
         this.cs = s;
-        this.$t = t;
+        this.Jt = t;
     });
-    return this.Zt;
+    return this.ts;
 }
 
 function compare(t, s, i) {