Merge branch 'main' into exp/orbit (pre-PR sync)

Conflicts resolved in:
- src/pages/SearchResults.tsx
- src/pages/AdvancedSearch.tsx

Both pages were rewritten on main (PR #303) to use the shared
<SongRow> component with click-to-enqueueAndPlay semantics. Orbit's
playSong helper that branched on orbit-active is no longer needed
at the page level — instead, orbit awareness moved INTO SongRow and
SongCard themselves: in an active orbit session both buttons collapse
into addTrackToOrbit (suggest for guests, host-enqueue for the host)
so we don't ship a queue replacement to every guest.

Also kept main's IntersectionObserver-based pagination on both pages.

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

src/pages/AdvancedSearch.tsx

@@ -1,19 +1,16 @@
-import React, { useEffect, useState } from 'react';
-import { useSearchParams, useNavigate } from 'react-router-dom';
-import { Play, SlidersVertical } from 'lucide-react';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { useSearchParams } from 'react-router-dom';
+import { SlidersVertical } from 'lucide-react';
 import {
-  search, getGenres, getAlbumsByGenre, getAlbumList, getRandomSongs,
+  search, searchSongsPaged, getGenres, getAlbumsByGenre, getAlbumList, getRandomSongs,
   SubsonicGenre, SubsonicArtist, SubsonicAlbum, SubsonicSong,
 } from '../api/subsonic';
-import { usePlayerStore, songToTrack } from '../store/playerStore';
 import { useTranslation } from 'react-i18next';
 import AlbumRow from '../components/AlbumRow';
 import ArtistRow from '../components/ArtistRow';
+import SongRow, { SongListHeader } from '../components/SongRow';
 import CustomSelect from '../components/CustomSelect';
-import { useDragDrop } from '../contexts/DragDropContext';
-import { useOrbitSongRowBehavior } from '../hooks/useOrbitSongRowBehavior';
 import { useAuthStore } from '../store/authStore';
-import { useShallow } from 'zustand/react/shallow';
 
 type ResultType = 'all' | 'artists' | 'albums' | 'songs';
 
@@ -35,25 +32,6 @@ export default function AdvancedSearch() {
   const { t } = useTranslation();
   const [params] = useSearchParams();
   const qFromUrl = params.get('q') ?? '';
-  const navigate = useNavigate();
-  const psyDrag = useDragDrop();
-
-  const { playTrack, openContextMenu } = usePlayerStore(
-    useShallow(s => ({
-      playTrack: s.playTrack,
-      openContextMenu: s.openContextMenu,
-    }))
-  );
-
-  const { orbitActive, addTrackToOrbit } = useOrbitSongRowBehavior();
-
-  const [contextMenuSongId, setContextMenuSongId] = useState<string | null>(null);
-  const contextMenuOpen = usePlayerStore(s => s.contextMenu.isOpen);
-
-  useEffect(() => {
-    if (!contextMenuOpen) setContextMenuSongId(null);
-  }, [contextMenuOpen]);
-
   const [query, setQuery] = useState(params.get('q') ?? '');
   const [genre, setGenre] = useState('');
   const [yearFrom, setYearFrom] = useState('');
@@ -69,10 +47,35 @@ export default function AdvancedSearch() {
   const [genreNote, setGenreNote] = useState(false);
   const musicLibraryFilterVersion = useAuthStore(s => s.musicLibraryFilterVersion);
 
+  // Pagination — only the free-text-query branch uses search3 with offset
+  const SONGS_INITIAL = 100;
+  const SONGS_PAGE_SIZE = 50;
+  const [activeSearch, setActiveSearch] = useState<SearchOpts | null>(null);
+  const [songsServerOffset, setSongsServerOffset] = useState(0);
+  const [songsHasMore, setSongsHasMore] = useState(false);
+  const [loadingMoreSongs, setLoadingMoreSongs] = useState(false);
+  const songsSentinelRef = useRef<HTMLDivElement>(null);
+
+  const applySongFilters = (
+    list: SubsonicSong[],
+    g: string,
+    from: number | null,
+    to: number | null,
+  ): SubsonicSong[] => {
+    let r = list;
+    if (g) r = r.filter(s => s.genre?.toLowerCase() === g.toLowerCase());
+    if (from !== null) r = r.filter(s => !s.year || s.year >= from);
+    if (to !== null) r = r.filter(s => !s.year || s.year <= to);
+    return r;
+  };
+
   const runSearch = async (opts: SearchOpts) => {
     setLoading(true);
     setHasSearched(true);
     setGenreNote(false);
+    setActiveSearch(opts);
+    setSongsServerOffset(0);
+    setSongsHasMore(false);
     const { query: q, genre: g, yearFrom: yf, yearTo: yt, resultType: rt } = opts;
     const from = yf ? parseInt(yf) : null;
     const to = yt ? parseInt(yt) : null;
@@ -83,23 +86,25 @@ export default function AdvancedSearch() {
 
     try {
       if (q.trim()) {
-        const r = await search(q.trim(), { artistCount: 30, albumCount: 50, songCount: 100 });
+        const r = await search(q.trim(), { artistCount: 30, albumCount: 50, songCount: SONGS_INITIAL });
         artists = r.artists;
         albums = r.albums;
-        songs = r.songs;
+        songs = applySongFilters(r.songs, g, from, to);
 
         if (g) {
           albums = albums.filter(a => a.genre?.toLowerCase() === g.toLowerCase());
-          songs = songs.filter(s => s.genre?.toLowerCase() === g.toLowerCase());
         }
         if (from !== null) {
           albums = albums.filter(a => !a.year || a.year >= from);
-          songs = songs.filter(s => !s.year || s.year >= from);
         }
         if (to !== null) {
           albums = albums.filter(a => !a.year || a.year <= to);
-          songs = songs.filter(s => !s.year || s.year <= to);
         }
+
+        // Only the free-text branch supports server-side pagination via search3 offset.
+        // If the server returned a full page, more probably exist.
+        setSongsServerOffset(r.songs.length);
+        setSongsHasMore(r.songs.length === SONGS_INITIAL);
       } else if (g) {
         const [albumRes, songRes] = await Promise.all([
           rt === 'songs' || rt === 'artists' ? Promise.resolve([]) : getAlbumsByGenre(g, 50),
@@ -134,6 +139,39 @@ export default function AdvancedSearch() {
     if (qFromUrl) runSearch({ query: qFromUrl, genre: '', yearFrom: '', yearTo: '', resultType: 'all' });
   }, [musicLibraryFilterVersion, qFromUrl]);
 
+  const loadMoreSongs = useCallback(async () => {
+    if (loadingMoreSongs || !songsHasMore) return;
+    if (!activeSearch || !activeSearch.query.trim()) return;
+    setLoadingMoreSongs(true);
+    try {
+      const q = activeSearch.query.trim();
+      const g = activeSearch.genre;
+      const from = activeSearch.yearFrom ? parseInt(activeSearch.yearFrom) : null;
+      const to = activeSearch.yearTo ? parseInt(activeSearch.yearTo) : null;
+      const page = await searchSongsPaged(q, SONGS_PAGE_SIZE, songsServerOffset);
+      const filtered = applySongFilters(page, g, from, to);
+      setResults(prev => prev ? { ...prev, songs: [...prev.songs, ...filtered] } : prev);
+      setSongsServerOffset(o => o + page.length);
+      // No more pages when the server returned a non-full page (regardless of how many survived filtering).
+      if (page.length < SONGS_PAGE_SIZE) setSongsHasMore(false);
+    } catch {
+      setSongsHasMore(false);
+    } finally {
+      setLoadingMoreSongs(false);
+    }
+  }, [loadingMoreSongs, songsHasMore, activeSearch, songsServerOffset]);
+
+  // IntersectionObserver on the bottom sentinel — fires loadMoreSongs as it nears the viewport.
+  useEffect(() => {
+    const el = songsSentinelRef.current;
+    if (!el) return;
+    const obs = new IntersectionObserver(entries => {
+      if (entries[0]?.isIntersecting) loadMoreSongs();
+    }, { rootMargin: '600px' });
+    obs.observe(el);
+    return () => obs.disconnect();
+  }, [loadMoreSongs]);
+
   const handleSubmit = (e?: React.FormEvent) => {
     e?.preventDefault();
     runSearch({ query, genre, yearFrom, yearTo, resultType });
@@ -282,90 +320,22 @@ export default function AdvancedSearch() {
           {results && results.songs.length > 0 && (
             <section>
               <h2 className="section-title" style={{ marginBottom: '0.75rem' }}>
-                {t('search.songs')} ({results.songs.length})
+                {t('search.songs')}
                 {genreNote && (
                   <span style={{ fontSize: 12, fontWeight: 400, color: 'var(--text-muted)', marginLeft: '0.75rem' }}>
                     — {t('search.advancedGenreNote')}
                   </span>
                 )}
               </h2>
-              <div className="tracklist">
-                <div className="tracklist-header" style={{ gridTemplateColumns: '60px minmax(150px, 1fr) minmax(80px, 1fr) minmax(80px, 1fr) 90px 65px' }}>
-                  <span />
-                  <span>{t('randomMix.trackTitle')}</span>
-                  <span>{t('randomMix.trackArtist')}</span>
-                  <span>{t('randomMix.trackAlbum')}</span>
-                  <span>{t('randomMix.trackGenre')}</span>
-                  <span style={{ textAlign: 'right' }}>{t('randomMix.trackDuration')}</span>
+              <SongListHeader />
+              {results.songs.map(song => (
+                <SongRow key={song.id} song={song} />
+              ))}
+              {songsHasMore && (
+                <div ref={songsSentinelRef} style={{ display: 'flex', justifyContent: 'center', padding: '1rem' }}>
+                  {loadingMoreSongs && <div className="spinner" style={{ width: 20, height: 20 }} />}
                 </div>
-                {results.songs.map(song => {
-                  const track = songToTrack(song);
-                  return (
-                    <div
-                      key={song.id}
-                      className={`track-row${contextMenuSongId === song.id ? ' context-active' : ''}`}
-                      style={{ gridTemplateColumns: '60px minmax(150px, 1fr) minmax(80px, 1fr) minmax(80px, 1fr) 90px 65px' }}
-                      onDoubleClick={() => orbitActive ? addTrackToOrbit(song.id) : playTrack(track, results.songs.map(songToTrack))}
-                      role="row"
-                      onContextMenu={e => {
-                        e.preventDefault();
-                        setContextMenuSongId(song.id);
-                        openContextMenu(e.clientX, e.clientY, track, 'song');
-                      }}
-                      onMouseDown={e => {
-                        if (e.button !== 0) return;
-                        e.preventDefault();
-                        const sx = e.clientX, sy = e.clientY;
-                        const onMove = (me: MouseEvent) => {
-                          if (Math.abs(me.clientX - sx) > 5 || Math.abs(me.clientY - sy) > 5) {
-                            document.removeEventListener('mousemove', onMove);
-                            document.removeEventListener('mouseup', onUp);
-                            psyDrag.startDrag({ data: JSON.stringify({ type: 'song', track }), label: song.title }, me.clientX, me.clientY);
-                          }
-                        };
-                        const onUp = () => { document.removeEventListener('mousemove', onMove); document.removeEventListener('mouseup', onUp); };
-                        document.addEventListener('mousemove', onMove);
-                        document.addEventListener('mouseup', onUp);
-                      }}
-                    >
-                      <button
-                        className="btn btn-ghost"
-                        style={{ padding: 4 }}
-                        onClick={e => { e.stopPropagation(); if (orbitActive) { addTrackToOrbit(song.id); return; } playTrack(track, results.songs.map(songToTrack)); }}
-                      >
-                        <Play size={13} fill="currentColor" />
-                      </button>
-                      <div className="track-info">
-                        <span className="track-title">{song.title}</span>
-                      </div>
-                      <div className="track-artist-cell">
-                        <span
-                          className={`track-artist${song.artistId ? ' track-artist-link' : ''}`}
-                          style={{ cursor: song.artistId ? 'pointer' : 'default' }}
-                          onClick={() => song.artistId && navigate(`/artist/${song.artistId}`)}
-                        >
-                          {song.artist}
-                        </span>
-                      </div>
-                      <div className="track-info">
-                        <span
-                          className="track-title"
-                          style={{ fontSize: '0.85rem', color: 'var(--subtext0)', cursor: 'pointer' }}
-                          onClick={() => navigate(`/album/${song.albumId}`)}
-                        >
-                          {song.album}
-                        </span>
-                      </div>
-                      <div style={{ fontSize: 11, color: 'var(--text-muted)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
-                        {song.genre ?? '—'}
-                      </div>
-                      <span className="track-duration" style={{ textAlign: 'right' }}>
-                        {Math.floor(song.duration / 60)}:{(song.duration % 60).toString().padStart(2, '0')}
-                      </span>
-                    </div>
-                  );
-                })}
-              </div>
+              )}
             </section>
           )}
         </div>

src/pages/Home.tsx

@@ -1,7 +1,8 @@
 import React, { useEffect, useState } from 'react';
 import Hero from '../components/Hero';
 import AlbumRow from '../components/AlbumRow';
-import { getAlbumList, getArtists, SubsonicAlbum, SubsonicArtist } from '../api/subsonic';
+import SongRail from '../components/SongRail';
+import { getAlbumList, getArtists, getRandomSongs, SubsonicAlbum, SubsonicArtist, SubsonicSong } from '../api/subsonic';
 import { useTranslation } from 'react-i18next';
 import { NavLink, useNavigate } from 'react-router-dom';
 import { ChevronRight } from 'lucide-react';
@@ -13,6 +14,7 @@ import { filterAlbumsByMixRatings, getMixMinRatingsConfigFromAuth } from '../uti
 const HOME_RANDOM_FETCH = 100;
 const HOME_HERO_COUNT = 8;
 const HOME_DISCOVER_SLICE = 20;
+const HOME_DISCOVER_SONGS_SIZE = 18;
 
 export default function Home() {
   const homeSections = useHomeStore(s => s.sections);
@@ -30,6 +32,7 @@ export default function Home() {
   const [mostPlayed, setMostPlayed] = useState<SubsonicAlbum[]>([]);
   const [recentlyPlayed, setRecentlyPlayed] = useState<SubsonicAlbum[]>([]);
   const [randomArtists, setRandomArtists] = useState<SubsonicArtist[]>([]);
+  const [discoverSongs, setDiscoverSongs] = useState<SubsonicSong[]>([]);
   const [loading, setLoading] = useState(true);
 
   useEffect(() => {
@@ -41,13 +44,16 @@ export default function Home() {
         const albumMix =
           mixCfg.enabled && (mixCfg.minAlbum > 0 || mixCfg.minArtist > 0);
         const randomSize = albumMix ? HOME_RANDOM_FETCH : HOME_DISCOVER_SLICE;
-        const [s, n, rRaw, f, rp, artists] = await Promise.all([
+        const [s, n, rRaw, f, rp, artists, songs] = await Promise.all([
           getAlbumList('starred', 12).catch(() => []),
           getAlbumList('newest', 12).catch(() => []),
           getAlbumList('random', randomSize).catch(() => []),
           getAlbumList('frequent', 12).catch(() => []),
           getAlbumList('recent', 12).catch(() => []),
           isVisible('discoverArtists') ? getArtists().catch(() => []) : Promise.resolve<SubsonicArtist[]>([]),
+          isVisible('discoverSongs')
+            ? getRandomSongs(HOME_DISCOVER_SONGS_SIZE).catch(() => [] as SubsonicSong[])
+            : Promise.resolve<SubsonicSong[]>([]),
         ]);
         if (cancelled) return;
         const r = await filterAlbumsByMixRatings(rRaw, mixCfg);
@@ -57,6 +63,7 @@ export default function Home() {
         setRandom(r.slice(HOME_HERO_COUNT, HOME_DISCOVER_SLICE));
         setMostPlayed(f);
         setRecentlyPlayed(rp);
+        setDiscoverSongs(songs);
         const shuffled = [...artists];
         for (let i = shuffled.length - 1; i > 0; i--) {
           const j = Math.floor(Math.random() * (i + 1));
@@ -128,6 +135,12 @@ export default function Home() {
                 moreText={t('home.discoverMore')}
               />
             )}
+            {isVisible('discoverSongs') && discoverSongs.length > 0 && (
+              <SongRail
+                title={t('home.discoverSongs')}
+                songs={discoverSongs}
+              />
+            )}
             {isVisible('discoverArtists') && randomArtists.length > 0 && (
               <section className="album-row-section">
                 <div className="album-row-header">

src/pages/SearchResults.tsx

@@ -1,20 +1,15 @@
-import React, { useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
 import { useSearchParams } from 'react-router-dom';
-import { Play, Search } from 'lucide-react';
-import { search, SearchResults as ISearchResults, SubsonicSong } from '../api/subsonic';
-import { usePlayerStore, songToTrack } from '../store/playerStore';
+import { Search } from 'lucide-react';
+import { search, searchSongsPaged, SearchResults as ISearchResults } from '../api/subsonic';
 import AlbumRow from '../components/AlbumRow';
 import ArtistRow from '../components/ArtistRow';
+import SongRow, { SongListHeader } from '../components/SongRow';
 import { useTranslation } from 'react-i18next';
-import { useDragDrop } from '../contexts/DragDropContext';
 import { useAuthStore } from '../store/authStore';
-import { useOrbitSongRowBehavior } from '../hooks/useOrbitSongRowBehavior';
-import { useThemeStore } from '../store/themeStore';
-import { useShallow } from 'zustand/react/shallow';
 
-function formatDuration(s: number) {
-  return `${Math.floor(s / 60)}:${(s % 60).toString().padStart(2, '0')}`;
-}
+const SONGS_INITIAL = 50;
+const SONGS_PAGE_SIZE = 50;
 
 export default function SearchResults() {
   const { t } = useTranslation();
@@ -22,43 +17,53 @@ export default function SearchResults() {
   const query = params.get('q') ?? '';
   const [results, setResults] = useState<ISearchResults | null>(null);
   const [loading, setLoading] = useState(false);
+  const [songsServerOffset, setSongsServerOffset] = useState(0);
+  const [songsHasMore, setSongsHasMore] = useState(false);
+  const [loadingMoreSongs, setLoadingMoreSongs] = useState(false);
+  const songsSentinelRef = useRef<HTMLDivElement>(null);
   const musicLibraryFilterVersion = useAuthStore(s => s.musicLibraryFilterVersion);
-  const showBitrate = useThemeStore(s => s.showBitrate);
-  const psyDrag = useDragDrop();
-
-  const { playTrack, enqueue, openContextMenu, currentTrack } = usePlayerStore(
-    useShallow(s => ({
-      playTrack: s.playTrack,
-      enqueue: s.enqueue,
-      openContextMenu: s.openContextMenu,
-      currentTrack: s.currentTrack,
-    }))
-  );
-
-  const [contextMenuSongId, setContextMenuSongId] = useState<string | null>(null);
-  const contextMenuOpen = usePlayerStore(s => s.contextMenu.isOpen);
-
-  useEffect(() => {
-    if (!contextMenuOpen) setContextMenuSongId(null);
-  }, [contextMenuOpen]);
 
   useEffect(() => {
+    setSongsServerOffset(0);
+    setSongsHasMore(false);
     if (!query.trim()) { setResults(null); return; }
     setLoading(true);
-    search(query, { artistCount: 20, albumCount: 20, songCount: 50 })
-      .then(r => setResults(r))
+    search(query, { artistCount: 20, albumCount: 20, songCount: SONGS_INITIAL })
+      .then(r => {
+        setResults(r);
+        setSongsServerOffset(r.songs.length);
+        setSongsHasMore(r.songs.length === SONGS_INITIAL);
+      })
       .finally(() => setLoading(false));
   }, [query, musicLibraryFilterVersion]);
 
+  const loadMoreSongs = useCallback(async () => {
+    if (loadingMoreSongs || !songsHasMore || !query.trim()) return;
+    setLoadingMoreSongs(true);
+    try {
+      const page = await searchSongsPaged(query.trim(), SONGS_PAGE_SIZE, songsServerOffset);
+      setResults(prev => prev ? { ...prev, songs: [...prev.songs, ...page] } : prev);
+      setSongsServerOffset(o => o + page.length);
+      if (page.length < SONGS_PAGE_SIZE) setSongsHasMore(false);
+    } catch {
+      setSongsHasMore(false);
+    } finally {
+      setLoadingMoreSongs(false);
+    }
+  }, [loadingMoreSongs, songsHasMore, query, songsServerOffset]);
+
+  useEffect(() => {
+    const el = songsSentinelRef.current;
+    if (!el) return;
+    const obs = new IntersectionObserver(entries => {
+      if (entries[0]?.isIntersecting) loadMoreSongs();
+    }, { rootMargin: '600px' });
+    obs.observe(el);
+    return () => obs.disconnect();
+  }, [loadMoreSongs]);
+
   const hasResults = results && (results.artists.length || results.albums.length || results.songs.length);
 
-  const { orbitActive, addTrackToOrbit } = useOrbitSongRowBehavior();
-
-  const playSong = (song: SubsonicSong, list: SubsonicSong[]) => {
-    if (orbitActive) { addTrackToOrbit(song.id); return; }
-    playTrack(songToTrack(song), list.map(songToTrack));
-  };
-
   return (
     <div className="content-body animate-fade-in" style={{ display: 'flex', flexDirection: 'column', gap: '3rem' }}>
       <div style={{ marginBottom: '-1.5rem' }}>
@@ -87,69 +92,17 @@ export default function SearchResults() {
           )}
 
           {results.songs.length > 0 && (
-            <section className="album-row-section">
-              <div className="album-row-header" style={{ marginBottom: '1rem' }}>
-                <h2 className="section-title" style={{ marginBottom: 0 }}>{t('search.songs')}</h2>
-              </div>
-              <div className="tracklist" style={{ padding: 0 }}>
-                <div className="tracklist-header" style={{ gridTemplateColumns: '60px minmax(150px, 1fr) minmax(80px, 1fr) minmax(80px, 1fr) 100px 65px' }}>
-                  <div />
-                  <div>{t('albumDetail.trackTitle')}</div>
-                  <div>{t('albumDetail.trackArtist')}</div>
-                  <div>{t('search.album')}</div>
-                  <div>{t('albumDetail.trackFormat')}</div>
-                  <div style={{ textAlign: 'right' }}>{t('albumDetail.trackDuration')}</div>
+            <section>
+              <h2 className="section-title" style={{ marginBottom: '0.75rem' }}>{t('search.songs')}</h2>
+              <SongListHeader />
+              {results.songs.map(song => (
+                <SongRow key={song.id} song={song} />
+              ))}
+              {songsHasMore && (
+                <div ref={songsSentinelRef} style={{ display: 'flex', justifyContent: 'center', padding: '1rem' }}>
+                  {loadingMoreSongs && <div className="spinner" style={{ width: 20, height: 20 }} />}
                 </div>
-                {results.songs.map(song => (
-                  <div
-                    key={song.id}
-                    className={`track-row${currentTrack?.id === song.id ? ' active' : ''}${contextMenuSongId === song.id ? ' context-active' : ''}`}
-                    style={{ gridTemplateColumns: '60px minmax(150px, 1fr) minmax(80px, 1fr) minmax(80px, 1fr) 100px 65px' }}
-                    onDoubleClick={() => playSong(song, results.songs)}
-                    onContextMenu={e => {
-                      e.preventDefault();
-                      setContextMenuSongId(song.id);
-                      openContextMenu(e.clientX, e.clientY, songToTrack(song), 'album-song');
-                    }}
-                    role="row"
-                    onMouseDown={e => {
-                      if (e.button !== 0) return;
-                      e.preventDefault();
-                      const sx = e.clientX, sy = e.clientY;
-                      const track = songToTrack(song);
-                      const onMove = (me: MouseEvent) => {
-                        if (Math.abs(me.clientX - sx) > 5 || Math.abs(me.clientY - sy) > 5) {
-                          document.removeEventListener('mousemove', onMove);
-                          document.removeEventListener('mouseup', onUp);
-                          psyDrag.startDrag({ data: JSON.stringify({ type: 'song', track }), label: song.title }, me.clientX, me.clientY);
-                        }
-                      };
-                      const onUp = () => { document.removeEventListener('mousemove', onMove); document.removeEventListener('mouseup', onUp); };
-                      document.addEventListener('mousemove', onMove);
-                      document.addEventListener('mouseup', onUp);
-                    }}
-                  >
-                    <button
-                      className="btn btn-ghost"
-                      style={{ padding: 4 }}
-                      onClick={e => { e.stopPropagation(); playSong(song, results.songs); }}
-                    >
-                      <Play size={14} fill="currentColor" />
-                    </button>
-                    <div className="track-info">
-                      <span className="track-title" title={song.title}>{song.title}</span>
-                    </div>
-                    <div className="track-artist-cell"><span className="track-artist" title={song.artist}>{song.artist}</span></div>
-                    <div className="track-artist-cell"><span className="track-artist" title={song.album}>{song.album}</span></div>
-                    <span className="track-codec" style={{ alignSelf: 'center' }}>
-                      {[song.suffix?.toUpperCase(), showBitrate && song.bitRate ? `${song.bitRate} kbps` : ''].filter(Boolean).join(' · ')}
-                    </span>
-                    <span className="track-duration" style={{ textAlign: 'right' }}>
-                      {formatDuration(song.duration)}
-                    </span>
-                  </div>
-                ))}
-              </div>
+              )}
             </section>
           )}
         </>

src/pages/Settings.tsx

@@ -4220,6 +4220,7 @@ function HomeCustomizer() {
     hero:            t('home.hero'),
     recent:          t('home.recent'),
     discover:        t('home.discover'),
+    discoverSongs:   t('home.discoverSongs'),
     discoverArtists: t('home.discoverArtists'),
     recentlyPlayed:  t('home.recentlyPlayed'),
     starred:         t('home.starred'),

src/pages/Tracks.tsx

@@ -0,0 +1,153 @@
+import React, { useEffect, useState, useCallback, useMemo } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { Play, ListPlus, RefreshCw, Sparkles } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+import {
+  SubsonicSong,
+  getRandomSongs,
+  buildCoverArtUrl,
+  coverArtCacheKey,
+} from '../api/subsonic';
+import { useAuthStore } from '../store/authStore';
+import { usePlayerStore, songToTrack } from '../store/playerStore';
+import CachedImage from '../components/CachedImage';
+import SongRail from '../components/SongRail';
+import VirtualSongList from '../components/VirtualSongList';
+import { playSongNow } from '../utils/playSong';
+
+const RANDOM_RAIL_SIZE = 18;
+
+export default function Tracks() {
+  const { t } = useTranslation();
+  const navigate = useNavigate();
+  const activeServerId = useAuthStore(s => s.activeServerId);
+  const enqueue = usePlayerStore(s => s.enqueue);
+
+  const [hero, setHero] = useState<SubsonicSong | null>(null);
+  const [heroLoading, setHeroLoading] = useState(false);
+
+  const [random, setRandom] = useState<SubsonicSong[]>([]);
+  const [randomLoading, setRandomLoading] = useState(true);
+
+  const rerollHero = useCallback(async () => {
+    setHeroLoading(true);
+    try {
+      const picks = await getRandomSongs(1);
+      if (picks[0]) setHero(picks[0]);
+    } finally {
+      setHeroLoading(false);
+    }
+  }, []);
+
+  const rerollRandom = useCallback(async () => {
+    setRandomLoading(true);
+    try {
+      const r = await getRandomSongs(RANDOM_RAIL_SIZE);
+      setRandom(r);
+    } finally {
+      setRandomLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (!activeServerId) return;
+    rerollHero();
+    rerollRandom();
+  }, [activeServerId, rerollHero, rerollRandom]);
+
+  const heroCoverUrl = hero?.coverArt ? buildCoverArtUrl(hero.coverArt, 600) : '';
+
+  // Hide the hero song from the random rail if the server happens to return it in
+  // both fetches (Navidrome's getRandomSongs sometimes overlaps within a short window).
+  const railSongs = useMemo(
+    () => (hero ? random.filter(s => s.id !== hero.id) : random),
+    [random, hero],
+  );
+
+  return (
+    <div className="content-body animate-fade-in tracks-page">
+      <header className="tracks-header">
+        <div className="tracks-header-text">
+          <h1 className="page-title">{t('tracks.title')}</h1>
+          <p className="tracks-subtitle">{t('tracks.subtitle')}</p>
+        </div>
+      </header>
+
+      {hero && (
+        <section className="tracks-hero">
+          <div className="tracks-hero-cover">
+            {heroCoverUrl ? (
+              <CachedImage
+                src={heroCoverUrl}
+                cacheKey={coverArtCacheKey(hero.coverArt!, 600)}
+                alt=""
+              />
+            ) : (
+              <div className="tracks-hero-cover-placeholder" />
+            )}
+          </div>
+          <div className="tracks-hero-content">
+            <span className="tracks-hero-eyebrow">
+              <Sparkles size={14} />
+              {t('tracks.heroEyebrow')}
+            </span>
+            <h2 className="tracks-hero-title" title={hero.title}>{hero.title}</h2>
+            <p className="tracks-hero-meta">
+              <span
+                className={hero.artistId ? 'track-artist-link' : ''}
+                style={{ cursor: hero.artistId ? 'pointer' : 'default' }}
+                onClick={() => hero.artistId && navigate(`/artist/${hero.artistId}`)}
+              >{hero.artist}</span>
+              {hero.album && (
+                <>
+                  <span className="tracks-hero-meta-dot">·</span>
+                  <span
+                    className={hero.albumId ? 'track-artist-link' : ''}
+                    style={{ cursor: hero.albumId ? 'pointer' : 'default' }}
+                    onClick={() => hero.albumId && navigate(`/album/${hero.albumId}`)}
+                  >{hero.album}</span>
+                </>
+              )}
+            </p>
+            <div className="tracks-hero-actions">
+              <button
+                className="btn btn-primary"
+                onClick={() => playSongNow(hero)}
+              >
+                <Play size={16} fill="currentColor" /> {t('tracks.playSong')}
+              </button>
+              <button
+                className="btn"
+                onClick={() => enqueue([songToTrack(hero)])}
+              >
+                <ListPlus size={16} /> {t('tracks.enqueueSong')}
+              </button>
+              <button
+                className="btn btn-ghost"
+                onClick={rerollHero}
+                disabled={heroLoading}
+                aria-label={t('tracks.heroReroll')}
+                data-tooltip={t('tracks.heroReroll')}
+                data-tooltip-pos="top"
+              >
+                <RefreshCw size={16} className={heroLoading ? 'is-spinning' : ''} />
+              </button>
+            </div>
+          </div>
+        </section>
+      )}
+
+      <SongRail
+        title={t('tracks.railRandom')}
+        songs={railSongs}
+        loading={randomLoading}
+        onReroll={rerollRandom}
+      />
+
+      <VirtualSongList
+        title={t('tracks.browseTitle')}
+        emptyBrowseText={t('tracks.browseUnsupported')}
+      />
+    </div>
+  );
+}