Perf/UI cover cache mainstage (#468)

* Enhance CachedImage and ArtistDetail components with improved image caching and priority handling

- Refactor CachedImage to utilize a priority system for image loading based on viewport visibility, improving performance during scrolling.
- Update useCachedUrl to accept an optional getPriority function for better cache management.
- Optimize ArtistDetail and Artists components by using useMemo for cover art URLs, reducing redundant calculations and improving rendering efficiency.
- Adjust image loading logic in CachedImage to ensure smoother transitions and avoid unnecessary fetch requests.

* perf(ui): unblock IDB cover art, stabilize mainstage rails and virtual lists

Let IndexedDB reads bypass the network concurrency slot so cached thumbnails
paint without queueing behind remote fetches; debounce disk eviction during
heavy scrolling.

Fix mainstage horizontal rails: dedupe album/song ids for React keys, widen
artwork budget overscan, avoid resetting the budget on list append, and raise
Home initial artwork budgets. CachedImage treats already-decoded images as
loaded; rail cards load cover images eagerly.

Refresh dynamic color extraction and extend virtual scrolling / scroll roots on
Albums, Artists, Playlists, and related surfaces.


Remove local agent-only commit instructions from the repository tree.

* perf(virtual): viewport-based overscan for main scroll lists

Drive TanStack Virtual overscan from measured scroll height so each list
renders about one screen of extra rows above and below the viewport for
snappier scrolling on Albums, Artists (list mode), and Tracks virtual song list.

Introduce useResizeClientHeight helpers (ID + ref) for ResizeObserver-based
clientHeight tracking.

* docs(changelog): note PR #468 UI cover cache, rails, and virtual lists

Add a coarse summary under 1.46.0 Changed for cover-art pipeline,
mainstage rails, viewport-based overscan, and library/chrome polish.

src/pages/Albums.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useState, useCallback, useRef, useMemo } from 'react';
+import React, { useState, useEffect, useRef, useCallback, useMemo, useLayoutEffect } from 'react';
 import AlbumCard from '../components/AlbumCard';
 import GenreFilterBar from '../components/GenreFilterBar';
 import YearFilterButton from '../components/YearFilterButton';
@@ -16,8 +16,16 @@ import { join } from '@tauri-apps/api/path';
 import { showToast } from '../utils/toast';
 import { useZipDownloadStore } from '../store/zipDownloadStore';
 import { CheckSquare2, Download, HardDriveDownload, ListMusic, Disc3, ListPlus } from 'lucide-react';
+import { useVirtualizer } from '@tanstack/react-virtual';
+import { APP_MAIN_SCROLL_VIEWPORT_ID } from '../constants/appScroll';
+import { useElementClientHeightById } from '../hooks/useResizeClientHeight';
 import { usePerfProbeFlags } from '../utils/perfFlags';
 
+const ALBUM_GRID_GAP_PX = 16; // matches --space-4
+const ALBUM_GRID_MIN_CARD_PX = 140;
+/** Estimated row height for virtual window (card + margin). */
+const ALBUM_VIRTUAL_ROW_HEIGHT = 288;
+
 type SortType = 'alphabeticalByName' | 'alphabeticalByArtist';
 type CompFilter = 'all' | 'only' | 'hide';
 
@@ -87,6 +95,38 @@ export default function Albums() {
     return out;
   }, [albums, compFilter, starredOnly, starredOverrides]);
 
