fix(signals): repeat() handles disjoint window jumps (#2853, from #2854)

updateRepeat modeled every window move as clear-end + shift-front + fill,
valid only when the old and new windows overlap. Disjoint moves walked
_nodes at negative local indices: forward jumps larger than the window
created and leaked every gap row (owners/effects alive, invisible to
dispose bookkeeping), first render with nonzero `from` mapped the whole
prefix, and backward disjoint jumps threw on _nodes[negative].dispose()
and froze the list. Detect disjointness up front (from >= prevTo ||
to <= offset — the exact complement of overlap) and replace the window
wholesale; overlapping slides (the #2784 fix) are untouched.

Co-authored-by: yumemi-thomas <yumemi-thomas@users.noreply.github.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

Author: 3 people

.changeset/repeat-disjoint-window.md

@@ -0,0 +1,5 @@
+---
+"@solidjs/signals": patch
+---
+
+Fix `repeat()` / `<Repeat>` leaking live row scopes and crashing on disjoint window jumps. When a reactive `from` moves the window to indices that don't overlap the previous window, the shift-and-fill update walked `_nodes` at negative local indices: a forward jump larger than the window created every gap row and left them alive (owners, effects, and `onCleanup`s never disposed), and a backward disjoint jump threw `Cannot read properties of undefined (reading 'dispose')` and froze the list. The first render with a nonzero `from` mapped the whole `0..from+count` prefix for the same reason. Disjoint windows are now detected and replaced wholesale; overlapping slides (the #2784 fix) are unchanged.

packages/solid-signals/src/map.ts

@@ -346,6 +346,20 @@ function updateRepeat<MappedItem>(this: RepeatData<MappedItem>): any[] {
     // remove fallback
     if (this._len === 0 && this._nodes[0]) this._nodes[0].dispose();
 
+    // Disjoint windows have no rows to retain; replace them wholesale.
+    if (from >= prevTo || to <= this._offset) {
+      for (let i = 0; i < this._len; i++) this._nodes[i].dispose();
+      this._nodes = new Array(newLen);
+      this._mappings = new Array(newLen);
+      for (let i = 0; i < newLen; i++)
+        this._mappings[i] = runWithOwner<MappedItem>((this._nodes[i] = createOwner()), () =>
+          this._map(from + i)
+        );
+      this._offset = from;
+      this._len = newLen;
+      return;
+    }
+
     // clear the end
     for (let i = to; i < prevTo; i++) this._nodes[i - this._offset].dispose();
 

packages/solid-signals/tests/repeat.test.ts

@@ -346,3 +346,76 @@ it("slides the window backwards: disposes departing rows and retains the overlap
   // only the departing rows were disposed
   expect(disposed.sort()).toEqual([4, 5]);
 });
+
+describe("disjoint window jumps", () => {
+  function windowed() {
+    const [from, setFrom] = createSignal(0);
+    let created = 0;
+    let cleaned = 0;
+    let view!: () => number[];
+    createRoot(() => {
+      view = repeat(
+        () => 3,
+        i => {
+          created++;
+          onCleanup(() => cleaned++);
+          return i;
+        },
+        { from }
+      );
+    });
+    flush();
+    return {
+      view,
+      jump: (n: number) => {
+        setFrom(n);
+        flush();
+      },
+      live: () => created - cleaned
+    };
+  }
+
+  it("a forward jump larger than the window creates only the window's rows", () => {
+    const w = windowed();
+    expect(w.view()).toEqual([0, 1, 2]);
+    expect(w.live()).toBe(3);
+    w.jump(10);
+    expect(w.view()).toEqual([10, 11, 12]);
+    expect(w.live()).toBe(3);
+  });
+
+  it("repeated disjoint jumps do not accumulate live scopes", () => {
+    const w = windowed();
+    w.jump(10);
+    w.jump(20);
+    expect(w.view()).toEqual([20, 21, 22]);
+    expect(w.live()).toBe(3);
+  });
+
+  it("a backward disjoint jump maps the new window without crashing", () => {
+    const w = windowed();
+    w.jump(20);
+    expect(() => w.jump(0)).not.toThrow();
+    expect(w.view()).toEqual([0, 1, 2]);
+    expect(w.live()).toBe(3);
+  });
+
+  it("initial render with a nonzero `from` maps only the window", () => {
+    const [from] = createSignal(10);
+    let created = 0;
+    let view!: () => number[];
+    createRoot(() => {
+      view = repeat(
+        () => 3,
+        i => {
+          created++;
+          return i;
+        },
+        { from }
+      );
+    });
+    flush();
+    expect(view()).toEqual([10, 11, 12]);
+    expect(created).toBe(3);
+  });
+});