.gitea/workflows/build-and-test.yml

@@ -60,24 +60,16 @@ jobs:
           cargo test
           cd ..
 
-  # Fast per-commit Android compile check. This does NOT build a shippable APK:
+  build:
-  # the full signed release APK is built only on tag pushes by build-release.yml
+    name: Build Android APK
-  # (which runs sync-android-sources.sh + signing). Running the full bundle here
-  # too would duplicate a ~15min build and, without the sync step, produced an
-  # unsigned APK missing our custom sources/icons/proguard rules anyway.
-  # `cargo check` for the Android target (~1min) catches Android-specific Rust
-  # breakage without linking, bundling, or signing.
-  android-check:
-    name: Android Compile Check
     runs-on: linux/amd64
     needs: test
     container:
       image: gitea.tourolle.paris/dtourolle/jellytau-builder:latest
     env:
       ANDROID_HOME: /opt/android-sdk
-      ANDROID_SDK_ROOT: /opt/android-sdk
+      NDK_VERSION: 27.0.11902837
       NDK_HOME: /opt/android-sdk/ndk/27.0.11902837
-      ANDROID_NDK_HOME: /opt/android-sdk/ndk/27.0.11902837
 
     steps:
       - name: Checkout repository
@@ -105,13 +97,42 @@ jobs:
             ${{ runner.os }}-bun-
 
       - name: Install dependencies
-        run: bun install
-
-      - name: Cargo check (aarch64-linux-android)
         run: |
-          TC="$NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin"
+          bun install
-          export CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER="$TC/aarch64-linux-android24-clang"
+
-          export CC_aarch64_linux_android="$TC/aarch64-linux-android24-clang"
+      - name: Build frontend
-          export AR_aarch64_linux_android="$TC/llvm-ar"
+        run: bun run build
+
+      - name: Ensure Android NDK
+        run: |
+          if [ ! -d "$NDK_HOME" ]; then
+            echo "NDK not found at $NDK_HOME, installing ndk;$NDK_VERSION"
+            yes | "$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager" --sdk_root="$ANDROID_HOME" "ndk;$NDK_VERSION"
+          fi
+          echo "Using NDK at $NDK_HOME"
+          ls "$NDK_HOME"
+
+      - name: Initialize Android project
+        run: |
           cd src-tauri
-          cargo check --target aarch64-linux-android --lib
+          echo "" | bunx tauri android init
+          cd ..
+
+      - name: Build Android APK
+        id: build
+        run: |
+          mkdir -p artifacts
+          bun run tauri android build --apk true --target aarch64
+
+          # Find the generated APK file
+          ARTIFACT=$(find src-tauri/gen/android/app/build/outputs/apk -name "*.apk" -type f -print -quit)
+          echo "artifact=${ARTIFACT}" >> $GITHUB_OUTPUT
+          echo "Found artifact: ${ARTIFACT}"
+
+      - name: Upload build artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: jellytau-apk
+          path: ${{ steps.build.outputs.artifact }}
+          retention-days: 30
+          if-no-files-found: error

scripts/build-android.sh

@@ -44,9 +44,6 @@ bun run build
 
 # Step 2: Build Android APK
 if [ "$BUILD_TYPE" = "release" ]; then
-    # Configure release signing from .env (single source of truth). Must run
-    # after sync-android-sources.sh, since gen/android is (re)generated there.
-    ./scripts/write-keystore-properties.sh
     echo "📦 Building release APK..."
     bun run tauri android build --apk true
 else

scripts/sync-android-sources.sh

@@ -65,25 +65,6 @@ if [ -d "$RES_SRC" ]; then
         cp "$dir"/* "$RES_DST/$name/"
         echo "  Copied res: $name"
     done
-    # We ship only the color adaptive icon (background + foreground). Drop any
-    # monochrome layer Tauri may generate: the themed-icon monochrome doesn't
-    # render well, and our adaptive-icon xml no longer references it, so a stray
-    # ic_launcher_monochrome.png would just be dead weight.
-    rm -f "$RES_DST"/mipmap-*/ic_launcher_monochrome.png
-
-    # `tauri android init` also emits the Android Studio DEFAULT adaptive icon
-    # as API-qualified VECTOR drawables:
-    #   drawable/ic_launcher_background.xml      (solid #3DDC84 green)
-    #   drawable-v24/ic_launcher_foreground.xml  (the Android robot)
-    # Because drawable-v24 is a more specific match than our unqualified
-    # mipmap-*/ic_launcher_*.png, on API 24+ the vector WINS and the app ships
-    # the green square robot instead of our jellyfish. Remove them so the
-    # adaptive-icon xml resolves @mipmap/ic_launcher_{background,foreground}
-    # to the real committed PNGs.
-    rm -f "$RES_DST"/drawable/ic_launcher_background.xml \
-          "$RES_DST"/drawable-v24/ic_launcher_foreground.xml \
-          "$RES_DST"/drawable*/ic_launcher_foreground.xml \
-          "$RES_DST"/drawable*/ic_launcher_background.xml
 fi
 
 echo "✓ Android sources synced successfully"

scripts/write-keystore-properties.sh

@@ -1,52 +0,0 @@
-#!/bin/bash
-# Regenerate src-tauri/gen/android/keystore.properties from the gitignored .env.
-#
-# .env is the single source of truth for local release signing. `tauri android
-# init` wipes/regenerates gen/android, so keystore.properties must be rewritten
-# from .env before every release build (this is the local mirror of what the CI
-# workflow does from Gitea secrets).
-#
-# Required .env vars:
-#   ANDROID_KEY_ALIAS, ANDROID_KEYSTORE_PASSWORD, ANDROID_KEY_PASSWORD,
-#   ANDROID_KEYSTORE_FILE (absolute path to the .jks)
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
-ENV_FILE="$PROJECT_ROOT/.env"
-PROPS="$PROJECT_ROOT/src-tauri/gen/android/keystore.properties"
-
-if [ ! -f "$ENV_FILE" ]; then
-    echo "❌ $ENV_FILE not found — cannot configure release signing." >&2
-    echo "   Create it with ANDROID_KEY_ALIAS / ANDROID_KEYSTORE_PASSWORD /" >&2
-    echo "   ANDROID_KEY_PASSWORD / ANDROID_KEYSTORE_FILE." >&2
-    exit 1
-fi
-
-# Load .env without leaking it into the caller's environment beyond what we need.
-set -a
-# shellcheck disable=SC1090
-. "$ENV_FILE"
-set +a
-
-: "${ANDROID_KEY_ALIAS:?ANDROID_KEY_ALIAS missing from .env}"
-: "${ANDROID_KEYSTORE_PASSWORD:?ANDROID_KEYSTORE_PASSWORD missing from .env}"
-: "${ANDROID_KEY_PASSWORD:?ANDROID_KEY_PASSWORD missing from .env}"
-: "${ANDROID_KEYSTORE_FILE:?ANDROID_KEYSTORE_FILE missing from .env}"
-
-if [ ! -f "$ANDROID_KEYSTORE_FILE" ]; then
-    echo "❌ Keystore not found at ANDROID_KEYSTORE_FILE=$ANDROID_KEYSTORE_FILE" >&2
-    exit 1
-fi
-
-mkdir -p "$(dirname "$PROPS")"
-umask 077
-cat > "$PROPS" <<EOF
-storeFile=$ANDROID_KEYSTORE_FILE
-storePassword=$ANDROID_KEYSTORE_PASSWORD
-keyAlias=$ANDROID_KEY_ALIAS
-keyPassword=$ANDROID_KEY_PASSWORD
-EOF
-
-echo "🔐 Wrote release signing config to keystore.properties (from .env)"

src-tauri/android/src/main/java/com/dtourolle/jellytau/player/JellyTauPlaybackService.kt

@@ -295,14 +295,6 @@ class JellyTauPlaybackService : MediaSessionService() {
         // Update MediaSession playback state
         session.setPlaybackState(buildPlaybackState(isPlaying, position))
 
-        // While casting, re-assert the remote volume provider. Metadata pushes
-        // arrive on the session poller thread and can race with (or arrive
-        // before) enableRemoteVolume(); this keeps the session routed to the
-        // remote (absolute) volume slider instead of the local media stream.
-        if (isRemoteVolumeEnabled) {
-            volumeProvider?.let { session.setPlaybackToRemote(it) }
-        }
-
         // Update the notification
         updateNotification(title, artist, isPlaying)
     }