+  const albumGridWrapRef = useRef<HTMLDivElement>(null);
+  const [albumGridCols, setAlbumGridCols] = useState(4);
+
+  useLayoutEffect(() => {
+    if (perfFlags.disableMainstageVirtualLists) return;
+    const el = albumGridWrapRef.current;
+    if (!el) return;
+    const ro = new ResizeObserver(() => {
+      const w = el.clientWidth;
+      const cols = Math.max(1, Math.floor((w + ALBUM_GRID_GAP_PX) / (ALBUM_GRID_MIN_CARD_PX + ALBUM_GRID_GAP_PX)));
+      setAlbumGridCols(cols);
+    });
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [perfFlags.disableMainstageVirtualLists, visibleAlbums.length]);
+
+  const albumVirtualRowCount = Math.max(0, Math.ceil(visibleAlbums.length / albumGridCols));
+
+  const mainScrollViewportHeight = useElementClientHeightById(APP_MAIN_SCROLL_VIEWPORT_ID);
+  /** ~One full viewport of grid rows above + below visible range (TanStack overscan = rows per side). */
+  const albumGridOverscan = Math.max(
+    2,
+    Math.ceil(mainScrollViewportHeight / ALBUM_VIRTUAL_ROW_HEIGHT),
+  );
+
+  const albumGridVirtualizer = useVirtualizer({
+    count: perfFlags.disableMainstageVirtualLists ? 0 : albumVirtualRowCount,
+    getScrollElement: () => document.getElementById(APP_MAIN_SCROLL_VIEWPORT_ID),
+    estimateSize: () => ALBUM_VIRTUAL_ROW_HEIGHT,
+    overscan: albumGridOverscan,
+  });
+
   const selectedAlbums = visibleAlbums.filter(a => selectedIds.has(a.id));
   const openContextMenu = usePlayerStore(state => state.openContextMenu);
   const enqueue = usePlayerStore(state => state.enqueue);
@@ -313,18 +353,66 @@ export default function Albums() {
       ) : (
         <>
           {!perfFlags.disableMainstageGridCards && (
-            <div className="album-grid-wrap">
-              {visibleAlbums.map(a => (
-                <AlbumCard
-                  key={a.id}
-                  album={a}
-                  selectionMode={selectionMode}
-                  selected={selectedIds.has(a.id)}
-                  onToggleSelect={toggleSelect}
-                  selectedAlbums={selectedAlbums}
-                />
-              ))}
-            </div>
+            perfFlags.disableMainstageVirtualLists ? (
+              <div className="album-grid-wrap">
+                {visibleAlbums.map(a => (
+                  <AlbumCard
+                    key={a.id}
+                    album={a}
+                    selectionMode={selectionMode}
+                    selected={selectedIds.has(a.id)}
+                    onToggleSelect={toggleSelect}
+                    selectedAlbums={selectedAlbums}
+                  />
+                ))}
+              </div>
+            ) : (
+              <div
+                ref={albumGridWrapRef}
+                className="album-grid-wrap"
+                style={{ display: 'block', position: 'relative', width: '100%' }}
+              >
+                <div
+                  style={{
+                    height: albumVirtualRowCount === 0 ? 0 : albumGridVirtualizer.getTotalSize(),
+                    width: '100%',
+                    position: 'relative',
+                  }}
+                >
+                  {albumGridVirtualizer.getVirtualItems().map(vRow => {
+                    const start = vRow.index * albumGridCols;
+                    const rowAlbums = visibleAlbums.slice(start, start + albumGridCols);
+                    return (
+                      <div
+                        key={vRow.key}
+                        style={{
+                          position: 'absolute',
+                          top: 0,
+                          left: 0,
+                          width: '100%',
+                          transform: `translateY(${vRow.start}px)`,
+                          display: 'grid',
+                          gridTemplateColumns: `repeat(${albumGridCols}, minmax(0, 1fr))`,
+                          gap: 'var(--space-4)',
+                          alignItems: 'start',
+                        }}
+                      >
+                        {rowAlbums.map(a => (
+                          <AlbumCard
+                            key={a.id}
+                            album={a}
+                            selectionMode={selectionMode}
+                            selected={selectedIds.has(a.id)}
+                            onToggleSelect={toggleSelect}
+                            selectedAlbums={selectedAlbums}
+                          />
+                        ))}
+                      </div>
+                    );
+                  })}
+                </div>
+              </div>
+            )
           )}
           {!genreFiltered && (
             <div ref={observerTarget} style={{ height: '20px', margin: '2rem 0', display: 'flex', justifyContent: 'center' }}>