fix(timeline): bound the loaded window with far-edge eviction

The all-repos windowed hook documents itself as keeping "ONE window", but
extendOlder / extendNewer appended / prepended without ever evicting — a
long uninterrupted scroll accumulated the whole walked history in React
state, against the unbounded-scale mandate.

The window is now capped at MAX_WINDOW rows. Extending past the cap drops
the rows now far from the viewport — extendOlder evicts the top and bumps
baseIndex, extendNewer evicts the bottom — recomputing the edge cursor
from the new edge row (a cursor is reconstructable straight from a
CommitSummary now that it is keyed on repo_path). The count-tall scroll
track keeps evicted rows at their true global positions, so scrolling
back simply re-loads them.

tsc + vite build clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: var-gg

src/lib/useTimelineWindow.ts

@@ -36,6 +36,10 @@ const ANCHOR_AFTER = 150;
 const EXTEND_GAP = 120;
 /** Collapse a flurry of scroll events (a scrollbar drag) into one jump. */
 const JUMP_DEBOUNCE_MS = 100;
+/** Hard cap on the loaded window. Extending past it evicts the far edge,
+ *  so an uninterrupted scroll can't accumulate the whole history in
+ *  memory — the window stays bounded regardless of scroll distance. */
+const MAX_WINDOW = 600;
 
 /** Stable identity for a commit across reloads. */
 function commitKey(c: { repoPath: string; hash: string }): string {
@@ -45,6 +49,13 @@ function nowSec(): number {
   return Math.floor(Date.now() / 1000);
 }
 
+/** A commit's keyset cursor, reconstructed from the row itself — the cursor
+ *  is (sort_ts, repo_path, hash) with sort_ts = -timestamp, all carried by
+ *  the CommitSummary. Used to recompute an edge cursor after a window trim. */
+function cursorOf(c: CommitSummary): Cursor {
+  return { sortTs: -c.timestamp, repoPath: c.repoPath, hash: c.hash };
+}
+
 export interface TimelineWindowParams {
   /** repo-id filter, or null for all repos */
   repoIds: number[] | null;
@@ -206,13 +217,25 @@ export function useTimelineWindow(
         .then((win) => {
           if (qid !== queryRef.current) return;
           const cur = windowRef.current;
-          const merged = [...cur.rows, ...win.rows];
+          let rows = [...cur.rows, ...win.rows];
+          let baseIndex = cur.baseIndex;
+          let startCursor = cur.startCursor;
+          // Cap the window — evict the rows now far above the viewport.
+          if (rows.length > MAX_WINDOW) {
+            const trim = rows.length - MAX_WINDOW;
+            rows = rows.slice(trim);
+            baseIndex += trim;
+            startCursor = cursorOf(rows[0]);
+          }
           windowRef.current = {
             ...cur,
-            rows: merged,
+            rows,
+            baseIndex,
+            startCursor,
             endCursor: win.endCursor ?? cur.endCursor,
           };
-          setRows(merged);
+          setRows(rows);
+          setBaseIndex(baseIndex);
         })
         .catch(() => {})
         .finally(() => {
@@ -232,16 +255,23 @@ export function useTimelineWindow(
         .then((win) => {
           if (qid !== queryRef.current) return;
           const cur = windowRef.current;
-          const merged = [...win.rows, ...cur.rows];
-          const newBase = Math.max(0, cur.baseIndex - win.rows.length);
+          let rows = [...win.rows, ...cur.rows];
+          const baseIndex = Math.max(0, cur.baseIndex - win.rows.length);
+          let endCursor = cur.endCursor;
+          // Cap the window — evict the rows now far below the viewport.
+          if (rows.length > MAX_WINDOW) {
+            rows = rows.slice(0, MAX_WINDOW);
+            endCursor = cursorOf(rows[rows.length - 1]);
+          }
           windowRef.current = {
             ...cur,
-            rows: merged,
-            baseIndex: newBase,
+            rows,
+            baseIndex,
             startCursor: win.startCursor ?? cur.startCursor,
+            endCursor,
           };
-          setRows(merged);
-          setBaseIndex(newBase);
+          setRows(rows);
+          setBaseIndex(baseIndex);
         })
         .catch(() => {})
         .finally(() => {