@@ -334,17 +326,8 @@ class JellyTauPlaybackService : MediaSessionService() {
      *
      * The reported playback speed is 1.0 while playing and 0.0 while paused so
      * Android does not extrapolate the position past a paused track.
-     *
-     * While remote volume control is enabled (casting), the state is forced to
-     * STATE_PLAYING regardless of [isPlaying]. Android only surfaces the remote
-     * (absolute) volume slider for a session that is actively playing; if a
-     * periodic metadata/position push reports paused (e.g. before the remote
-     * session has actually started), reporting STATE_PAUSED here makes the
-     * system tear down the remote slider set up by setPlaybackToRemote() and
-     * fall back to the local media-stream volume.
      */
     private fun buildPlaybackState(isPlaying: Boolean, position: Long): PlaybackStateCompat {
-        val playing = isPlaying || isRemoteVolumeEnabled
         return PlaybackStateCompat.Builder()
             .setActions(
                 PlaybackStateCompat.ACTION_PLAY or
@@ -355,9 +338,9 @@ class JellyTauPlaybackService : MediaSessionService() {
                 PlaybackStateCompat.ACTION_SEEK_TO
             )
             .setState(
-                if (playing) PlaybackStateCompat.STATE_PLAYING else PlaybackStateCompat.STATE_PAUSED,
+                if (isPlaying) PlaybackStateCompat.STATE_PLAYING else PlaybackStateCompat.STATE_PAUSED,
                 position,
-                if (playing) 1.0f else 0.0f
+                if (isPlaying) 1.0f else 0.0f
             )
             .build()
     }

src-tauri/android/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -2,4 +2,5 @@
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
   <background android:drawable="@mipmap/ic_launcher_background"/>
   <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+  <monochrome android:drawable="@mipmap/ic_launcher_monochrome"/>
 </adaptive-icon>

src-tauri/src/auth/mod.rs

@@ -133,7 +133,7 @@ impl AuthManager {
 
         log::info!("[AuthManager] Connecting to server: {}", normalized_url);
 
-        match self.http_client.get_json_fast::<PublicSystemInfo>(&endpoint).await {
+        match self.http_client.get_json_with_retry::<PublicSystemInfo>(&endpoint).await {
             Ok(info) => {
                 log::info!("[AuthManager] Connected to server: {} ({})", info.server_name, info.version);
 

src-tauri/src/commands/catalog.rs

@@ -1,455 +0,0 @@
-//! Tauri commands for the offline "browse & queue" feature.
-//!
-//! Two backend pieces support browsing the full server catalog while offline
-//! and queueing downloads that fire on reconnect:
-//!
-//! - [`sync_full_catalog`] walks every library while online and persists all
-//!   items to the offline cache so the whole catalog is browsable (greyed out)
-//!   offline. It reuses [`HybridRepository::cache_items_from_server`], which in
-//!   turn reuses `OfflineRepository::save_to_cache` (sets `synced_at`, which is
-//!   what `get_items` branch 3 serves offline).
-//! - [`resume_queued_downloads`] resolves and pumps the `pending` download rows
-//!   that were queued offline (they have `stream_url IS NULL`), mirroring the
-//!   heal-and-pump pattern in `player_preload_upcoming`.
-
-use std::sync::Arc;
-
-use log::{info, warn};
-use tauri::State;
-
-use crate::commands::repository::RepositoryManagerWrapper;
-use crate::commands::download::{pump_download_queue, DownloadManagerWrapper};
-use crate::commands::storage::DatabaseWrapper;
-use crate::repository::types::GetItemsOptions;
-use crate::storage::db_service::{DatabaseService, Query, QueryParam};
-
-/// app_settings key holding the RFC-3339 timestamp of the last successful
-/// full-catalog sync.
-const LAST_CATALOG_SYNC_KEY: &str = "last_catalog_sync";
-
-/// Item types worth caching for offline browsing: containers the library
-/// landing pages render plus the playable leaves users queue for download.
-const CATALOG_ITEM_TYPES: &[&str] = &[
-    "MusicAlbum",
-    "Movie",
-    "Series",
-    "Season",
-    "Episode",
-    "Audio",
-    "BoxSet",
-];
-
-#[derive(specta::Type, Debug, Clone, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CatalogSyncResult {
-    /// Total items persisted to the offline cache across all libraries.
-    pub items_cached: usize,
-    /// Libraries that failed to sync (e.g. server hiccup); best-effort.
-    pub libraries_failed: usize,
-}
-
-#[derive(specta::Type, Debug, Clone, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CatalogSyncStatus {
-    /// RFC-3339 timestamp of the last successful sync, if any.
-    pub last_synced_at: Option<String>,
-}
-
-/// Walk every library on the server and persist all items to the offline cache
-/// so the full catalog is browsable offline (greyed out when not downloaded).
-///
-/// Best-effort: a library that fails to fetch is counted and skipped rather than
-/// aborting the whole sync. Runs libraries sequentially to avoid hammering the
-/// server. Uses `Recursive=true` so a single request per library returns the
-/// containers and their playable children.
-#[tauri::command]
-#[specta::specta]
-pub async fn sync_full_catalog(
-    repository: State<'_, RepositoryManagerWrapper>,
-    db: State<'_, DatabaseWrapper>,
-    handle: String,
-) -> Result<CatalogSyncResult, String> {
-    use crate::repository::MediaRepository;
-
-    let repo = repository.0.get(&handle).ok_or("Repository not found")?;
-
-    let db_service = {
-        let database = db.0.lock().map_err(|e| e.to_string())?;
-        Arc::new(database.service())
-    };
-
-    let libraries = repo.get_libraries().await.map_err(|e| e.to_string())?;
-    info!("[Catalog] Full sync starting across {} libraries", libraries.len());
-
-    let include_types: Vec<String> = CATALOG_ITEM_TYPES.iter().map(|s| s.to_string()).collect();
-
-    let mut items_cached = 0usize;
-    let mut libraries_failed = 0usize;
-
-    for library in &libraries {
-        let opts = GetItemsOptions {
-            recursive: Some(true),
-            include_item_types: Some(include_types.clone()),
-            limit: Some(100_000),
-            ..Default::default()
-        };
-
-        match repo.cache_items_from_server(&library.id, Some(opts)).await {
-            Ok(items) => {
-                info!(
-                    "[Catalog] Cached {} items from library '{}'",
-                    items.len(),
-                    library.name
-                );
-                items_cached += items.len();
-            }
-            Err(e) => {
-                warn!("[Catalog] Failed to sync library '{}': {:?}", library.name, e);
-                libraries_failed += 1;
-            }
-        }
-    }
-
-    // Record the sync time so callers can skip re-syncing too eagerly.
-    let now = chrono::Utc::now().to_rfc3339();
-    let upsert = Query::with_params(
-        "INSERT INTO app_settings (key, value, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)
-         ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = CURRENT_TIMESTAMP",
-        vec![
-            QueryParam::String(LAST_CATALOG_SYNC_KEY.to_string()),
-            QueryParam::String(now),
-        ],
-    );
-    if let Err(e) = db_service.execute(upsert).await {
-        warn!("[Catalog] Failed to persist last-sync timestamp: {}", e);
-    }
-
-    info!(
-        "[Catalog] Full sync complete: {} items cached, {} libraries failed",
-        items_cached, libraries_failed
-    );
-
-    Ok(CatalogSyncResult {
-        items_cached,
-        libraries_failed,
-    })
-}
-
-/// Report the last-synced timestamp so the UI can show a hint / decide whether
-/// to trigger a fresh sync.
-#[tauri::command]
-#[specta::specta]
-pub async fn catalog_sync_status(
-    db: State<'_, DatabaseWrapper>,
-) -> Result<CatalogSyncStatus, String> {
-    let db_service = {
-        let database = db.0.lock().map_err(|e| e.to_string())?;
-        Arc::new(database.service())
-    };
-
-    let query = Query::with_params(
-        "SELECT value FROM app_settings WHERE key = ?",
-        vec![QueryParam::String(LAST_CATALOG_SYNC_KEY.to_string())],
-    );
-    let last_synced_at: Option<String> = db_service
-        .query_optional(query, |row| row.get(0))
-        .await
-        .map_err(|e| e.to_string())?;
-
-    Ok(CatalogSyncStatus { last_synced_at })
-}
-
-#[derive(specta::Type, Debug, Clone, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ResumeQueuedResult {
-    /// Rows whose stream URL was resolved and are now pump-eligible.
-    pub resolved: usize,
-    /// Rows that couldn't be resolved (item metadata / URL lookup failed).
-    pub failed: usize,
-}
-
-/// Core of [`resume_queued_downloads`], factored out for testing: select every
-/// `pending`/`stream_url IS NULL` row, resolve each via `resolve` (returning
-/// `None` leaves the row pending), and heal the row so the pump can start it.
-/// The `resolve` closure receives `(item_id, media_type, quality_preset)`.
-pub(crate) async fn resolve_pending_download_urls<F, Fut>(
-    db_service: &Arc<crate::storage::db_service::RusqliteService>,
-    target_dir: &str,
-    resolve: F,
-) -> Result<ResumeQueuedResult, String>
-where
-    F: Fn(String, String, String) -> Fut,
-    Fut: std::future::Future<Output = Option<String>>,
-{
-    let rows_query = Query::new(
-        "SELECT id, item_id, COALESCE(media_type, 'audio'), COALESCE(quality_preset, 'original')
-         FROM downloads
-         WHERE status = 'pending' AND stream_url IS NULL",
-    );
-    let rows: Vec<(i64, String, String, String)> = db_service
-        .query_many(rows_query, |row| {
-            Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?))
-        })
-        .await
-        .map_err(|e| e.to_string())?;
-
-    if rows.is_empty() {
-        return Ok(ResumeQueuedResult { resolved: 0, failed: 0 });
-    }
-
-    info!("[Catalog] Resolving {} offline-queued downloads on reconnect", rows.len());
-
-    let mut resolved = 0usize;
-    let mut failed = 0usize;
-
-    for (download_id, item_id, media_type, quality) in rows {
-        let stream_url = match resolve(item_id.clone(), media_type, quality).await {
-            Some(url) => url,
-            None => {
-                failed += 1;
-                continue;
-            }
-        };
-
-        // Heal the row so the pump can start it. Guard on stream_url IS NULL so a
-        // concurrent resolver doesn't clobber an already-started row.
-        let update = Query::with_params(
-            "UPDATE downloads SET stream_url = ?, target_dir = ?
-             WHERE id = ? AND status = 'pending' AND stream_url IS NULL",
-            vec![
-                QueryParam::String(stream_url),
-                QueryParam::String(target_dir.to_string()),
-                QueryParam::Int64(download_id),
-            ],
-        );
-        match db_service.execute(update).await {
-            Ok(n) if n > 0 => resolved += 1,
-            Ok(_) => {} // already resolved by someone else; not a failure
-            Err(e) => {
-                warn!("[Catalog] Failed to persist URL for download {}: {}", download_id, e);
-                failed += 1;
-            }
-        }
-    }
-
-    Ok(ResumeQueuedResult { resolved, failed })
-}
-
-/// Resolve the stream URL for every download row that was queued while offline
-/// (`status = 'pending' AND stream_url IS NULL`), then pump the queue so they
-/// start. Call this on reconnect.
-///
-/// Audio rows resolve via `get_audio_stream_url`; video rows (media_type =
-/// 'video') via the pure `get_video_download_url` builder using the row's stored
-/// `quality_preset` — mirroring `enqueue_video_downloads`. Rows whose URL can't
-/// be resolved are left pending (they retry on the next reconnect).
-#[tauri::command]
-#[specta::specta]
-pub async fn resume_queued_downloads(
-    repository: State<'_, RepositoryManagerWrapper>,
-    db: State<'_, DatabaseWrapper>,
-    download_manager: State<'_, DownloadManagerWrapper>,
-    app: tauri::AppHandle,
-    handle: String,
-) -> Result<ResumeQueuedResult, String> {
-    use crate::repository::MediaRepository;
-
-    use crate::repository::HybridRepository;
-
-    let repo = repository.0.get(&handle).ok_or("Repository not found")?;
-
-    // The pump needs a target_dir; use the same storage root the other download
-    // paths use (the database's parent directory — see `storage_get_path`).
-    let (db_service, target_dir) = {
-        let database = db.0.lock().map_err(|e| e.to_string())?;
-        let target_dir = database
-            .path()
-            .parent()
-            .ok_or_else(|| "Database path has no parent directory".to_string())?
-            .to_string_lossy()
-            .to_string();
-        (Arc::new(database.service()), target_dir)
-    };
-
-    // Recover stale downloads: rows left in 'downloading' when the app was killed
-    // mid-transfer are orphaned — nothing ever restarts them, so they show as
-    // permanently "downloading". Reset them to 'pending' and clear the stale
-    // stream_url so they get re-resolved and restarted from scratch below.
-    let recover_query = Query::new(
-        "UPDATE downloads SET status = 'pending', stream_url = NULL, progress = 0, \
-         bytes_downloaded = 0, started_at = NULL \
-         WHERE status = 'downloading'",
-    );
-    match db_service.execute(recover_query).await {
-        Ok(n) if n > 0 => info!("[Catalog] Reset {} stale 'downloading' rows to pending", n),
-        Ok(_) => {}
-        Err(e) => warn!("[Catalog] Failed to reset stale downloads: {}", e),
-    }
-
-    // Resolve each row's URL against the (now reachable) repository.
-    let repo_for_resolve = Arc::clone(&repo);
-    let outcome = resolve_pending_download_urls(
-        &db_service,
-        &target_dir,
-        move |item_id: String, media_type: String, quality: String| {
-            let repo = Arc::clone(&repo_for_resolve);
-            async move {
-                if media_type == "video" {
-                    Some(<HybridRepository as MediaRepository>::get_video_download_url(
-                        repo.as_ref(),
-                        &item_id,
-                        &quality,
-                        None,
-                    ))
-                } else {
-                    match repo.get_audio_stream_url(&item_id).await {
-                        Ok(url) => Some(url),
-                        Err(e) => {
-                            warn!("[Catalog] Failed to resolve audio URL for {}: {:?}", item_id, e);
-                            None
-                        }
-                    }
-                }
-            }
-        },
-    )
-    .await
-    .map_err(|e| e.to_string())?;
-
-    let ResumeQueuedResult { resolved, failed } = outcome;
-
-    // Kick the pump so the newly-resolved rows actually start.
-    if resolved > 0 {
-        let active_downloads = {
-            let manager = download_manager.0.lock().map_err(|e| e.to_string())?;
-            manager.get_active_downloads()
-        };
-        pump_download_queue(app, db_service, active_downloads).await;
-    }
-
-    info!("[Catalog] Resume complete: {} resolved, {} failed", resolved, failed);
-
-    Ok(ResumeQueuedResult { resolved, failed })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::storage::db_service::RusqliteService;
-    use rusqlite::Connection;
-    use std::sync::Mutex;
-
-    fn test_db() -> Arc<RusqliteService> {
-        let conn = Connection::open_in_memory().unwrap();
-        conn.execute_batch(
-            r#"
-            CREATE TABLE downloads (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                item_id TEXT NOT NULL,
-                status TEXT NOT NULL,
-                stream_url TEXT,
-                target_dir TEXT,
-                media_type TEXT,
-                quality_preset TEXT
-            );
-            "#,
-        )
-        .unwrap();
-        Arc::new(RusqliteService::new(Arc::new(Mutex::new(conn))))
-    }
-
-    async fn insert_download(
-        db: &Arc<RusqliteService>,
-        item_id: &str,
-        status: &str,
-        stream_url: Option<&str>,
-        media_type: Option<&str>,
-    ) {
-        let q = Query::with_params(
-            "INSERT INTO downloads (item_id, status, stream_url, media_type) VALUES (?, ?, ?, ?)",
-            vec![
-                QueryParam::String(item_id.to_string()),
-                QueryParam::String(status.to_string()),
-                stream_url.map(|s| QueryParam::String(s.to_string())).unwrap_or(QueryParam::Null),
-                media_type.map(|s| QueryParam::String(s.to_string())).unwrap_or(QueryParam::Null),
-            ],
-        );
-        db.execute(q).await.unwrap();
-    }
-
-    async fn get_row(db: &Arc<RusqliteService>, item_id: &str) -> (String, Option<String>, Option<String>) {
-        let q = Query::with_params(
-            "SELECT status, stream_url, target_dir FROM downloads WHERE item_id = ?",
-            vec![QueryParam::String(item_id.to_string())],
-        );
-        db.query_one(q, |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)))
-            .await
-            .unwrap()
-    }
-
-    #[tokio::test]
-    async fn resolves_offline_queued_row_and_leaves_resolved_rows_untouched() {
-        let db = test_db();
-        // A row queued offline: pending with no URL yet.
-        insert_download(&db, "queued-1", "pending", None, None).await;
-        // An already-resolved pending row: must NOT be touched.
-        insert_download(&db, "already", "pending", Some("http://existing/url"), None).await;
-        // A completed row: irrelevant.
-        insert_download(&db, "done", "completed", Some("http://done/url"), None).await;
-
-        let out = resolve_pending_download_urls(&db, "/data/downloads", |item_id, _mt, _q| async move {
-            Some(format!("http://resolved/{item_id}"))
-        })
-        .await
-        .unwrap();
-
-        assert_eq!(out.resolved, 1);
-        assert_eq!(out.failed, 0);
-
-        // The offline-queued row now has a URL + target dir and stays pending.
-        let (status, url, target) = get_row(&db, "queued-1").await;
-        assert_eq!(status, "pending");
-        assert_eq!(url.as_deref(), Some("http://resolved/queued-1"));
-        assert_eq!(target.as_deref(), Some("/data/downloads"));
-
-        // The already-resolved row is unchanged (not re-resolved).
-        let (_s, url2, _t) = get_row(&db, "already").await;
-        assert_eq!(url2.as_deref(), Some("http://existing/url"));
-    }
-
-    #[tokio::test]
-    async fn counts_unresolvable_rows_as_failed_and_leaves_them_pending() {
-        let db = test_db();
-        insert_download(&db, "bad", "pending", None, None).await;
-
-        // Resolver returns None (e.g. server lookup failed).
-        let out = resolve_pending_download_urls(&db, "/data", |_id, _mt, _q| async move { None })
-            .await
-            .unwrap();
-
-        assert_eq!(out.resolved, 0);
-        assert_eq!(out.failed, 1);
-
-        // Still pending with no URL, so a later reconnect can retry it.
-        let (status, url, _t) = get_row(&db, "bad").await;
-        assert_eq!(status, "pending");
-        assert_eq!(url, None);
-    }
-
-    #[tokio::test]
-    async fn video_rows_use_media_type_in_resolver() {
-        let db = test_db();
-        insert_download(&db, "vid-1", "pending", None, Some("video")).await;
-
-        let out = resolve_pending_download_urls(&db, "/data", |item_id, media_type, _q| async move {
-            assert_eq!(media_type, "video");
-            Some(format!("http://transcode/{item_id}"))
-        })
-        .await
-        .unwrap();
-
-        assert_eq!(out.resolved, 1);
-        let (_s, url, _t) = get_row(&db, "vid-1").await;
-        assert_eq!(url.as_deref(), Some("http://transcode/vid-1"));
-    }
-}

src-tauri/src/commands/download/mod.rs

@@ -1268,50 +1268,13 @@ fn spawn_download_worker(
             debug!("   Unregistered download {}. Active downloads: {}", download_id, active.len());
         }
 
-        // The pump runs downloads in the background, so the terminal status MUST
-        // be persisted to the DB here — the frontend event handler only writes it
-        // when that download happens to be loaded in its store, which is not the
-        // case for auto-pumped rows (or any completion while the downloads page is
-        // closed). `check_for_local_download` filters on status = 'completed', so a
-        // missed write leaves finished files unrecognized: albums never show as
-        // downloaded and playback never switches from the (expiring) stream to the
-        // local file, cutting tracks off mid-play.
-        let db_service = {
-            let db = app.state::<DatabaseWrapper>();
-            let database = match db.0.lock() {
-                Ok(d) => d,
-                Err(e) => {
-                    error!("[pump] Failed to lock database after download {}: {}", download_id, e);
-                    return;
-                }
-            };
-            Arc::new(database.service())
-        };
-
         match result {
             Ok(res) => {
                 info!("Download completed successfully: {} bytes", res.bytes_downloaded);
-                let file_path = target_path.to_string_lossy().to_string();
-
-                let update = Query::with_params(
-                    "UPDATE downloads SET status = 'completed', progress = 1.0, \
-                     bytes_downloaded = ?, file_size = ?, file_path = ?, \
-                     completed_at = CURRENT_TIMESTAMP WHERE id = ?",
-                    vec![
-                        QueryParam::Int64(res.bytes_downloaded as i64),
-                        QueryParam::Int64(res.bytes_downloaded as i64),
-                        QueryParam::String(file_path.clone()),
-                        QueryParam::Int64(download_id),
-                    ],
-                );
-                if let Err(e) = db_service.execute(update).await {
-                    error!("[pump] Failed to persist completed status for download {}: {}", download_id, e);
-                }
-
                 let completed_event = DownloadEvent::Completed {
                     download_id,
                     item_id,
-                    file_path,
+                    file_path: target_path.to_string_lossy().to_string(),
                 };
                 match app.emit("download-event", completed_event) {
                     Ok(_) => debug!("   Completed event emitted successfully"),
@@ -1320,18 +1283,6 @@ fn spawn_download_worker(
             }
             Err(e) => {
                 error!("Download failed: {:?}", e);
-
-                let update = Query::with_params(
-                    "UPDATE downloads SET status = 'failed', error_message = ? WHERE id = ?",
-                    vec![
-                        QueryParam::String(e.to_string()),
-                        QueryParam::Int64(download_id),
-                    ],
-                );
-                if let Err(db_err) = db_service.execute(update).await {
-                    error!("[pump] Failed to persist failed status for download {}: {}", download_id, db_err);
-                }
-
                 let failed_event = DownloadEvent::Failed {
                     download_id,
                     item_id,
@@ -1345,6 +1296,17 @@ fn spawn_download_worker(
         }
 
         // A slot just freed — start the next pending download (if any).
+        let db_service = {
+            let db = app.state::<DatabaseWrapper>();
+            let database = match db.0.lock() {
+                Ok(d) => d,
+                Err(e) => {
+                    error!("[pump] Failed to lock database after download {}: {}", download_id, e);
+                    return;
+                }
+            };
+            Arc::new(database.service())
+        };
         pump_download_queue(app.clone(), db_service, active_downloads).await;
     });
 }

src-tauri/src/commands/mod.rs

@@ -2,7 +2,6 @@
 // TRACES: UR-002, UR-003, UR-004, UR-005, UR-009, UR-011, UR-012, UR-017, UR-019, UR-025 |
 //         DR-015, DR-017, DR-021, DR-028
 pub mod auth;
-pub mod catalog;
 pub mod connectivity;
 pub mod conversions;
 pub mod device;
@@ -18,7 +17,6 @@ pub mod storage;
 pub mod sync;
 
 pub use auth::*;
-pub use catalog::*;
 pub use connectivity::*;
 pub use conversions::*;
 pub use device::*;

src-tauri/src/commands/player/mod.rs

@@ -1422,14 +1422,13 @@ pub async fn player_play_album_track(
         info!("  [{}] {} (ID: {})", idx, track.name, track.id);
     }
 
-    // Validate the requested track exists in the album (its position in the
+    // Find the index of the requested track
-    // final queue is computed after building, since offline tracks are skipped).
     info!("Looking for track_id: {}", request.track_id);
-    let album_index = tracks.iter()
+    let start_index = tracks.iter()
         .position(|t| t.id == request.track_id)
         .ok_or_else(|| format!("Track {} not found in album", request.track_id))?;
 
-    info!("Track {} is at index {} in album", request.track_id, album_index);
+    info!("Track {} is at index {} in album", request.track_id, start_index);
 
     // Convert tracks to MediaItems
     let mut media_items = Vec::new();
@@ -1444,21 +1443,13 @@ pub async fn player_play_album_track(
                 jellyfin_item_id: Some(jellyfin_id.clone()),
             }
         } else {
-            // Non-downloaded track: needs a stream URL from the server. When the
+            // Get stream URL from repository (works online/offline)
-            // server is unreachable (offline), skip this track rather than failing
+            let stream_url = repository.get_audio_stream_url(&track.id).await
-            // the whole album — downloaded tracks must still be playable.
+                .map_err(|e| format!("Failed to get stream URL for {}: {}", track.name, e))?;
-            match repository.get_audio_stream_url(&track.id).await {
+
-                Ok(stream_url) => MediaSource::Remote {
+            MediaSource::Remote {
-                    stream_url,
+                stream_url,
-                    jellyfin_item_id: jellyfin_id.clone(),
+                jellyfin_item_id: jellyfin_id.clone(),
-                },
-                Err(e) => {
-                    warn!(
-                        "[Player] Skipping track {} ({}) — no local download and stream URL unavailable: {}",
-                        track.name, track.id, e
-                    );
-                    continue;
-                }
             }
         };
 
@@ -1498,18 +1489,6 @@ pub async fn player_play_album_track(
         media_items.push(media_item);
     }
 
-    if media_items.is_empty() {
-        return Err("No playable tracks available (offline and nothing downloaded)".to_string());
-    }
-
-    // Tracks with no local download and no reachable server were skipped above,
-    // so positions shifted. Re-locate the requested track in the built queue.
-    // If the tapped track itself was skipped, fall back to the first item.
-    let start_index = media_items
-        .iter()
-        .position(|item| item.id == request.track_id)
-        .unwrap_or(0);
-
     info!("Built queue with {} media items, starting at index {}", media_items.len(), start_index);
 
     // Handle shuffle before setting queue

src-tauri/src/jellyfin/http_client.rs

@@ -217,45 +217,6 @@ impl HttpClient {
             .map_err(|e| format!("Failed to parse JSON: {}", e))
     }
 
-    /// Make a GET request and deserialize JSON with a short timeout and no retries.
-    ///
-    /// Intended for the initial "connect to server" probe on the login screen:
-    /// a wrong/unreachable URL must fail fast instead of burning through the
-    /// default 30s-per-attempt timeout and exponential backoff retries.
-    pub async fn get_json_fast<T: DeserializeOwned>(&self, url: &str) -> Result<T, String> {
-        // Short timeout so an unreachable host fails quickly.
-        const FAST_TIMEOUT: Duration = Duration::from_secs(10);
-
-        let request = self
-            .client
-            .get(url)
-            .timeout(FAST_TIMEOUT)
-            .build()
-            .map_err(|e| format!("Failed to build request: {}", e))?;
-
-        // No retry: connection failures on a wrong URL won't succeed on retry,
-        // they'd only multiply the wait the user sees before an error.
-        let response = self
-            .client
-            .execute(request)
-            .await
-            .map_err(|e| format!("Request failed: {}", e))?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let error_text = response
-                .text()
-                .await
-                .unwrap_or_else(|_| "Unknown error".to_string());
-            return Err(format!("HTTP {}: {}", status, error_text));
-        }
-
-        response
-            .json::<T>()
-            .await
-            .map_err(|e| format!("Failed to parse JSON: {}", e))
-    }
-
     /// Quick ping to check if a server is reachable (no retry)
     pub async fn ping(&self, url: &str) -> bool {
         let request = self.client.get(url)

src-tauri/src/lib.rs

@@ -23,7 +23,6 @@ use log::{error, info};
 use log::warn;
 
 use commands::{
-    sync_full_catalog, catalog_sync_status, resume_queued_downloads,
     cancel_download, clear_stale_downloads, delete_album_downloads, delete_all_downloads, delete_download,
     download_album, download_item, download_item_and_start, download_video, download_series, download_season,
     get_download_storage_stats, get_downloads, get_download_manager_stats, set_max_concurrent_downloads,
@@ -586,9 +585,6 @@ fn specta_builder() -> Builder<tauri::Wry> {
             start_download,
             enqueue_download,
             enqueue_video_downloads,
-            sync_full_catalog,
-            catalog_sync_status,
-            resume_queued_downloads,
             get_download_manager_stats,
             set_max_concurrent_downloads,
             get_smart_cache_stats,
@@ -934,11 +930,9 @@ pub fn run() {
                 playback_mode_arc.clone(),
             );
             session_poller.set_event_emitter(event_emitter.clone());
-            // Note: start() is deferred until after the connectivity monitor is
+            session_poller.start();
-            // created below, so the poller can report reachability from its first
-            // poll (it drives offline detection + recovery while the user is idle).
             let session_poller_arc = Arc::new(session_poller);
-            let session_poller_wrapper = SessionPollerWrapper(session_poller_arc.clone());
+            let session_poller_wrapper = SessionPollerWrapper(session_poller_arc);
             app.manage(session_poller_wrapper);
 
             // On Android, set up the MediaSession (lockscreen) handler and the
@@ -1000,12 +994,6 @@ pub fn run() {
             let mut connectivity_monitor = ConnectivityMonitor::new(http_client);
             connectivity_monitor.set_app_handle(app.handle().clone());
 
-            // Wire the connectivity reporter into the session poller so its
-            // continuous background polls drive reachability (offline detection
-            // + recovery) even when the user isn't browsing, then start it.
-            session_poller_arc.set_connectivity_reporter(connectivity_monitor.reporter());
-            session_poller_arc.start();
-
             // Wrap in Arc for sharing with AuthManager
             let connectivity_arc = Arc::new(tokio::sync::Mutex::new(connectivity_monitor));
             let connectivity_wrapper = ConnectivityMonitorWrapper(connectivity_arc.clone());

src-tauri/src/repository/hybrid.rs

@@ -79,26 +79,6 @@ impl HybridRepository {
             .await
     }
 
-    /// Fetch a folder's items from the live server and persist them to the
-    /// offline cache synchronously (unlike `get_items`, which saves in a
-    /// fire-and-forget background task after a 100ms cache race).
-    ///
-    /// Used by the full-catalog pre-sync (`sync_full_catalog`) to deterministically
-    /// walk every library while online so the whole catalog is browsable — greyed
-    /// out — offline. Returns the items fetched so the caller can recurse into
-    /// containers. Server-only: errors if unreachable.
-    pub async fn cache_items_from_server(
-        &self,
-        parent_id: &str,
-        options: Option<GetItemsOptions>,
-    ) -> Result<Vec<MediaItem>, RepoError> {
-        let result = self.online.get_items(parent_id, options).await?;
-        if !result.items.is_empty() {
-            self.offline.save_to_cache(parent_id, &result.items).await?;
-        }
-        Ok(result.items)
-    }
-
     /// Search only the live Jellyfin server (full library).
     pub async fn search_server_only(
         &self,
@@ -216,41 +196,11 @@ impl HybridRepository {
 #[async_trait]
 impl MediaRepository for HybridRepository {
     async fn get_libraries(&self) -> Result<Vec<Library>, RepoError> {
-        // Cache-first (100ms). On a cache hit, refresh the cache from the server
+        // Libraries change infrequently, try cache first with fast timeout
-        // in the background. On a miss, fetch from the server and persist so the
+        let cache_future = self.cache_with_timeout(self.offline.get_libraries());
-        // list is available on the next (possibly offline) startup.
+        let server_future = self.online.get_libraries();
-        let cache_result = self.cache_with_timeout(self.offline.get_libraries()).await;
 
-        if let Ok(libs) = &cache_result {
+        self.parallel_race(cache_future, server_future).await
-            if libs.has_content() {
-                debug!("[HybridRepo] Cache hit for libraries, returning immediately");
-                let online = Arc::clone(&self.online);
-                let offline = Arc::clone(&self.offline);
-                tokio::spawn(async move {
-                    if let Ok(server_libs) = online.get_libraries().await {
-                        if !server_libs.is_empty() {
-                            if let Err(e) = offline.save_libraries_to_cache(&server_libs).await {
-                                warn!("[HybridRepo] Background library cache update failed: {:?}", e);
-                            }
-                        }
-                    }
-                });
-                return cache_result;
-            }
-        }
-
-        // Cache miss — fetch from server and persist for offline use.
-        match self.online.get_libraries().await {
-            Ok(server_libs) => {
-                if !server_libs.is_empty() {
-                    if let Err(e) = self.offline.save_libraries_to_cache(&server_libs).await {
-                        warn!("[HybridRepo] Failed to cache {} libraries: {:?}", server_libs.len(), e);
-                    }
-                }
-                Ok(server_libs)
-            }
-            Err(e) => cache_result.or(Err(e)),
-        }
     }
 
     async fn get_items(&self, parent_id: &str, options: Option<GetItemsOptions>) -> Result<SearchResult, RepoError> {
@@ -427,60 +377,20 @@ impl MediaRepository for HybridRepository {
     }
 
     async fn get_genres(&self, parent_id: Option<&str>) -> Result<Vec<Genre>, RepoError> {
-        // Cache-first (100ms). On a cache hit, refresh the cached genre catalog
+        let offline = Arc::clone(&self.offline);
-        // from the server in the background. On a miss, fetch from the server and
+        let online = Arc::clone(&self.online);
-        // persist so the full genre list is available offline. Mirrors
-        // get_libraries — NOT parallel_race, whose "any non-empty cache wins"
-        // rule would pin genres to whatever sparse set the local albums yield.
         let parent_id_str = parent_id.map(|s| s.to_string());
+        let parent_id_clone = parent_id_str.clone();
 
-        let cache_offline = Arc::clone(&self.offline);
+        let cache_future = self.cache_with_timeout(async move {
-        let cache_pid = parent_id_str.clone();
+            offline.get_genres(parent_id_str.as_deref()).await
-        let cache_result = self
+        });
-            .cache_with_timeout(async move { cache_offline.get_genres(cache_pid.as_deref()).await })
-            .await;
 
-        if let Ok(genres) = &cache_result {
+        let server_future = async move {
-            if genres.has_content() {
+            online.get_genres(parent_id_clone.as_deref()).await
-                debug!("[HybridRepo] Cache hit for genres, returning immediately");
+        };
-                let online = Arc::clone(&self.online);
-                let offline = Arc::clone(&self.offline);
-                let pid = parent_id_str.clone();
-                tokio::spawn(async move {
-                    if let Ok(server_genres) = online.get_genres(pid.as_deref()).await {
-                        if !server_genres.is_empty() {
-                            if let Err(e) =
-                                offline.save_genres_to_cache(pid.as_deref(), &server_genres).await
-                            {
-                                warn!("[HybridRepo] Background genre cache update failed: {:?}", e);
-                            }
-                        }
-                    }
-                });
-                return cache_result;
-            }
-        }
 
-        // Cache miss — fetch from server and persist for offline use.
+        self.parallel_race(cache_future, server_future).await
-        match self.online.get_genres(parent_id_str.as_deref()).await {
-            Ok(server_genres) => {
-                if !server_genres.is_empty() {
-                    if let Err(e) = self
-                        .offline
-                        .save_genres_to_cache(parent_id_str.as_deref(), &server_genres)
-                        .await
-                    {
-                        warn!(
-                            "[HybridRepo] Failed to cache {} genres: {:?}",
-                            server_genres.len(),
-                            e
-                        );
-                    }
-                }
-                Ok(server_genres)
-            }
-            Err(e) => cache_result.or(Err(e)),
-        }
     }
 
     async fn search(&self, query: &str, options: Option<SearchOptions>) -> Result<SearchResult, RepoError> {

src-tauri/src/repository/offline.rs

@@ -359,94 +359,6 @@ impl OfflineRepository {
         Ok(count)
     }
 
-    /// Cache the library (view) list from the server into the local database.
-    /// Called by HybridRepository after a successful online fetch so the list is
-    /// available offline. Without this, the `libraries` table stays empty and
-    /// offline startup shows no libraries at all.
-    pub async fn save_libraries_to_cache(&self, libraries: &[Library]) -> Result<usize, RepoError> {
-        if libraries.is_empty() {
-            return Ok(0);
-        }
-
-        let mut count = 0;
-        for (idx, lib) in libraries.iter().enumerate() {
-            let query = Query::with_params(
-                "INSERT OR REPLACE INTO libraries (id, server_id, name, collection_type, image_tag, sort_order, synced_at)
-                 VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)",
-                vec![
-                    QueryParam::String(lib.id.clone()),
-                    QueryParam::String(self.server_id.clone()),
-                    QueryParam::String(lib.name.clone()),
-                    QueryParam::String(lib.collection_type.clone()),
-                    lib.image_tag.clone().map(QueryParam::String).unwrap_or(QueryParam::Null),
-                    QueryParam::Int(idx as i32),
-                ],
-            );
-            self.db_service.execute(query).await
-                .map_err(|e| RepoError::Database { message: e })?;
-            count += 1;
-        }
-        Ok(count)
-    }
-
-    /// Cache the full server genre catalog for a library, so offline (and the
-    /// hybrid cache-first race) can return the complete list instead of only the
-    /// genres derivable from locally-cached albums. Replaces the scope's rows
-    /// wholesale so genres removed on the server don't linger.
-    pub async fn save_genres_to_cache(
-        &self,
-        parent_id: Option<&str>,
-        genres: &[Genre],
-    ) -> Result<usize, RepoError> {
-        if genres.is_empty() {
-            return Ok(0);
-        }
-
-        // library_id is part of the primary key; NULL keys don't de-dupe in
-        // SQLite, so store the "no library" scope as an empty string.
-        let library_id = parent_id.unwrap_or("").to_string();
-        let server_id = self.server_id.clone();
-        let genres: Vec<(String, String, Option<u32>)> = genres
-            .iter()
-            .map(|g| (g.id.clone(), g.name.clone(), g.album_count))
-            .collect();
-        let saved = genres.len();
-
-        self.db_service
-            .transaction(move |tx| {
-                use crate::storage::db_service::{Query, QueryParam};
-
-                // Clear the scope's existing genres, then re-insert the fresh set.
-                tx.execute(Query::with_params(
-                    "DELETE FROM genres WHERE server_id = ? AND library_id = ?",
-                    vec![
-                        QueryParam::String(server_id.clone()),
-                        QueryParam::String(library_id.clone()),
-                    ],
-                ))?;
-
-                for (id, name, album_count) in &genres {
-                    tx.execute(Query::with_params(
-                        "INSERT OR REPLACE INTO genres (id, server_id, library_id, name, album_count, synced_at)
-                         VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)",
-                        vec![
-                            QueryParam::String(id.clone()),
-                            QueryParam::String(server_id.clone()),
-                            QueryParam::String(library_id.clone()),
-                            QueryParam::String(name.clone()),
-                            album_count.map(|c| QueryParam::Int(c as i32)).unwrap_or(QueryParam::Null),
-                        ],
-                    ))?;
-                }
-
-                Ok(())
-            })
-            .await
-            .map_err(|e| RepoError::Database { message: e })?;
-
-        Ok(saved)
-    }
-
     /// Cache playlist items from server into local database
     /// Called by HybridRepository after fetching from online
     pub async fn save_playlist_items_to_cache(
@@ -501,17 +413,26 @@ impl OfflineRepository {
 #[async_trait]
 impl MediaRepository for OfflineRepository {
     async fn get_libraries(&self) -> Result<Vec<Library>, RepoError> {
-        // Return every cached library for this server. We deliberately do NOT
+        // Only show libraries that have downloaded content
-        // gate on `items.library_id` here: that column is not populated in the
+        // Check both direct children and nested children (e.g., albums inside library)
-        // cache (the Jellyfin client doesn't parse it), so the old
-        // `INNER JOIN items i ON i.library_id = l.id` matched nothing and left
-        // offline startup with zero libraries. Navigating into a library still
-        // filters to downloaded content via get_items, so listing all cached
-        // libraries is correct — it's the "local first" list the UI browses.
         let query = Query::with_params(
-            "SELECT l.id, l.name, l.collection_type, l.image_tag
+            "SELECT DISTINCT l.id, l.name, l.collection_type, l.image_tag
              FROM libraries l
+             INNER JOIN items i ON i.library_id = l.id
              WHERE l.server_id = ?
+               AND (
+                   -- Direct playable items with downloads
+                   (i.item_type IN ('Audio', 'Movie', 'Episode')
+                    AND EXISTS (SELECT 1 FROM downloads d WHERE d.item_id = i.id AND d.status = 'completed'))
+                   OR
+                   -- Container items with downloaded children
+                   (i.item_type IN ('MusicAlbum', 'Series', 'Season', 'BoxSet', 'Folder', 'CollectionFolder')
+                    AND EXISTS (
+                        SELECT 1 FROM items children
+                        INNER JOIN downloads d ON children.id = d.item_id
+                        WHERE children.parent_id = i.id AND d.status = 'completed'
+                    ))
+               )
              ORDER BY l.sort_order ASC, l.name ASC",
             vec![QueryParam::String(self.server_id.clone())],
         );
@@ -573,7 +494,7 @@ impl MediaRepository for OfflineRepository {
                 -- Containers with downloaded children
                 SELECT DISTINCT i.id
                 FROM items i
-                INNER JOIN items children ON (children.parent_id = i.id OR children.album_id = i.id OR children.season_id = i.id OR children.series_id = i.id)
+                INNER JOIN items children ON children.parent_id = i.id
                 INNER JOIN downloads d ON children.id = d.item_id
                 WHERE d.status = 'completed'
                   AND i.item_type IN ('MusicAlbum', 'Series', 'Season', 'BoxSet', 'Folder', 'CollectionFolder')
@@ -592,38 +513,17 @@ impl MediaRepository for OfflineRepository {
                     i.parent_index_number, i.is_folder, i.premiere_date
             FROM items i
              INNER JOIN available_items ai ON i.id = ai.id
-             WHERE i.server_id = ?
+             WHERE i.server_id = ? AND i.parent_id = ?{}
-               AND (
-                   i.parent_id = ? OR i.album_id = ? OR i.season_id = ? OR i.series_id = ?
-                   -- When the requested parent is a LIBRARY, there is no per-item
-                   -- link back to it (library_id/parent_id are NULL in the cache),
-                   -- so match every item on the server and let the type filter
-                   -- (e.g. MusicAlbum / Movie / Series) narrow it. This is what
-                   -- makes library landing pages show albums/movies/shows offline.
-                   OR EXISTS (
-                       SELECT 1 FROM libraries l
-                       WHERE l.id = ? AND l.server_id = i.server_id
-                   )
-               ){}
              ORDER BY {}
              LIMIT {} OFFSET {}",
             type_filter, order_by, limit, start_index
         );
 
-        // The requested id is compared against every hierarchy-linkage column
-        // because `parent_id` is not populated for cached items — music tracks
-        // link to their album via `album_id`, episodes to their season/series
-        // via `season_id`/`series_id`, and a library parent matches via the
-        // `libraries` EXISTS clause. See [[offline-libraries-never-cached]].
         let query = Query::with_params(
             sql,
             vec![
                 QueryParam::String(self.server_id.clone()),
-                QueryParam::String(parent_id.to_string()), // i.parent_id = ?
+                QueryParam::String(parent_id.to_string()),
-                QueryParam::String(parent_id.to_string()), // i.album_id = ?
-                QueryParam::String(parent_id.to_string()), // i.season_id = ?
-                QueryParam::String(parent_id.to_string()), // i.series_id = ?
-                QueryParam::String(parent_id.to_string()), // libraries.id = ?
             ],
         );
 
@@ -666,7 +566,7 @@ impl MediaRepository for OfflineRepository {
                 -- Containers with downloaded children
                 SELECT DISTINCT i.id
                 FROM items i
-                INNER JOIN items children ON (children.parent_id = i.id OR children.album_id = i.id OR children.season_id = i.id OR children.series_id = i.id)
+                INNER JOIN items children ON children.parent_id = i.id
                 INNER JOIN downloads d ON children.id = d.item_id
                 WHERE d.status = 'completed'
                   AND i.item_type IN ('MusicAlbum', 'Series', 'Season', 'BoxSet', 'Folder', 'CollectionFolder')
@@ -711,7 +611,7 @@ impl MediaRepository for OfflineRepository {
                     -- Containers with downloaded children
                     SELECT DISTINCT i.id
                     FROM items i
-                    INNER JOIN items children ON (children.parent_id = i.id OR children.album_id = i.id OR children.season_id = i.id OR children.series_id = i.id)
+                    INNER JOIN items children ON children.parent_id = i.id
                     INNER JOIN downloads d ON children.id = d.item_id
                     WHERE d.status = 'completed'
                       AND i.item_type IN ('MusicAlbum', 'Series', 'Season', 'BoxSet', 'Folder', 'CollectionFolder')
@@ -844,7 +744,7 @@ impl MediaRepository for OfflineRepository {
                     -- Containers with downloaded children (Albums)
                     SELECT DISTINCT i.id
                     FROM items i
-                    INNER JOIN items children ON (children.parent_id = i.id OR children.album_id = i.id OR children.season_id = i.id OR children.series_id = i.id)
+                    INNER JOIN items children ON children.parent_id = i.id
                     INNER JOIN downloads d ON children.id = d.item_id
                     WHERE d.status = 'completed'
                       AND i.item_type = 'MusicAlbum'
@@ -949,32 +849,59 @@ impl MediaRepository for OfflineRepository {
     }
 
     async fn get_genres(&self, parent_id: Option<&str>) -> Result<Vec<Genre>, RepoError> {
-        // Read the cached server genre catalog (populated by the hybrid repo via
+        // Derive genres from cached albums, tallying how many albums carry each
-        // save_genres_to_cache). This is the FULL genre list for the library, not
+        // so the frontend can rank by popularity. We scope to MusicAlbum (genres
-        // just the genres derivable from locally-cached albums — so offline keeps
+        // power the music landing) and read every matching row — NOT DISTINCT —
-        // the same variety the server has. library_id NULL is stored as ''.
+        // so the per-genre counts are real. Genres are stored as a JSON array
-        let library_id = parent_id.unwrap_or("").to_string();
+        // string per item.
+        let (sql, params) = if let Some(pid) = parent_id {
+            (
+                "SELECT genres FROM items WHERE server_id = ? AND library_id = ? \
+                 AND item_type = 'MusicAlbum' AND genres IS NOT NULL",
+                vec![
+                    QueryParam::String(self.server_id.clone()),
+                    QueryParam::String(pid.to_string()),
+                ],
+            )
+        } else {
+            (
+                "SELECT genres FROM items WHERE server_id = ? \
+                 AND item_type = 'MusicAlbum' AND genres IS NOT NULL",
+                vec![QueryParam::String(self.server_id.clone())],
+            )
+        };
 
-        let query = Query::with_params(
+        let query = Query::with_params(sql, params);
-            "SELECT id, name, album_count FROM genres WHERE server_id = ? AND library_id = ?",
-            vec![
-                QueryParam::String(self.server_id.clone()),
-                QueryParam::String(library_id),
-            ],
-        );
 
-        let genres: Vec<Genre> = self
+        let genres_rows: Vec<String> = self
             .db_service
-            .query_many(query, |row| {
+            .query_many(query, |row| row.get(0))
-                Ok(Genre {
-                    id: row.get(0)?,
-                    name: row.get(1)?,
-                    album_count: row.get::<_, Option<i64>>(2)?.map(|c| c as u32),
-                })
-            })
             .await
             .map_err(|e| RepoError::Database { message: e })?;
 
+        // genre name -> album count
+        let mut counts: std::collections::HashMap<String, u32> = std::collections::HashMap::new();
+        for genres_json in genres_rows {
+            if let Ok(genres_vec) = serde_json::from_str::<Vec<String>>(&genres_json) {
+                // De-dupe within one album so a genre listed twice counts once.
+                let mut seen = std::collections::HashSet::new();
+                for genre in genres_vec {
+                    if seen.insert(genre.clone()) {
+                        *counts.entry(genre).or_insert(0) += 1;
+                    }
+                }
+            }
+        }
+
+        let genres = counts
+            .into_iter()
+            .map(|(name, count)| Genre {
+                id: name.clone(),
+                name,
+                album_count: Some(count),
+            })
+            .collect();
+
         Ok(genres)
     }
 
@@ -1016,7 +943,7 @@ impl MediaRepository for OfflineRepository {
                 -- Containers with downloaded children
                 SELECT DISTINCT i.id
                 FROM items i
-                INNER JOIN items children ON (children.parent_id = i.id OR children.album_id = i.id OR children.season_id = i.id OR children.series_id = i.id)
+                INNER JOIN items children ON children.parent_id = i.id
                 INNER JOIN downloads d ON children.id = d.item_id
                 WHERE d.status = 'completed'
                   AND i.item_type IN ('MusicAlbum', 'Series', 'Season', 'BoxSet', 'Folder', 'CollectionFolder')
@@ -1230,7 +1157,7 @@ impl MediaRepository for OfflineRepository {
                     -- Containers with downloaded children
                     SELECT DISTINCT i.id
                     FROM items i
-                    INNER JOIN items children ON (children.parent_id = i.id OR children.album_id = i.id OR children.season_id = i.id OR children.series_id = i.id)
+                    INNER JOIN items children ON children.parent_id = i.id
                     INNER JOIN downloads d ON children.id = d.item_id
                     WHERE d.status = 'completed'
                       AND i.item_type IN ('MusicAlbum', 'Series', 'Season', 'BoxSet', 'Folder', 'CollectionFolder')
@@ -1614,32 +1541,6 @@ mod tests {
             );
 
             CREATE INDEX idx_playlist_items_playlist ON playlist_items(playlist_id, sort_order);
-
-            CREATE TABLE downloads (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                item_id TEXT NOT NULL,
-                status TEXT NOT NULL
-            );
-
-            CREATE TABLE libraries (
-                id TEXT PRIMARY KEY,
-                server_id TEXT NOT NULL,
-                name TEXT NOT NULL,
-                collection_type TEXT,
-                image_tag TEXT,
-                sort_order INTEGER DEFAULT 0,
-                synced_at TEXT
-            );
-
-            CREATE TABLE genres (
-                id TEXT NOT NULL,
-                server_id TEXT NOT NULL,
-                library_id TEXT,
-                name TEXT NOT NULL,
-                album_count INTEGER,
-                synced_at TEXT DEFAULT CURRENT_TIMESTAMP,
-                PRIMARY KEY (server_id, library_id, name)
-            );
         "#).unwrap();
 
         // Insert a test server
@@ -1820,196 +1721,6 @@ mod tests {
         assert_eq!(result.unwrap(), 3);
     }
 
-    /// Regression: a MusicAlbum whose tracks link via `album_id` (and have a
-    /// NULL `parent_id`, which is how the Jellyfin cache actually stores them)
-    /// must be recognized as available offline when a track is downloaded.
-    ///
-    /// Before the fix, `get_item(album_id)` only matched children by
-    /// `children.parent_id = i.id`, so a fully-downloaded album returned
-    /// NotFound offline and playback fell through to the (unreachable) server.
-    #[tokio::test]
-    async fn test_get_item_album_available_via_album_id_link() {
-        use crate::storage::db_service::DatabaseService;
-        let db_service = create_test_db();
-
-        for sql in [
-            // Album container (no children by parent_id).
-            "INSERT INTO items (id, server_id, name, item_type, album_id, parent_id) \
-             VALUES ('album-1', 'test-server', 'Hadestown', 'MusicAlbum', NULL, NULL)",
-            // Track linked to the album ONLY via album_id, parent_id NULL.
-            "INSERT INTO items (id, server_id, name, item_type, album_id, parent_id) \
-             VALUES ('track-1', 'test-server', 'Wait For Me', 'Audio', 'album-1', NULL)",
-            "INSERT INTO downloads (item_id, status) VALUES ('track-1', 'completed')",
-        ] {
-            db_service.execute(Query::new(sql)).await.unwrap();
-        }
-
-        let repo = OfflineRepository::new(
-            db_service.clone(),
-            "test-server".to_string(),
-            "test-user".to_string(),
-        );
-
-        // The downloaded track itself resolves offline.
-        assert!(
-            repo.get_item("track-1").await.is_ok(),
-            "downloaded track should be available offline"
-        );
-
-        // The album must also resolve offline because it has a downloaded child
-        // linked by album_id (not parent_id).
-        let album = repo.get_item("album-1").await;
-        assert!(
-            album.is_ok(),
-            "album with an album_id-linked downloaded track should be available offline, got {:?}",
-            album.err()
-        );
-        assert_eq!(album.unwrap().id, "album-1");
-
-        // Browsing into the album (get_items) must return its tracks even though
-        // they link by album_id and have a NULL parent_id. This is the call
-        // play_album_track makes to build the queue.
-        let tracks = repo.get_items("album-1", None).await.unwrap();
-        assert_eq!(tracks.items.len(), 1, "get_items(album_id) should return the track");
-        assert_eq!(tracks.items[0].id, "track-1");
-    }
-
-    /// Regression: TV episodes link to their season/series via `season_id` /
-    /// `series_id` (NOT `parent_id`, which is NULL in the cache). A downloaded
-    /// episode must make both its Season and Series available offline, and
-    /// browsing either container must return the episode.
-    #[tokio::test]
-    async fn test_get_item_tv_available_via_season_series_link() {
-        use crate::storage::db_service::DatabaseService;
-        let db_service = create_test_db();
-
-        for sql in [
-            "INSERT INTO items (id, server_id, name, item_type, parent_id) \
-             VALUES ('series-1', 'test-server', 'Gilmore Girls', 'Series', NULL)",
-            "INSERT INTO items (id, server_id, name, item_type, series_id, parent_id) \
-             VALUES ('season-1', 'test-server', 'Season 1', 'Season', 'series-1', NULL)",
-            // Episode links to both season and series; parent_id NULL.
-            "INSERT INTO items (id, server_id, name, item_type, season_id, series_id, parent_id) \
-             VALUES ('ep-1', 'test-server', 'Pilot', 'Episode', 'season-1', 'series-1', NULL)",
-            "INSERT INTO downloads (item_id, status) VALUES ('ep-1', 'completed')",
-        ] {
-            db_service.execute(Query::new(sql)).await.unwrap();
-        }
-
-        let repo = OfflineRepository::new(
-            db_service.clone(),
-            "test-server".to_string(),
-            "test-user".to_string(),
-        );
-
-        assert!(repo.get_item("ep-1").await.is_ok(), "downloaded episode available offline");
-        assert!(
-            repo.get_item("season-1").await.is_ok(),
-            "season with a season_id-linked downloaded episode should be available offline"
-        );
-        assert!(
-            repo.get_item("series-1").await.is_ok(),
-            "series with a series_id-linked downloaded episode should be available offline"
-        );
-
-        // Browsing the season returns the episode.
-        let season_items = repo.get_items("season-1", None).await.unwrap();
-        assert!(
-            season_items.items.iter().any(|i| i.id == "ep-1"),
-            "get_items(season_id) should return the episode"
-        );
-
-        // Browsing the series returns the episode (via series_id link).
-        let series_items = repo.get_items("series-1", None).await.unwrap();
-        assert!(
-            series_items.items.iter().any(|i| i.id == "ep-1"),
-            "get_items(series_id) should surface the downloaded episode"
-        );
-    }
-
-    /// Regression: offline startup must list cached libraries. Previously
-    /// `get_libraries` joined on `items.library_id` (always NULL in the cache),
-    /// so it returned nothing offline and the app showed no libraries at all.
-    /// The list must round-trip through `save_libraries_to_cache`.
-    #[tokio::test]
-    async fn test_libraries_cache_roundtrip_available_offline() {
-        let db_service = create_test_db();
-        let repo = OfflineRepository::new(
-            db_service.clone(),
-            "test-server".to_string(),
-            "test-user".to_string(),
-        );
-
-        // Empty cache → no libraries (this is the state that fell through to the
-        // server and hung offline).
-        assert!(repo.get_libraries().await.unwrap().is_empty());
-
-        // Simulate the online path persisting the server's library list.
-        let server_libs = vec![
-            Library { id: "music".into(), name: "Music".into(), collection_type: "music".into(), image_tag: None },
-            Library { id: "movies".into(), name: "Movies".into(), collection_type: "movies".into(), image_tag: Some("tag".into()) },
-        ];
-        let saved = repo.save_libraries_to_cache(&server_libs).await.unwrap();
-        assert_eq!(saved, 2);
-
-        // Now offline get_libraries returns them without touching the server.
-        let offline_libs = repo.get_libraries().await.unwrap();
-        let names: Vec<&str> = offline_libs.iter().map(|l| l.name.as_str()).collect();
-        assert_eq!(names, vec!["Music", "Movies"], "cached libraries available offline in sort order");
-
-        // Re-saving is idempotent (INSERT OR REPLACE), not duplicating rows.
-        repo.save_libraries_to_cache(&server_libs).await.unwrap();
-        assert_eq!(repo.get_libraries().await.unwrap().len(), 2);
-    }
-
-    /// Regression: the music/TV/movie landing pages lost genre variety because
-    /// offline `get_genres` derived genres from cached albums only — so the
-    /// hybrid cache-first race pinned the list to whatever sparse set the local
-    /// albums yielded instead of the server's full catalog. The full genre list
-    /// must round-trip through `save_genres_to_cache` and come back scoped by
-    /// library.
-    #[tokio::test]
-    async fn test_genres_cache_roundtrip_scoped_by_library() {
-        let db_service = create_test_db();
-        let repo = OfflineRepository::new(
-            db_service.clone(),
-            "test-server".to_string(),
-            "test-user".to_string(),
-        );
-
-        // Empty cache → no genres.
-        assert!(repo.get_genres(Some("music-lib")).await.unwrap().is_empty());
-
-        // Simulate the online path persisting the server's full genre catalog.
-        let server_genres = vec![
-            Genre { id: "g1".into(), name: "Rock".into(), album_count: Some(42) },
-            Genre { id: "g2".into(), name: "Jazz".into(), album_count: Some(17) },
-            Genre { id: "g3".into(), name: "Ambient".into(), album_count: None },
-        ];
-        let saved = repo.save_genres_to_cache(Some("music-lib"), &server_genres).await.unwrap();
-        assert_eq!(saved, 3);
-
-        // Offline get_genres returns the full set for that library, counts intact.
-        let mut offline_genres = repo.get_genres(Some("music-lib")).await.unwrap();
-        offline_genres.sort_by(|a, b| a.name.cmp(&b.name));
-        let names: Vec<&str> = offline_genres.iter().map(|g| g.name.as_str()).collect();
-        assert_eq!(names, vec!["Ambient", "Jazz", "Rock"]);
-        let rock = offline_genres.iter().find(|g| g.name == "Rock").unwrap();
-        assert_eq!(rock.album_count, Some(42));
-
-        // Genres are scoped: a different library sees nothing.
-        assert!(repo.get_genres(Some("other-lib")).await.unwrap().is_empty());
-
-        // Re-saving replaces the scope's rows (server removed "Jazz").
-        let updated = vec![
-            Genre { id: "g1".into(), name: "Rock".into(), album_count: Some(50) },
-        ];
-        repo.save_genres_to_cache(Some("music-lib"), &updated).await.unwrap();
-        let after = repo.get_genres(Some("music-lib")).await.unwrap();
-        assert_eq!(after.len(), 1, "stale genres removed on refresh");
-        assert_eq!(after[0].album_count, Some(50), "counts updated on refresh");
-    }
-
     // ===== Playlist Tests =====
 
     /// Helper to seed items into the DB for playlist tests

src-tauri/src/repository/online.rs

@@ -144,17 +144,6 @@ impl OnlineRepository {
 
     /// Make authenticated GET request
     async fn get_json<T: for<'de> Deserialize<'de>>(&self, endpoint: &str) -> Result<T, RepoError> {
-        // Fast-fail when connectivity is known-offline. Without this every request
-        // still runs the full HTTP retry/backoff cycle (~7s) before giving up,
-        // which stalls cache-miss paths and makes offline browsing feel janky.
-        // The offline recovery probe (connectivity monitor) flips us back to
-        // reachable the moment the server returns, so this never sticks.
-        if let Some(reporter) = &self.connectivity {
-            if !reporter.is_reachable().await {
-                return Err(RepoError::Offline);
-            }
-        }
-
         let result = self.get_json_inner(endpoint).await;
         self.report_outcome(&result).await;
         result
@@ -1424,43 +1413,12 @@ impl MediaRepository for OnlineRepository {
         quality: &str,
         media_source_id: Option<&str>,
     ) -> String {
-        // NOTE: Jellyfin's `/Videos/{id}/download` endpoint is not universally
+        let mut url = format!("{}/Videos/{}/download", self.server_url, item_id);
-        // available (returns 404 on many server configs), which silently broke
-        // every movie/TV download. Use the progressive `stream.mp4` endpoint
-        // instead — it is always present and supports HTTP Range, which the
-        // download worker relies on for resume.
-        let mut url = format!("{}/Videos/{}/stream.mp4", self.server_url, item_id);
         let mut params = vec![format!("api_key={}", self.access_token)];
 
-        // Map the frontend quality preset to concrete transcode params. For
+        // Add quality parameter if not "original"
-        // "original" we request a direct static copy (no transcode) which is
+        if quality != "original" {
-        // byte-range resumable; other presets ask the server to transcode.
+            params.push(format!("quality={}", quality));
-        match quality {
-            "high" => {
-                params.push("videoBitrate=8000000".to_string());
-                params.push("maxHeight=1080".to_string());
-                params.push("audioBitrate=384000".to_string());
-                params.push("videoCodec=h264".to_string());
-                params.push("audioCodec=aac".to_string());
-            }
-            "medium" => {
-                params.push("videoBitrate=4000000".to_string());
-                params.push("maxHeight=720".to_string());
-                params.push("audioBitrate=256000".to_string());
-                params.push("videoCodec=h264".to_string());
-                params.push("audioCodec=aac".to_string());
-            }
-            "low" => {
-                params.push("videoBitrate=1500000".to_string());
-                params.push("maxHeight=480".to_string());
-                params.push("audioBitrate=128000".to_string());
-                params.push("videoCodec=h264".to_string());
-                params.push("audioCodec=aac".to_string());
-            }
-            // "original" (and any unknown value) → direct, resumable copy.
-            _ => {
-                params.push("Static=true".to_string());
-            }
         }
 
         // Add media source ID if provided
@@ -1468,8 +1426,10 @@ impl MediaRepository for OnlineRepository {
             params.push(format!("mediaSourceId={}", source_id));
         }
 
-        url.push('?');
+        if !params.is_empty() {
-        url.push_str(&params.join("&"));
+            url.push('?');
+            url.push_str(&params.join("&"));
+        }
 
         url
     }
@@ -1799,25 +1759,6 @@ mod tests {
         }
     }
 
-    /// When connectivity is known-offline, `get_json` must fast-fail with
-    /// `RepoError::Offline` instead of running the full HTTP retry cycle (~7s).
-    /// This is what keeps offline browsing snappy. `test.server.com` is
-    /// unroutable, so if the guard were absent this would hang on retries; the
-    /// assertion returning promptly with `Offline` proves the short-circuit.
-    #[tokio::test]
-    async fn test_get_json_fast_fails_when_offline() {
-        let (repo, reporter) = create_test_repository_with_connectivity();
-        reporter.mark_unreachable_for_test().await;
-        assert!(!reporter.is_reachable().await, "precondition: offline");
-
-        let result: Result<serde_json::Value, RepoError> = repo.get_json("/System/Info").await;
-        assert!(
-            matches!(result, Err(RepoError::Offline)),
-            "known-offline get_json should return Offline immediately, got {:?}",
-            result
-        );
-    }
-
     /// A network error routes through the debounced path. A single failure stays
     /// online (debounce window not yet elapsed).
     #[tokio::test]
@@ -1946,74 +1887,6 @@ mod tests {
         assert_eq!(tags.primary(), None);
     }
 
-    // ===== Video download URL (real impl) =====
-    //
-    // These exercise the PRODUCTION `OnlineRepository::get_video_download_url`,
-    // not a mock. A prior mock in online_integration_test.rs used the correct
-    // `stream.mp4` endpoint while the real impl shipped `/Videos/{id}/download`,
-    // which returns 404 on real servers and silently broke every movie/TV
-    // download. Assert the real builder targets the resumable stream endpoint.
-    //
-    // @req-test: DR-013 - Repository pattern for online/offline data access
-
-    #[test]
-    fn test_video_download_url_uses_stream_not_download_endpoint() {
-        let repo = create_test_repository();
-        let url = repo.get_video_download_url("item123", "original", None);
-
-        // Must NOT use the /download endpoint (404 on real servers).
-        assert!(
-            !url.contains("/download"),
-            "download URL must not use the broken /Videos/{{id}}/download endpoint: {url}"
-        );
-        // Must use the progressive, range-resumable stream endpoint.
-        assert!(
-            url.contains("/Videos/item123/stream.mp4"),
-            "download URL must target /Videos/{{id}}/stream.mp4: {url}"
-        );
-        assert!(url.contains("api_key=test-access-token"), "url: {url}");
-    }
-
-    #[test]
-    fn test_video_download_url_original_is_static_direct_copy() {
-        let repo = create_test_repository();
-        let url = repo.get_video_download_url("item123", "original", None);
-
-        // "original" must request a direct static copy (byte-range resumable),
-        // with no transcode params.
-        assert!(url.contains("Static=true"), "url: {url}");
-        assert!(!url.contains("videoBitrate"), "original must not transcode: {url}");
-        assert!(!url.contains("maxHeight"), "original must not transcode: {url}");
-    }
-
-    #[test]
-    fn test_video_download_url_quality_presets_transcode() {
-        let repo = create_test_repository();
-
-        for (quality, height) in [("high", "1080"), ("medium", "720"), ("low", "480")] {
-            let url = repo.get_video_download_url("item123", quality, None);
-            assert!(
-                url.contains("/Videos/item123/stream.mp4"),
-                "{quality} must use stream.mp4: {url}"
-            );
-            assert!(url.contains("videoBitrate="), "{quality} must set bitrate: {url}");
-            assert!(
-                url.contains(&format!("maxHeight={height}")),
-                "{quality} must cap height at {height}: {url}"
-            );
-            assert!(url.contains("videoCodec=h264"), "{quality}: {url}");
-            // Transcoded presets must not also ask for a static copy.
-            assert!(!url.contains("Static=true"), "{quality} must not be Static: {url}");
-        }
-    }
-
-    #[test]
-    fn test_video_download_url_passes_media_source_id() {
-        let repo = create_test_repository();
-        let url = repo.get_video_download_url("item123", "original", Some("src-42"));
-        assert!(url.contains("mediaSourceId=src-42"), "url: {url}");
-    }
-
     #[test]
     fn test_jellyfin_item_deserialize_with_image_tags() {
         // Test full JellyfinItem deserialization with ImageTags

src-tauri/src/session_poller/mod.rs

@@ -32,13 +32,6 @@ pub struct SessionPollerManager {
     jellyfin_client: Arc<Mutex<Option<JellyfinClient>>>,
     playback_mode_manager: Arc<PlaybackModeManager>,
     event_emitter: Arc<Mutex<Option<Arc<dyn PlayerEventEmitter>>>>,
-    /// Optional connectivity reporter. The session poller is the one piece of
-    /// server traffic that runs continuously even when the user is idle (not
-    /// browsing the library), so feeding its poll outcomes into the reporter is
-    /// what lets the app detect going offline — and, crucially, recover when the
-    /// server returns — without any user interaction. Repository traffic alone
-    /// can't do this because it only happens while browsing.
-    connectivity_reporter: Arc<Mutex<Option<crate::connectivity::ConnectivityReporter>>>,
 
     // Polling state
     is_running: Arc<AtomicBool>,
@@ -59,7 +52,6 @@ impl SessionPollerManager {
             jellyfin_client,
             playback_mode_manager,
             event_emitter: Arc::new(Mutex::new(None)),
-            connectivity_reporter: Arc::new(Mutex::new(None)),
             is_running: Arc::new(AtomicBool::new(false)),
             current_hint: Arc::new(RwLock::new(PollingHint::Normal)),
             current_interval_ms: Arc::new(AtomicU64::new(10000)), // Default 10s
@@ -72,13 +64,6 @@ impl SessionPollerManager {
         *self.event_emitter.lock_safe() = Some(emitter);
     }
 
-    /// Wire the connectivity reporter so each poll outcome updates reachability.
-    /// A successful poll recovers the app to online instantly; sustained poll
-    /// failures flip it offline (subject to the reporter's debounce window).
-    pub fn set_connectivity_reporter(&self, reporter: crate::connectivity::ConnectivityReporter) {
-        *self.connectivity_reporter.lock_safe() = Some(reporter);
-    }
-
     /// Start the background polling thread
     pub fn start(&self) {
         if self.is_running.swap(true, Ordering::Relaxed) {
@@ -92,7 +77,6 @@ impl SessionPollerManager {
         let client = self.jellyfin_client.clone();
         let mode_manager = self.playback_mode_manager.clone();
         let emitter = self.event_emitter.clone();
-        let connectivity_reporter = self.connectivity_reporter.clone();
         let is_running = self.is_running.clone();
         let hint = self.current_hint.clone();
         let interval_ms = self.current_interval_ms.clone();
@@ -112,35 +96,18 @@ impl SessionPollerManager {
 
                 debug!("[SessionPoller] Polling with interval: {}ms", new_interval);
 
-                // Fetch sessions. `had_client` distinguishes "server didn't
+                // Fetch sessions
-                // answer" from "no client configured" so we only feed real
+                let sessions_result = rt.block_on(async {
-                // request outcomes into the connectivity reporter.
-                let (sessions_result, had_client) = rt.block_on(async {
                     let client_opt = client.lock_safe().clone();
                     match client_opt {
-                        Some(c) => (c.get_sessions().await, true),
+                        Some(c) => c.get_sessions().await,
                         None => {
                             debug!("[SessionPoller] Jellyfin client not configured, skipping poll");
-                            (Ok(Vec::new()), false)
+                            Ok(Vec::new())
                         }
                     }
                 });
 
-                // Drive the connectivity reporter from this poll's outcome. This
-                // is what recovers the app to online when the server returns
-                // while the user is idle, and detects going offline when no
-                // library browsing is happening. See connectivity/mod.rs.
-                if had_client {
-                    if let Some(reporter) = connectivity_reporter.lock_safe().clone() {
-                        rt.block_on(async {
-                            match &sessions_result {
-                                Ok(_) => reporter.report_success().await,
-                                Err(e) => reporter.report_network_failure(Some(e.clone())).await,
-                            }
-                        });
-                    }
-                }
-
                 // Emit event if successful
                 match sessions_result {
                     Ok(sessions) => {

src-tauri/src/storage/mod.rs

@@ -201,7 +201,6 @@ mod tests {
             "thumbnails",
             "playlists",
             "playlist_items",
-            "genres",
         ];
 
         for table in expected_tables {

src-tauri/src/storage/schema.rs

@@ -23,7 +23,6 @@ pub const MIGRATIONS: &[(&str, &str)] = &[
     ("016_autoplay_max_episodes", MIGRATION_016),
     ("017_downloads_resume_url", MIGRATION_017),
     ("018_items_is_folder", MIGRATION_018),
-    ("019_genres_cache", MIGRATION_019),
 ];
 
 /// Initial schema migration
@@ -694,23 +693,3 @@ ALTER TABLE items ADD COLUMN is_folder INTEGER DEFAULT 0;
 -- Force re-fetch of all cached items so is_folder is populated from the server.
 UPDATE items SET synced_at = NULL;
 "#;
-
-/// Migration to cache the full server genre catalog. Previously genres were
-/// derived on the fly from cached albums, which meant offline (and the hybrid
-/// cache-first race) only ever saw genres for the handful of locally-cached
-/// albums — collapsing the variety on the music/TV/movie landing pages. This
-/// table stores the complete genre list per library so offline has the real
-/// catalog and cache-first routing returns the right thing.
-const MIGRATION_019: &str = r#"
-CREATE TABLE IF NOT EXISTS genres (
-    id TEXT NOT NULL,
-    server_id TEXT NOT NULL,
-    library_id TEXT,
-    name TEXT NOT NULL,
-    album_count INTEGER,
-    synced_at TEXT DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY (server_id, library_id, name)
-);
-
-CREATE INDEX IF NOT EXISTS idx_genres_scope ON genres(server_id, library_id);
-"#;

src-tauri/src/thumbnail/cache.rs

@@ -64,8 +64,7 @@ impl ThumbnailCache {
         image_type: &str,
         tag: &str,
     ) -> Option<PathBuf> {
-        // Primary lookup: exact (item_id, image_type, tag) match.
+        let query = Query::with_params(
-        let exact = Query::with_params(
             "SELECT file_path FROM thumbnails
              WHERE item_id = ? AND image_type = ? AND image_tag = ?",
             vec![
@@ -75,60 +74,12 @@ impl ThumbnailCache {
             ],
         );
 
-        if let Ok(Some(path_str)) = db.query_optional(exact, |row| row.get::<_, String>(0)).await {
+        let path_str: String = db.query_optional(query, |row| row.get(0)).await.ok()??;
-            let path = PathBuf::from(&path_str);
-            if path.exists() {
-                self.touch(&db, item_id, image_type, Some(tag)).await;
-                return Some(path);
-            }
-            // File gone — drop the stale row and fall through to the tag-agnostic
-            // lookup below (another cached image for this item may still exist).
-            let _ = db.execute(Query::with_params(
-                "DELETE FROM thumbnails WHERE item_id = ? AND image_type = ? AND image_tag = ?",
-                vec![
-                    QueryParam::String(item_id.to_string()),
-                    QueryParam::String(image_type.to_string()),
-                    QueryParam::String(tag.to_string()),
-                ],
-            )).await;
-        }
-
-        // Fallback: any cached image for this item + type, newest first. The
-        // `image_tag` is a cache-busting version, and callers don't always pass
-        // the same tag the image was cached under — e.g. the mini player asks for
-        // the album image using the *track's* primary_image_tag. Ignoring the tag
-        // here lets those still resolve offline instead of hitting the server.
-        let any_tag = Query::with_params(
-            "SELECT file_path FROM thumbnails
-             WHERE item_id = ? AND image_type = ?
-             ORDER BY cached_at DESC LIMIT 1",
-            vec![
-                QueryParam::String(item_id.to_string()),
-                QueryParam::String(image_type.to_string()),
-            ],
-        );
-
-        let path_str: String = db.query_optional(any_tag, |row| row.get(0)).await.ok()??;
         let path = PathBuf::from(&path_str);
-        if path.exists() {
-            self.touch(&db, item_id, image_type, None).await;
-            Some(path)
-        } else {
-            None
-        }
-    }
 
-    /// Update `last_accessed` for LRU tracking. When `tag` is `Some`, scope to
+        if path.exists() {
-    /// that exact row; when `None`, touch every row for the item + type.
+            // Update last_accessed for LRU tracking
-    async fn touch(
+            let update_query = Query::with_params(
-        &self,
-        db: &Arc<RusqliteService>,
-        item_id: &str,
-        image_type: &str,
-        tag: Option<&str>,
-    ) {
-        let query = match tag {
-            Some(tag) => Query::with_params(
                 "UPDATE thumbnails SET last_accessed = CURRENT_TIMESTAMP
                  WHERE item_id = ? AND image_type = ? AND image_tag = ?",
                 vec![
@@ -136,17 +87,23 @@ impl ThumbnailCache {
                     QueryParam::String(image_type.to_string()),
                     QueryParam::String(tag.to_string()),
                 ],
-            ),
+            );
-            None => Query::with_params(
+            let _ = db.execute(update_query).await;
-                "UPDATE thumbnails SET last_accessed = CURRENT_TIMESTAMP
+            Some(path)
-                 WHERE item_id = ? AND image_type = ?",
+        } else {
+            // Clean up stale database entry
+            let delete_query = Query::with_params(
+                "DELETE FROM thumbnails
+                 WHERE item_id = ? AND image_type = ? AND image_tag = ?",
                 vec![
                     QueryParam::String(item_id.to_string()),
                     QueryParam::String(image_type.to_string()),
+                    QueryParam::String(tag.to_string()),
                 ],
-            ),
+            );
-        };
+            let _ = db.execute(delete_query).await;
-        let _ = db.execute(query).await;
+            None
+        }
     }
 
     /// Save thumbnail to cache

src/lib/api/bindings.ts

@@ -806,38 +806,6 @@ async enqueueDownload(downloadId: number, streamUrl: string, targetDir: string)
 async enqueueVideoDownloads(handle: string, downloadIds: number[], targetDir: string) : Promise<null> {
     return await TAURI_INVOKE("enqueue_video_downloads", { handle, downloadIds, targetDir });
 },
-/**
- * Walk every library on the server and persist all items to the offline cache
- * so the full catalog is browsable offline (greyed out when not downloaded).
- * 
- * Best-effort: a library that fails to fetch is counted and skipped rather than
- * aborting the whole sync. Runs libraries sequentially to avoid hammering the
- * server. Uses `Recursive=true` so a single request per library returns the
- * containers and their playable children.
- */
-async syncFullCatalog(handle: string) : Promise<CatalogSyncResult> {
-    return await TAURI_INVOKE("sync_full_catalog", { handle });
-},
-/**
- * Report the last-synced timestamp so the UI can show a hint / decide whether
- * to trigger a fresh sync.
- */
-async catalogSyncStatus() : Promise<CatalogSyncStatus> {
-    return await TAURI_INVOKE("catalog_sync_status");
-},
-/**
- * Resolve the stream URL for every download row that was queued while offline
- * (`status = 'pending' AND stream_url IS NULL`), then pump the queue so they
- * start. Call this on reconnect.
- * 
- * Audio rows resolve via `get_audio_stream_url`; video rows (media_type =
- * 'video') via the pure `get_video_download_url` builder using the row's stored
- * `quality_preset` — mirroring `enqueue_video_downloads`. Rows whose URL can't
- * be resolved are left pending (they retry on the next reconnect).
- */
-async resumeQueuedDownloads(handle: string) : Promise<ResumeQueuedResult> {
-    return await TAURI_INVOKE("resume_queued_downloads", { handle });
-},
 /**
  * Get download manager statistics
  */
@@ -1537,20 +1505,6 @@ export type CachedLibrary = { id: string; serverId: string; name: string; collec
  * Cached person info returned to frontend
  */
 export type CachedPerson = { id: string; serverId: string; name: string; overview: string | null; primaryImageTag: string | null; premiereDate: string | null; endDate: string | null }
-export type CatalogSyncResult = { 
-/**
- * Total items persisted to the offline cache across all libraries.
- */
-itemsCached: number; 
-/**
- * Libraries that failed to sync (e.g. server hiccup); best-effort.
- */
-librariesFailed: number }
-export type CatalogSyncStatus = { 
-/**
- * RFC-3339 timestamp of the last successful sync, if any.
- */
-lastSyncedAt: string | null }
 /**
  * Connectivity status
  */
@@ -2112,15 +2066,6 @@ export type RemoteSessionStatus = { position: number; duration: number | null; i
  * TRACES: UR-005 | DR-005
  */
 export type RepeatMode = "off" | "all" | "one"
-export type ResumeQueuedResult = { 
-/**
- * Rows whose stream URL was resolved and are now pump-eligible.
- */
-resolved: number; 
-/**
- * Rows that couldn't be resolved (item metadata / URL lookup failed).
- */
-failed: number }
 /**
  * Options for search queries
  */

src/lib/components/library/GenericGenreBrowser.svelte

@@ -1,6 +1,5 @@
 <script lang="ts">
   import { onMount } from "svelte";
-  import { page } from "$app/stores";
   import { truncateMiddle } from "$lib/utils/truncateMiddle";
   import { goto } from "$app/navigation";
   import { navigateBack } from "$lib/utils/navigation";
@@ -54,16 +53,6 @@
 
   onMount(async () => {
     await loadGenres();
-    // Auto-select a genre when linked with ?genre=<name> (e.g. from a genre tag)
-    const requestedGenre = $page.url.searchParams.get("genre");
-    if (requestedGenre) {
-      const match = genres.find(
-        (g) => g.name.toLowerCase() === requestedGenre.toLowerCase(),
-      );
-      if (match) {
-        await loadGenreItems(match);
-      }
-    }
     markLoaded();
   });
 

src/lib/components/library/GenreTags.svelte

@@ -5,34 +5,14 @@
     genres: string[];
     maxShow?: number;  // Default: unlimited
     clickable?: boolean;  // Default: true
-    itemType?: string;  // Determines which genre browse page to open
   }
 
   let {
     genres,
     maxShow,
-    clickable = true,
+    clickable = true
-    itemType
   }: Props = $props();
 
-  // Map the item type to its genre-browse route
-  function genreBasePath(type: string | undefined): string {
-    switch (type) {
-      case "MusicAlbum":
-      case "MusicArtist":
-      case "Audio":
-        return "/library/music/genres";
-      case "Series":
-      case "Season":
-      case "Episode":
-        return "/library/shows/genres";
-      case "Movie":
-        return "/library/movies/genres";
-      default:
-        return "/library/movies/genres";
-    }
-  }
-
   const displayGenres = $derived(
     maxShow ? genres.slice(0, maxShow) : genres
   );
@@ -43,7 +23,9 @@
 
   function handleGenreClick(genre: string) {
     if (clickable) {
-      goto(`${genreBasePath(itemType)}?genre=${encodeURIComponent(genre)}`);
+      // Navigate to genre browse page
+      // For now, we'll use a simple navigation - could be enhanced with a proper genre browse page
+      goto(`/search?genre=${encodeURIComponent(genre)}`);
     }
   }
 </script>

src/lib/components/library/MediaCard.serverOnly.test.ts

@@ -1,130 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { render, screen, fireEvent } from "@testing-library/svelte";
-
-// Controllable stores for the offline "server only" branch. Declared via
-// vi.hoisted so they exist when the hoisted vi.mock factories run. A tiny
-// writable shim avoids importing svelte inside the hoisted block.
-const h = vi.hoisted(() => {
-  function shim<T>(initial: T) {
-    let value = initial;
-    const subs = new Set<(v: T) => void>();
-    return {
-      set(v: T) {
-        value = v;
-        subs.forEach((fn) => fn(value));
-      },
-      subscribe(fn: (v: T) => void) {
-        subs.add(fn);
-        fn(value);
-        return () => subs.delete(fn);
-      },
-    };
-  }
-  return {
-    isConnectedStore: shim(true),
-    showServerCatalogStore: shim(false),
-    downloadsStore: shim({ downloads: {} as Record<string, any> }),
-    downloadItem: vi.fn(async () => 1),
-    getUserId: vi.fn(() => "user-1"),
-  };
-});
-
-const { isConnectedStore, showServerCatalogStore, downloadsStore, downloadItem, getUserId } = h;
-
-vi.mock("$lib/stores/connectivity", () => ({
-  isConnected: { subscribe: h.isConnectedStore.subscribe },
-}));
-
-vi.mock("$lib/services/offlineCatalog", () => ({
-  showServerCatalog: { subscribe: h.showServerCatalogStore.subscribe },
-}));
-
-vi.mock("$lib/stores/downloads", () => ({
-  downloads: { subscribe: h.downloadsStore.subscribe, downloadItem: h.downloadItem },
-}));
-
-vi.mock("$lib/stores/auth", () => ({
-  auth: { getUserId: h.getUserId },
-}));
-
-// CachedImage does async repo/image work irrelevant to these tests.
-vi.mock("$lib/components/common/CachedImage.svelte", async () => ({
-  default: (await import("./__mocks__/StubImage.svelte")).default,
-}));
-
-import MediaCard from "./MediaCard.svelte";
-
-const track = {
-  id: "track-1",
-  name: "Some Song",
-  type: "Audio" as const,
-  serverId: "server-1",
-  artists: ["Artist A"],
-  albumName: "Album X",
-};
-
-describe("MediaCard server-only (offline browse & queue)", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    isConnectedStore.set(true);
-    showServerCatalogStore.set(false);
-    downloadsStore.set({ downloads: {} });
-  });
-
-  it("shows no queue button while online", () => {
-    render(MediaCard, { props: { item: track } });
-    expect(screen.queryByLabelText(/Queue download/i)).toBeNull();
-  });
-
-  it("shows no queue button when offline but the reveal toggle is off", () => {
-    isConnectedStore.set(false);
-    render(MediaCard, { props: { item: track } });
-    expect(screen.queryByLabelText(/Queue download/i)).toBeNull();
-  });
-
-  it("reveals a queue button when offline and the reveal toggle is on", () => {
-    isConnectedStore.set(false);
-    showServerCatalogStore.set(true);
-    render(MediaCard, { props: { item: track } });
-    expect(screen.getByLabelText(/Queue download for Some Song/i)).toBeTruthy();
-  });
-
-  it("queues the item for download with its metadata on click", async () => {
-    isConnectedStore.set(false);
-    showServerCatalogStore.set(true);
-    render(MediaCard, { props: { item: track } });
-
-    await fireEvent.click(screen.getByLabelText(/Queue download for Some Song/i));
-
-    expect(downloadItem).toHaveBeenCalledTimes(1);
-    const args = downloadItem.mock.calls[0] as unknown as any[];
-    expect(args[0]).toBe("track-1"); // itemId
-    expect(args[1]).toBe("user-1"); // userId
-    expect(args[5]).toBe("Some Song"); // itemName
-    expect(args[6]).toBe("Artist A"); // artistName
-    expect(args[7]).toBe("Album X"); // albumName
-  });
-
-  it("shows a Queued badge (not the button) for a pending download", () => {
-    isConnectedStore.set(false);
-    showServerCatalogStore.set(true);
-    downloadsStore.set({
-      downloads: { "track-1": { itemId: "track-1", status: "pending", progress: 0 } },
-    });
-    render(MediaCard, { props: { item: track } });
-
-    expect(screen.getByText(/Queued/i)).toBeTruthy();
-    expect(screen.queryByLabelText(/Queue download/i)).toBeNull();
-  });
-
-  it("does not grey out a completed download", () => {
-    isConnectedStore.set(false);
-    showServerCatalogStore.set(true);
-    downloadsStore.set({
-      downloads: { "track-1": { itemId: "track-1", status: "completed", progress: 1 } },
-    });
-    render(MediaCard, { props: { item: track } });
-
-    expect(screen.queryByLabelText(/Queue download/i)).toBeNull();
-  });
-});

src/lib/components/library/MediaCard.svelte

@@ -2,9 +2,6 @@
   import type { MediaItem, Library } from "$lib/api/types";
   import { truncateMiddle } from "$lib/utils/truncateMiddle";
   import { downloads } from "$lib/stores/downloads";
-  import { isConnected } from "$lib/stores/connectivity";
-  import { showServerCatalog } from "$lib/services/offlineCatalog";
-  import { auth } from "$lib/stores/auth";
   import CachedImage from "$lib/components/common/CachedImage.svelte";
 
   interface Props {
@@ -28,55 +25,6 @@
   );
   const downloadProgress = $derived(downloadInfo?.progress || 0);
 
-  // A media item (not a library) is "server only" when it exists in the cache
-  // but isn't downloaded/downloading — and we're offline with the reveal toggle
-  // on. Such cards render greyed out with a "queue for download" button and are
-  // inert to tap (nothing to play offline).
-  const isMediaItem = $derived("type" in item);
-  const isQueued = $derived(downloadInfo?.status === "pending");
-  // Actively transferring (as opposed to merely queued/pending for reconnect).
-  const isActivelyDownloading = $derived(downloadInfo?.status === "downloading");
-  // "Server only" = offline, reveal on, and not already downloaded or actively
-  // transferring. A `pending` (queued-for-reconnect) item stays server-only so
-  // it can show the Queued badge in place of the queue button.
-  const isServerOnly = $derived(
-    isMediaItem && !$isConnected && $showServerCatalog && !isDownloaded && !isActivelyDownloading
-  );
-
-  let queueError = $state<string | null>(null);
-
-  // Queue this item for download on next reconnect. Offline, this just persists
-  // a `pending` downloads row (no stream_url); the reconnect handler resolves
-  // the URL and the pump starts it. See offlineCatalog service.
-  async function queueForDownload(e: Event) {
-    e.stopPropagation();
-    if (!isMediaItem) return;
-    const media = item as MediaItem;
-    const userId = auth.getUserId();
-    if (!userId) {
-      queueError = "Not signed in";
-      return;
-    }
-    try {
-      queueError = null;
-      // Derive a sensible on-disk path; the backend heals stream_url on reconnect.
-      const filePath = `downloads/${media.id}`;
-      await downloads.downloadItem(
-        media.id,
-        userId,
-        filePath,
-        undefined,
-        undefined,
-        media.name,
-        media.artists?.join(", ") ?? undefined,
-        media.albumName ?? undefined
-      );
-    } catch (err) {
-      console.error("[MediaCard] Failed to queue download:", err);
-      queueError = "Failed to queue";
-    }
-  }
-
   const sizeClasses = {
     small: "w-24",
     medium: "w-36",
@@ -128,12 +76,10 @@
   });
 </script>
 
-<svelte:element
+<button
-  this={isServerOnly ? "div" : "button"}
+  type="button"
-  type={isServerOnly ? undefined : "button"}
+  class="group/card flex flex-col text-left {sizeClasses[size]} flex-shrink-0 transition-transform duration-200 hover:scale-105"
-  role={isServerOnly ? "group" : undefined}
+  {onclick}
-  class="group/card flex flex-col text-left {sizeClasses[size]} flex-shrink-0 transition-transform duration-200 {isServerOnly ? '' : 'hover:scale-105'}"
-  onclick={isServerOnly ? undefined : onclick}
 >
   <div class="relative {aspectRatio()} w-full rounded-lg overflow-hidden bg-[var(--color-surface)] shadow-md group-hover/card:shadow-2xl transition-shadow duration-200">
     <CachedImage
@@ -142,12 +88,11 @@
       tag={imageTag}
       maxWidth={maxWidth}
       alt={item.name}
-      class="w-full h-full object-cover transition-transform duration-300 group-hover/card:scale-110 {isServerOnly ? 'opacity-40 grayscale' : ''}"
+      class="w-full h-full object-cover transition-transform duration-300 group-hover/card:scale-110"
     />
 
-    <!-- Hover overlay with smooth gradient (play affordance; hidden for
+    <!-- Hover overlay with smooth gradient -->
-         server-only cards, which can't be played offline) -->
+    <div class="absolute inset-0 bg-gradient-to-t from-black/60 via-black/0 to-black/0 opacity-0 group-hover/card:opacity-100 transition-opacity duration-300 flex items-center justify-center">
-    <div class="absolute inset-0 bg-gradient-to-t from-black/60 via-black/0 to-black/0 opacity-0 {isServerOnly ? '' : 'group-hover/card:opacity-100'} transition-opacity duration-300 flex items-center justify-center">
       <div class="transform scale-90 group-hover/card:scale-100 opacity-0 group-hover/card:opacity-100 transition-all duration-300">
         <div class="w-14 h-14 rounded-full bg-[var(--color-jellyfin)] hover:bg-[var(--color-jellyfin)]/90 flex items-center justify-center shadow-2xl">
           <svg class="w-7 h-7 text-white ml-1" fill="currentColor" viewBox="0 0 24 24">
@@ -218,43 +163,9 @@
         {/if}
       </div>
     {/if}
-
-    <!-- Server-only: queue-for-download control (kept at full opacity over the
-         greyed artwork). Queued items show a "queued" badge instead. -->
-    {#if isServerOnly}
-      <div class="absolute inset-0 flex items-center justify-center">
-        {#if isQueued}
-          <div class="flex flex-col items-center gap-1 text-white" title="Queued — will download on reconnect">
-            <div class="w-11 h-11 rounded-full bg-black/60 flex items-center justify-center shadow-lg">
-              <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2">
-                <path stroke-linecap="round" stroke-linejoin="round" d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z" />
-              </svg>
-            </div>
-            <span class="text-[10px] font-medium bg-black/60 px-1.5 py-0.5 rounded-full">Queued</span>
-          </div>
-        {:else}
-          <button
-            type="button"
-            onclick={queueForDownload}
-            class="w-11 h-11 rounded-full bg-[var(--color-jellyfin)] hover:bg-[var(--color-jellyfin)]/90 flex items-center justify-center shadow-lg transition-colors"
-            title="Queue download for next connection"
-            aria-label="Queue download for {item.name}"
-          >
-            <svg class="w-6 h-6 text-white" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2">
-              <path stroke-linecap="round" stroke-linejoin="round" d="M12 4v12m0 0l-4-4m4 4l4-4M4 20h16" />
-            </svg>
-          </button>
-        {/if}
-      </div>
-      {#if queueError}
-        <div class="absolute bottom-1 left-1 right-1 text-center text-[10px] text-red-200 bg-black/70 rounded px-1 py-0.5">
-          {queueError}
-        </div>
-      {/if}
-    {/if}
   </div>
 
-  <div class="mt-2 space-y-0.5 {isServerOnly ? 'opacity-60' : ''}">
+  <div class="mt-2 space-y-0.5">
     <p class="text-sm font-medium text-white truncate group-hover/card:text-[var(--color-jellyfin)] transition-colors">
       {truncateMiddle(item.name, 40)}
     </p>
@@ -262,4 +173,4 @@
       <p class="text-xs text-gray-400 truncate">{subtitle()}</p>
     {/if}
   </div>
-</svelte:element>
+</button>

src/lib/components/library/__mocks__/StubImage.svelte

@@ -1,7 +0,0 @@
-<script lang="ts">
-  // Minimal stand-in for CachedImage in unit tests: renders nothing meaningful,
-  // just accepts the same props so MediaCard renders without hitting the repo.
-  let { alt = "" }: { alt?: string; [key: string]: unknown } = $props();
-</script>
-
-<div data-testid="stub-image" aria-label={alt}></div>

src/lib/components/player/MiniPlayer.svelte

@@ -19,7 +19,6 @@
   import { goto } from "$app/navigation";
   import type { MediaItem } from "$lib/api/types";
   import { auth } from "$lib/stores/auth";
-  import { commands } from "$lib/api/bindings";
   import {
     mergedMedia,
     mergedIsPlaying,
@@ -71,27 +70,6 @@
   // In remote mode, this automatically uses the remote session's nowPlayingItem
   const displayMedia = $derived($mergedMedia || $currentQueueItem);
   const displayIsPlaying = $derived($mergedIsPlaying);
-
-  // The player's MediaItem doesn't carry favorite state, so read it from the
-  // local user_data cache (offline-safe — same source the optimistic toggle
-  // writes to). Re-runs whenever the current track changes.
-  let isFavorite = $state(false);
-  let favoriteLoadedFor = "";
-  $effect(() => {
-    const id = displayMedia?.id;
-    if (!id || id === favoriteLoadedFor) return;
-    favoriteLoadedFor = id;
-    isFavorite = false;
-    const userId = auth.getUserId();
-    if (!userId) return;
-    commands
-      .storageGetPlaybackProgress(userId, id)
-      .then((p) => {
-        // Guard against a race if the track changed while awaiting.
-        if (displayMedia?.id === id) isFavorite = p?.isFavorite ?? false;
-      })
-      .catch(() => {});
-  });
   const displayPosition = $derived($mergedPosition);
   const displayDuration = $derived($mergedDuration);
 
@@ -380,7 +358,7 @@
         {#if displayMedia}
           <FavoriteButton
             itemId={displayMedia?.id ?? ""}
-            bind:isFavorite
+            isFavorite={displayMedia?.userData?.isFavorite ?? false}
             size="sm"
           />
         {/if}

src/lib/services/favorites.ts

@@ -1,10 +1,8 @@
 // Favorites service - Handles toggling favorite status with optimistic updates
 // TRACES: UR-017 | DR-021
 
-import { get } from "svelte/store";
 import { commands } from "$lib/api/bindings";
 import { auth } from "$lib/stores/auth";
-import { isConnected } from "$lib/stores/connectivity";
 
 /**
  * Toggle the favorite status of an item.
@@ -33,31 +31,21 @@ export async function toggleFavorite(
   // 1. Update local database first (optimistic update)
   await commands.storageToggleFavorite(userId, itemId, newIsFavorite);
 
-  // 2. Sync to Jellyfin server.
+  // 2. Sync to Jellyfin server
-  //
+  try {
-  // Only attempt this when we're actually connected. When offline, the server
+    const repo = auth.getRepository();
-  // call can hang on a long network timeout rather than failing fast — which
+    if (newIsFavorite) {
-  // blocks the caller (and leaves the favorite button greyed out with a wait
+      await repo.markFavorite(itemId);
-  // cursor) until the request finally gives up, effectively only recovering
+    } else {
-  // once we're back online. The local DB write above keeps the pending_sync
+      await repo.unmarkFavorite(itemId);
-  // flag set, so the change still syncs later; we just don't block the UI on
-  // an unreachable server here.
-  if (get(isConnected)) {
-    try {
-      const repo = auth.getRepository();
-      if (newIsFavorite) {
-        await repo.markFavorite(itemId);
-      } else {
-        await repo.unmarkFavorite(itemId);
-      }
-
-      // 3. Mark as synced
-      await commands.storageMarkSynced(userId, itemId);
-    } catch (error) {
-      console.error("Failed to sync favorite to server:", error);
-      // Favorite is stored locally and will be synced later
-      // via sync queue (when implemented)
     }
+
+    // 3. Mark as synced
+    await commands.storageMarkSynced(userId, itemId);
+  } catch (error) {
+    console.error("Failed to sync favorite to server:", error);
+    // Favorite is stored locally and will be synced later
+    // via sync queue (when implemented)
   }
 
   return newIsFavorite;

src/lib/services/offlineCatalog.ts

@@ -1,102 +0,0 @@
-// Offline catalog service - "browse & queue" for offline mode.
-//
-// Two responsibilities:
-//  1. Full-catalog pre-sync: while online, walk every library and persist all
-//     items to the offline cache so the whole catalog is browsable (greyed out)
-//     offline. Backed by the `syncFullCatalog` Rust command.
-//  2. Resume-on-reconnect: when the server becomes reachable again, resolve the
-//     stream URLs of downloads that were queued while offline and let the pump
-//     start them. Backed by `resumeQueuedDownloads`.
-//
-// It also owns the `showServerCatalog` UI flag (the offline banner toggle that
-// reveals greyed-out, non-downloaded server media).
-//
-// TRACES: UR-002
-
-import { writable, type Writable } from "svelte/store";
-import { commands } from "$lib/api/bindings";
-import { auth } from "$lib/stores/auth";
-
-/**
- * When true (and offline), library grids reveal greyed-out versions of media
- * that exists on the server but isn't downloaded, each with a button to queue
- * a download for the next reconnect. Toggled from the offline banner.
- */
-export const showServerCatalog: Writable<boolean> = writable(false);
-
-/** Last time a full catalog sync completed, for a UI hint. */
-export const lastCatalogSync: Writable<string | null> = writable(null);
-
-// Guard against overlapping syncs (they can be slow on large libraries).
-let syncInProgress = false;
-
-function currentHandle(): string | null {
-  try {
-    return auth.getRepository().getHandle();
-  } catch {
-    return null; // not connected yet
-  }
-}
-
-/**
- * Walk every library and cache the full catalog. Best-effort and non-blocking:
- * safe to call on startup (while online) and on reconnect. No-ops if not
- * connected or a sync is already running.
- */
-export async function syncCatalog(): Promise<void> {
-  if (syncInProgress) return;
-  const handle = currentHandle();
-  if (!handle) return;
-
-  syncInProgress = true;
-  try {
-    const result = await commands.syncFullCatalog(handle);
-    console.info(
-      `[OfflineCatalog] Synced ${result.itemsCached} items (${result.librariesFailed} libraries failed)`
-    );
-    await refreshSyncStatus();
-  } catch (err) {
-    console.warn("[OfflineCatalog] Full catalog sync failed:", err);
-  } finally {
-    syncInProgress = false;
-  }
-}
-
-/**
- * Resolve URLs for downloads queued while offline and pump them. Call on
- * reconnect. No-ops if not connected.
- */
-export async function resumeQueued(): Promise<void> {
-  const handle = currentHandle();
-  if (!handle) return;
-  try {
-    const result = await commands.resumeQueuedDownloads(handle);
-    if (result.resolved > 0 || result.failed > 0) {
-      console.info(
-        `[OfflineCatalog] Resumed queued downloads: ${result.resolved} resolved, ${result.failed} failed`
-      );
-    }
-  } catch (err) {
-    console.warn("[OfflineCatalog] Failed to resume queued downloads:", err);
-  }
-}
-
-/** Refresh the last-synced timestamp from the backend. */
-export async function refreshSyncStatus(): Promise<void> {
-  try {
-    const status = await commands.catalogSyncStatus();
-    lastCatalogSync.set(status.lastSyncedAt ?? null);
-  } catch (err) {
-    console.debug("[OfflineCatalog] Failed to fetch sync status:", err);
-  }
-}
-
-/**
- * Called when the server becomes reachable again: resume queued downloads first
- * (fast, user-visible), then refresh the catalog in the background.
- */
-export async function onReconnected(): Promise<void> {
-  await resumeQueued();
-  // Fire-and-forget: don't block reconnection handling on a potentially long walk.
-  void syncCatalog();
-}

src/lib/stores/auth.ts

@@ -201,11 +201,6 @@ function createAuthStore() {
           onServerReconnected: () => {
             // Retry session verification when server becomes reachable
             retryVerification();
-            // Resume downloads queued while offline, then refresh the catalog.
-            // Lazy import to avoid an auth <-> offlineCatalog import cycle.
-            import("$lib/services/offlineCatalog")
-              .then((m) => m.onReconnected())
-              .catch((err) => console.warn("[Auth] Catalog reconnect failed:", err));
           },
         }).catch((error) => {
           console.error("[Auth] Failed to start connectivity monitoring:", error);

src/lib/stores/home.ts

@@ -36,10 +36,7 @@ function createHomeStore() {
     try {
       const repo = auth.getRepository();
 
-      // Use allSettled so one failing section (e.g. Next Up is online-only and
+      const [resume, nextUp, latest, recentAudio, resumeMovies] = await Promise.all([
-      // rejects offline) doesn't wipe out the whole homepage. Each section falls
-      // back to an empty list; cached sections (resume/latest/recent) still show.
-      const settled = await Promise.allSettled([
         repo.getResumeItems(undefined, 12),
         repo.getNextUpEpisodes(undefined, 12),
         repo.getLatestItems("", 16),
@@ -47,15 +44,6 @@ function createHomeStore() {
         repo.getResumeMovies(12),
       ]);
 
-      const valueOr = <T>(i: number, fallback: T): T =>
-        settled[i].status === "fulfilled" ? (settled[i] as PromiseFulfilledResult<T>).value : fallback;
-
-      const resume = valueOr(0, [] as typeof initialState.resumeItems);
-      const nextUp = valueOr(1, [] as typeof initialState.nextUpItems);
-      const latest = valueOr(2, [] as typeof initialState.latestItems);
-      const recentAudio = valueOr(3, [] as typeof initialState.recentlyPlayedAudio);
-      const resumeMovies = valueOr(4, [] as typeof initialState.resumeMovies);
-
       // Use resume items or latest as hero items
       const hero = resume.length >= 3 ? resume.slice(0, 5) : latest.slice(0, 5);
 

src/routes/+layout.svelte

@@ -1,6 +1,5 @@
 <script lang="ts">
   import { onMount, onDestroy } from "svelte";
-  import { get } from "svelte/store";
   import { page } from "$app/stores";
   import { goto } from "$app/navigation";
   import { platform } from "@tauri-apps/plugin-os";
@@ -8,9 +7,8 @@
   import { auth, needsReauth, isAuthenticated } from "$lib/stores/auth";
   import { connectivity, isConnected } from "$lib/stores/connectivity";
   import { initPlayerEvents, cleanupPlayerEvents } from "$lib/services/playerEvents";
-  import { downloads, initDownloadEvents, cleanupDownloadEvents } from "$lib/stores/downloads";
+  import { initDownloadEvents, cleanupDownloadEvents } from "$lib/stores/downloads";
   import { syncService } from "$lib/services/syncService";
-  import { onReconnected as onCatalogReconnected, syncCatalog, refreshSyncStatus, showServerCatalog, lastCatalogSync } from "$lib/services/offlineCatalog";
   import { playbackMode } from "$lib/stores/playbackMode";
   import { sessions } from "$lib/stores/sessions";
   import { currentMedia, isPlaying, playbackPosition, playbackDuration } from "$lib/stores/player";
@@ -45,20 +43,6 @@
       ($isAndroid || !pathname.startsWith('/library'))
   );
 
-  // The library and settings routes own their own full-height layout (their own
-  // scroll container + bottom-space reservation), so the root must leave their
-  // wrapper as a plain non-scrolling box. Every other top-level page (search,
-  // downloads, sessions, home) renders straight into the root, so the root
-  // wrapper has to scroll AND reserve the fixed bottom UI's height — otherwise
-  // the mini player / bottom nav overlay the last rows of content.
-  const routeOwnsLayout = $derived(
-    pathname.startsWith('/library') ||
-      pathname.startsWith('/settings') ||
-      pathname.startsWith('/player/') ||
-      pathname.startsWith('/login')
-  );
-  const showBottomUi = $derived(showBottomNav || showGlobalMiniPlayer);
-
   $effect(() => {
     const el = bottomUiEl;
     if (!el) {
@@ -99,26 +83,9 @@
     // Initialize download event listener
     await initDownloadEvents();
 
-    // Prime the downloads store from the DB. The store starts empty each launch,
-    // and download badges (e.g. AlbumDownloadButton) derive purely from it, so
-    // without an initial refresh a previously-downloaded album shows as
-    // not-downloaded until the user opens the Downloads page.
-    const userId = get(auth).user?.id;
-    if (userId) {
-      downloads.refresh(userId).catch((err) =>
-        console.error("Initial downloads refresh failed:", err)
-      );
-    }
-
     // Start sync service for offline mutation queue
     syncService.start();
 
-    // Kick off a best-effort full-catalog pre-sync so the whole server catalog
-    // is browsable (greyed out) offline, and load the last-sync hint for the
-    // offline banner. Non-blocking — no-ops when not connected.
-    void syncCatalog();
-    void refreshSyncStatus();
-
     // Initialize playback mode and session monitoring
     playbackMode.initializeSessionMonitoring();
     await playbackMode.refresh();
@@ -147,8 +114,6 @@
               onServerReconnected: () => {
                 // Retry session verification when server becomes reachable
                 auth.retryVerification();
-                // Resume offline-queued downloads and refresh the catalog.
-                void onCatalogReconnected();
               },
             }).catch((monitorError) => {
               console.error("[Layout] Failed to start connectivity monitoring:", monitorError);
@@ -188,35 +153,13 @@
             {$pendingSyncCount} pending sync{$pendingSyncCount !== 1 ? 's' : ''}
           </span>
         {/if}
-        <button
-          type="button"
-          onclick={() => showServerCatalog.update((v) => !v)}
-          class="ml-1 bg-white/20 hover:bg-white/30 px-2 py-0.5 rounded-full text-xs transition-colors"
-          aria-pressed={$showServerCatalog}
-          title={$lastCatalogSync ? `Catalog last synced ${new Date($lastCatalogSync).toLocaleString()}` : 'Catalog not yet synced'}
-        >
-          {$showServerCatalog ? 'Hide server media' : 'Show all server media'}
-        </button>
       </div>
     {/if}
 
-    <!-- Main content. Routes that own their full-height layout (library,
+    <!-- Main content -->
-         settings, player, login) get a plain clipped box and manage their own
+    <div class="flex-1 overflow-hidden">
-         scrolling internally. All other top-level pages render directly here, so
+      {@render children()}
-         this wrapper must scroll and reserve the fixed bottom UI's measured
+    </div>
-         height so the mini player / bottom nav never overlap the last rows. -->
-    {#if routeOwnsLayout}
-      <div class="flex-1 overflow-hidden">
-        {@render children()}
-      </div>
-    {:else}
-      <div
-        class="flex-1 overflow-y-auto min-h-0"
-        style="padding-bottom: {showBottomUi ? `${$bottomUiHeight}px` : '0'}; overscroll-behavior: contain"
-      >
-        {@render children()}
-      </div>
-    {/if}
 
     <!-- Re-authentication modal -->
     <ReauthModal isOpen={$needsReauth} />

src/routes/library/[id]/+page.svelte

@@ -511,7 +511,7 @@
       <!-- Genre Tags -->
       {#if item.genres?.length}
         <div>
-          <GenreTags genres={item.genres ?? undefined} maxShow={6} itemType={item.type} />
+          <GenreTags genres={item.genres ?? undefined} maxShow={6} />
         </div>
       {/if}