chore: Bump version to 2.8.9-beta

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
refactor: Move audiobook libraries toggle from settings to library menu
2026-01-18 09:37:44 +00:00 · 2026-01-18 09:33:27 +00:00 · 2026-01-18 08:58:31 +00:00 · 2026-01-18 08:36:50 +00:00 · 2026-01-18 07:56:47 +00:00 · 2026-01-17 23:10:15 +00:00
72 changed files with 19315 additions and 3579 deletions
@@ -1,136 +1,257 @@
-# Ensemble Flutter App - Code Audit Report
+# Ensemble Codebase Audit Report

-**Date:** January 4, 2026
-**Branch:** `audit/code-quality-review`
-**Files Audited:** 93 Dart files
+**Date**: 2026-01-14
+**Scope**: Full codebase audit (104 Dart files, 18 screens)
+**Focus Areas**: UI Continuity, Performance, Logic/Best Practices

 ---

 ## Executive Summary

-The codebase is generally well-maintained with good existing performance optimizations (RepaintBoundary, ListView.builder, cacheExtent settings). Key improvement areas identified:
+The Ensemble codebase is a **mature, feature-rich Flutter application** with many good patterns already in place. However, the audit identified **significant architectural debt** that should be addressed:

-| Category | Issues Found | Priority |
-|----------|-------------|----------|
-| Deprecated APIs | 20 instances | HIGH |
-| Missing const constructors | 100+ instances | MEDIUM |
-| Image cache parameters | 7 locations | MEDIUM |
-| Code duplication | 8 view mode functions | LOW |
-| Color constants | 3 files with duplicates | LOW |
+| Severity | Count | Key Themes |
+|----------|-------|------------|
+| **Critical** | 6 | God classes (5,443 & 4,209 lines), design token adoption, startup blocking |
+| **High** | 15 | Touch targets, batch DB operations, over-notification, code duplication |
+| **Medium** | 25+ | Inconsistencies, memory issues, missing error boundaries |
+| **Low** | 15+ | Minor polish items |
+
+**Top 3 Priorities:**
+1. **Split `MusicAssistantProvider` (5,443 lines)** - God object handling everything
+2. **Split `new_library_screen.dart` (4,209 lines)** - 10 scroll controllers, 15+ view modes
+3. **Fix startup performance** - Sequential blocking ops could save 1-8 seconds

 ---

-## 1. CRITICAL: Deprecated API Usage
+## Critical Issues

-### `colorScheme.background` (20 instances)
-Flutter Material 3 deprecates `ColorScheme.background`. Replace with `colorScheme.surface`.
+### 1. God Object: MusicAssistantProvider (5,443 lines)
+**File**: `lib/providers/music_assistant_provider.dart`
+- 54 `notifyListeners()` calls
+- 30+ state variables
+- 100+ public methods
+- Handles: connection, auth, players, library, search, caching, local playback, Sendspin
+- **Fix**: Split into ConnectionManager, PlayerStateManager, LibraryStateManager, SearchStateManager

-**Files affected:**
- lib/main.dart:335, 336
- lib/screens/library_artists_screen.dart:21
- lib/screens/new_home_screen.dart:121
- lib/screens/artist_details_screen.dart:708, 720
- lib/screens/library_playlists_screen.dart:53
- lib/screens/library_tracks_screen.dart:19
- lib/screens/login_screen.dart:489
- lib/screens/new_library_screen.dart:933, 957, 1020, 1021
- lib/screens/album_details_screen.dart:807, 819
- lib/screens/library_albums_screen.dart:19
- lib/screens/search_screen.dart:427, 738, 739
- lib/screens/settings_screen.dart:245
+### 2. God Object: NewLibraryScreen (4,209 lines)
+**File**: `lib/screens/new_library_screen.dart`
+- 10 scroll controllers
+- 15+ view mode states
+- 15+ sort order states
+- Handles: Music, Books, Podcasts, Radio tabs
+- **Fix**: Extract to ArtistsTab, AlbumsTab, TracksTab, PlaylistsTab, BooksTab, PodcastsTab, RadioTab
+
+### 3. Sequential Blocking Startup (500-1500ms wasted)
+**File**: `lib/main.dart:33-66`
+```dart
+await DatabaseService.instance.initialize();
+await ProfileService.instance.migrateFromOwnerName();
+await SettingsService.migrateToSecureStorage();
+await SyncService.instance.loadFromCache();
+audioHandler = await AudioService.init(...);
+```
+- **Fix**: Parallelize with `Future.wait()`, defer AudioService to post-first-frame
+
+### 4. Design Tokens Exist But Unused
+**File**: `lib/theme/design_tokens.dart`
+- `Spacing.*` used in only ~6 of 34+ widget files
+- `Radii.*` used in only ~5 files
+- `IconSizes.*` used in only ~4 files
+- **Fix**: Systematic replacement of hardcoded values
+
+### 5. Touch Targets Too Small (32x32)
+**File**: `lib/screens/new_library_screen.dart:1805-1867`
+- Sort, favorites, view mode buttons are 32x32
+- Material Design minimum: 48x48
+- **Fix**: Increase to 48x48 or add padding for hit area
+
+### 6. No Batch Database Inserts
+**File**: `lib/services/sync_service.dart:212-273`
+- 1000 albums = 1000 separate DB transactions
+- **Fix**: Wrap in single transaction or use Drift batch insert

 ---

-## 2. HIGH: Missing const Constructors
+## High Severity Issues

-### EdgeInsets.zero (64 instances)
-High-impact optimization - used extensively in button padding.
+### Performance
+| Issue | File | Impact |
+|-------|------|--------|
+| `context.watch()` in nested tabs | new_library_screen.dart:2960 | All tabs rebuild on any provider change |
+| Consumer wrapping 800-line player | expandable_player.dart:1234 | Full rebuild on every state change |
+| Inline sorting during build | new_library_screen.dart:3647 | 5-20ms for 1000+ albums |
+| Multiple setState for author images | new_library_screen.dart:1017 | 20+ rebuilds as images load |
+| SecureStorage migration every startup | secure_storage_service.dart:103 | 100-300ms wasted |

-**Key files:**
- lib/screens/album_details_screen.dart (12 instances)
- lib/screens/artist_details_screen.dart (8 instances)
- lib/screens/audiobook_detail_screen.dart (3 instances)
- lib/screens/audiobook_series_screen.dart (2 instances)
- lib/screens/audiobook_author_screen.dart (2 instances)
+### Architecture
+| Issue | File | Impact |
+|-------|------|--------|
+| State duplication across 4 providers | providers/*.dart | Maintenance burden, sync issues |
+| 8 duplicate `_cycle*ViewMode()` methods | new_library_screen.dart:251-402 | DRY violation |
+| 60+ duplicate getter/setter pairs | settings_service.dart:500-1000 | Code bloat |
+| Global singleton NavigationProvider | navigation_provider.dart:40 | Untestable |
+| CacheService duplicated in providers | Multiple | Memory waste, inconsistency |

-### BorderRadius.circular (40+ instances)
-Cannot use `const BorderRadius.circular()` directly. Alternative: `const BorderRadius.all(Radius.circular(X))`.
+### UI/UX
+| Issue | File | Impact |
+|-------|------|--------|
+| Hardcoded bottom spacing (140, 164, 100) | Multiple detail screens | Content obscured by player |
+| Inconsistent button sizes (44 vs 50) | Multiple screens | Visual disharmony |
+| No debounce on card taps | album_card.dart:118 | Double navigation possible |
+| Missing PopScope on AudiobookSeriesScreen | audiobook_series_screen.dart:276 | Adaptive colors not cleared |
+
+### Error Handling
+| Issue | File | Impact |
+|-------|------|--------|
+| No Flutter error boundaries | main.dart | Red error screen on build failure |
+| API returns empty list on error | music_assistant_api.dart | Can't distinguish error from empty |

 ---

-## 3. MEDIUM: Scroll Performance - Missing Image Cache Parameters
+## Medium Severity Issues

-### CachedNetworkImage without memCacheWidth/Height
+### Performance
+- PaletteGenerator on main isolate (10-30ms blocking)
+- Multiple `SharedPreferences.getInstance()` calls (132 occurrences)
+- AppStartup polling loop with fixed 250ms delay
+- SystemThemeHelper FutureBuilder recreated on every build

-**lib/screens/new_library_screen.dart:**
- Line 1395-1402: Author image (48x48) - missing cache params
- Line 1480-1486: Author card image - missing cache params
- Line 1572-1580: Audiobook cover (56x56) - missing cache params
- Line 1740-1745: Audiobook grid cover - missing cache params
- Line 1959-1969: Playlist cover (56x56) - missing cache params
- Line 2143-2152: Playlist grid covers - missing cache params
- Line 2973-2981: Album cover (56x56) - missing cache params
+### UI Consistency
+- Border radius varies: 8, 12, 20, 22, 25 for same element types
+- `SizedBox(height: 8)` appears 40+ times instead of `Spacing.vGap8`
+- Hardcoded colors for status (Colors.red, Colors.green)
+- Inconsistent icon sizes across screens

-**Note:** DecorationImage with CachedNetworkImageProvider cannot have cache size specified (structural Flutter limitation).
+### State Management
+- Over-notification (multiple notifyListeners in single methods)
+- Wide Consumer scope (watch instead of select)
+- Missing dispose() in some providers
+- Inconsistent async state handling (loading/error)
+
+### Navigation
+- `isQueuePanelOpen` vs `isQueuePanelTargetOpen` inconsistency
+- `popToHome()` doesn't clear adaptive colors
+- Infinite navigation loop possible (Album → Artist → Album)
+- Orphaned Hero animations in podcast_card, radio_station_card
+
+### Data/Caching
+- Unbounded `_podcastCoverCache`
+- SyncService listener not removed on error
+- Redundant API calls between providers
+- Fire-and-forget persistence race condition
+
+### Error Handling
+- No zone error handler for async exceptions
+- `retryCritical()` retries all errors including non-recoverable
+- No user notification of offline queue status
+- DisconnectedState not used consistently

 ---

-## 4. LOW: Code Duplication
+## Quick Wins (High Impact, Low Effort)

-### View Mode Cycling Functions (8 nearly identical functions)
-**File:** lib/screens/new_library_screen.dart
-
-Functions that follow identical switch/case pattern:
- `_cycleArtistsViewMode()` (line 184)
- `_cycleAlbumsViewMode()` (line 200)
- `_cyclePlaylistsViewMode()` (line 216)
- `_cycleAuthorsViewMode()` (line 232)
- `_cycleAudiobooksViewMode()` (line 248)
- `_cycleSeriesViewMode()` (line 286)
- `_cycleRadioViewMode()` (line 303)
- `_cyclePodcastsViewMode()` (line 319)
-
-**Recommendation:** Create generic utility function.
-
-### Duplicated Color Constants (3 files)
-Series fallback colors defined identically in:
- lib/widgets/series_row.dart:246-253
- lib/screens/audiobook_series_screen.dart:466-473
- lib/screens/new_library_screen.dart:2112-2119
-
-**Recommendation:** Extract to lib/constants/colors.dart
+| # | Task | File(s) | Effort |
+|---|------|---------|--------|
+| 1 | Replace hardcoded bottom spacing with `BottomSpacing.withMiniPlayer` | Detail screens | 30 min |
+| 2 | Add navigation debounce to card widgets | album_card, artist_card, etc. | 1 hr |
+| 3 | Fix touch targets to 48x48 minimum | new_library_screen.dart | 15 min |
+| 4 | Add migration skip flag for SecureStorage | secure_storage_service.dart | 30 min |
+| 5 | Add Flutter error boundary | main.dart | 30 min |
+| 6 | Use `context.select()` instead of `context.watch()` | global_player_overlay, etc. | 2 hr |
+| 7 | Cache `SharedPreferences.getInstance()` | settings_service.dart | 30 min |

 ---

-## 5. POSITIVE FINDINGS (Already Optimized)
+## Refactoring Roadmap

- **RepaintBoundary**: Properly implemented in all list item widgets
- **ListView.builder**: Used consistently with cacheExtent: 1000
- **ScrollController disposal**: All 8+ controllers properly disposed
- **Animation patterns**: Proper listener cleanup in expandable_player.dart
- **Debounced operations**: Color extraction debounced to 300ms
+### Phase 1: Quick Wins (1-2 days)
+- Fix touch targets
+- Fix bottom spacing
+- Add navigation debounce
+- Add error boundaries
+- Cache SharedPreferences singleton
+
+### Phase 2: Performance (3-5 days)
+- Parallelize startup operations
+- Replace `context.watch()` with `context.select()`
+- Batch database inserts
+- Add SecureStorage migration skip flag
+- Fix over-notification in provider
+
+### Phase 3: Design System (1 week)
+- Systematic design token adoption
+- Standardize button sizes (44 vs 50)
+- Standardize border radius values
+- Create StatusColors semantic tokens
+- Replace all magic numbers
+
+### Phase 4: Architecture (2-3 weeks)
+- ~~Split MusicAssistantProvider into focused managers~~ **DEFERRED** - MusicAssistantProvider has evolved with Sendspin, Cast-Sendspin ID mapping, position tracker integration. Splitting would require ~1600 lines of sync work. Code is working and tested.
+- ~~Split new_library_screen into tab widgets~~ **DEFERRED** - Tabs have tight state coupling (15+ view modes, 15+ sort orders, 10 scroll controllers). Extraction would require InheritedWidget/callbacks for all shared state. Risk outweighs benefit.
+- ✅ Extract generic helpers for SettingsService - Reduced from 1,031 to 874 lines (~15%)
+- ✅ Remove/integrate unused providers - Deleted PlayerProvider (964 lines), LibraryProvider, ConnectionProvider (651 lines total)
+- ~~Split music_assistant_api.dart by domain~~ **DEFERRED** - All methods share WebSocket connection and auth state. Clean extraction would require connection manager abstraction.

 ---

-## Recommended Action Plan
+## Positive Findings

-### Phase 1: Quick Wins (Low Risk)
-1. Replace `colorScheme.background` with `colorScheme.surface` (20 locations)
-2. Add `const` to EdgeInsets.zero instances
+The codebase already demonstrates many good practices:

-### Phase 2: Image Optimization
-1. Add memCacheWidth/memCacheHeight to CachedNetworkImage instances in new_library_screen.dart
-
-### Phase 3: Code Cleanup (Optional)
-1. Extract view mode cycling to utility function
-2. Centralize color constants
+- **Performance awareness**: `// PERF:` comments, RepaintBoundary (55 occurrences), image caching (80 memCacheWidth/Height)
+- **Caching**: Multi-tier caching with LRU eviction, proper TTLs, proper DB indexes
+- **Error handling**: DebugLogger, RetryHelper, OfflineActionQueue well-implemented
+- **Theme system**: Material You support, adaptive colors from album art
+- **Offline support**: Cache-first loading, graceful degradation
+- **Navigation**: Consistent FadeSlidePageRoute, proper Hero animations (mostly)

 ---

-## Files by Complexity
+## Files by Priority

-| File | Lines | Status |
-|------|-------|--------|
-| lib/screens/search_screen.dart | 3,489 | Good structure, minor fixes needed |
-| lib/screens/new_library_screen.dart | 3,351 | Good performance, some duplication |
-| lib/widgets/expandable_player.dart | 2,577 | Well-optimized animations |
+| Priority | File | Lines | Key Issues |
+|----------|------|-------|------------|
+| 1 | music_assistant_provider.dart | 5,443 | God object, over-notification |
+| 2 | new_library_screen.dart | 4,209 | God class, performance, touch targets |
+| 3 | main.dart | 549 | Startup blocking, error boundaries |
+| 4 | music_assistant_api.dart | 3,434 | Silent failures, needs splitting |
+| 5 | settings_service.dart | 1,019 | Code duplication, no caching |
+| 6 | expandable_player.dart | ~800 | Wide Consumer scope |
+| 7 | global_player_overlay.dart | ~500 | BottomSpacing source, Consumer scope |
+| 8 | All detail screens | Various | Hardcoded bottom spacing |
+| 9 | All card widgets | Various | Navigation debounce, design tokens |
+
+---
+
+## Audit Methodology
+
+This audit was conducted using 9 parallel sub-agents analyzing:
+
+**UI Continuity (3 agents)**
+1. Navigation & Flow - back button, Hero animations, tab preservation
+2. Visual Consistency - design tokens, spacing, typography
+3. Component Placement - touch targets, bottom spacing, modals
+
+**Performance (3 agents)**
+4. Rendering Performance - ListView.builder, const, rebuilds
+5. Data & Caching - streams, invalidation, memory bounds
+6. Startup & Load Time - blocking operations, initialization order
+
+**Logic/Best Practices (3 agents)**
+7. State Management - Provider patterns, notification frequency
+8. Error Handling - try-catch, boundaries, resilience
+9. Code Quality - file size, duplication, SOLID principles
+
+---
+
+## Conclusion
+
+The Ensemble app is well-architected at the macro level but has accumulated technical debt in its largest files. The most impactful improvements would be:
+
+1. **Splitting the two 4,000+ line files** into focused components
+2. **Adopting design tokens systematically** for visual consistency
+3. **Optimizing startup sequence** for faster app launch
+4. **Using granular state management** (select vs watch) for better performance
+
+The quick wins section provides immediate value with minimal risk, while the roadmap offers a path to sustainable improvement.
@@ -11,6 +11,7 @@
        android:label="Ensemble"
        android:name="${applicationName}"
        android:icon="@mipmap/ic_launcher"
+        android:appCategory="audio"
        android:usesCleartextTraffic="true"
        android:networkSecurityConfig="@xml/network_security_config">
        <activity
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <background android:drawable="@color/ic_launcher_background"/>
+  <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+</adaptive-icon>
@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
    <color name="launch_background_color">#1a1a1a</color>
-</resources>
+	<color name="ic_launcher_background">#1a1a1a</color>
+</resources>
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-all.zip
@@ -0,0 +1,336 @@
+# Per-Provider Sync Implementation
+
+## Date: January 17, 2026
+
+## Overview
+
+This document details the implementation of per-provider sync with source tracking, enabling instant client-side filtering that properly differentiates between multiple accounts of the same provider type (e.g., two different Spotify accounts).
+
+## Problem Statement
+
+### The Core Issue
+
+When a user has multiple accounts of the same provider type (e.g., two Spotify accounts: "Chris Laycock" and "Bababagoly"), the existing provider filter couldn't differentiate between them.
+
+**Why?** Music Assistant's `provider_mappings` field on media items shows which providers **CAN PLAY** an item, not which provider **ADDED** it. When both Spotify accounts can play the same artist, both appear in `provider_mappings`, making client-side filtering impossible.
+
+### Previous Approach (Failed)
+
+The initial implementation tried to filter client-side using `provider_mappings`:
+
+```dart
+bool isItemAllowedByProviderFilter(MediaItem item) {
+  final mappings = item.providerMappings;
+  for (final mapping in mappings) {
+    if (_providerFilter.contains(mapping.providerInstance)) {
+      return true;
+    }
+  }
+  return false;
+}
+```
+
+**Result:** Both Spotify accounts showed the same items because `provider_mappings` contained both account IDs for shared content.
+
+### Race Condition Issue
+
+Additionally, when rapidly toggling providers, a race condition occurred:
+1. User toggles Provider A off
+2. Sync starts for remaining providers
+3. User toggles Provider B off before sync completes
+4. First sync completes with wrong filter state
+5. UI shows incorrect results
+
+## Solution: Per-Provider Sync with Source Tracking
+
+### Concept
+
+Instead of relying on `provider_mappings`, we:
+1. **Sync each provider separately** using the MA API's `provider` parameter
+2. **Tag each item** with which provider instance(s) returned it
+3. **Store source tracking** in the local database
+4. **Filter client-side** using the source tracking data (instant)
+5. **Background sync** keeps data fresh without blocking UI
+
+### Why This Works
+
+When we call the MA API with `provider: ["spotify--RKnr3jKx"]`, the server returns **only items from that specific account's library**. By syncing each provider separately and remembering which provider returned each item, we can accurately filter.
+
+## Implementation Details
+
+### 1. Database Schema Update
+
+**File:** `lib/database/database.dart`
+
+Added `sourceProviders` column to `LibraryCache` table:
+
+```dart
+class LibraryCache extends Table {
+  // ... existing columns ...
+
+  /// Provider instance IDs that provided this item (JSON array)
+  /// Used for client-side filtering by source provider
+  TextColumn get sourceProviders => text().withDefault(const Constant('[]'))();
+}
+```
+
+**Schema version:** 5 → 6
+
+**Migration:**
+```dart
+if (from < 6) {
+  await customStatement(
+    "ALTER TABLE library_cache ADD COLUMN source_providers TEXT NOT NULL DEFAULT '[]'"
+  );
+}
+```
+
+### 2. Database Service Updates
+
+**File:** `lib/services/database_service.dart`
+
+Added `sourceProvider` parameter to `cacheItem()`:
+
+```dart
+Future<void> cacheItem<T>({
+  required String itemType,
+  required String itemId,
+  required Map<String, dynamic> data,
+  String? sourceProvider,  // NEW: tracks which provider this item came from
+})
+```
+
+Added new method to retrieve items with source tracking:
+
+```dart
+Future<List<(Map<String, dynamic>, List<String>)>> getCachedItemsWithProviders(String itemType)
+```
+
+Returns tuples of `(itemData, sourceProviderIds)`.
+
+### 3. SyncService Rewrite
+
+**File:** `lib/services/sync_service.dart`
+
+#### New Fields
+
+```dart
+// Source provider tracking for client-side filtering
+Map<String, List<String>> _albumSourceProviders = {};
+Map<String, List<String>> _artistSourceProviders = {};
+Map<String, List<String>> _audiobookSourceProviders = {};
+Map<String, List<String>> _playlistSourceProviders = {};
+```
+
+#### Per-Provider Sync Logic
+
+```dart
+Future<void> syncFromApi(MusicAssistantAPI api, {
+  bool force = false,
+  List<String>? providerInstanceIds,
+}) async {
+  // If specific providers are requested, sync each separately
+  if (providerInstanceIds != null && providerInstanceIds.isNotEmpty) {
+    for (final providerId in providerInstanceIds) {
+      // Fetch from this specific provider
+      final results = await Future.wait([
+        api.getAlbums(limit: 1000, providerInstanceIds: [providerId]),
+        api.getArtists(limit: 1000, providerInstanceIds: [providerId]),
+        // ... etc
+      ]);
+
+      // Track source provider for each item
+      for (final album in albums) {
+        albumMap[album.itemId] = album;
+        _albumSourceProviders.putIfAbsent(album.itemId, () => []);
+        if (!_albumSourceProviders[album.itemId]!.contains(providerId)) {
+          _albumSourceProviders[album.itemId]!.add(providerId);
+        }
+      }
+    }
+  }
+}
+```
+
+#### Client-Side Filtering Methods
+
+```dart
+/// Filter albums by source provider (instant, no network)
+List<Album> getAlbumsFilteredByProviders(Set<String> enabledProviderIds) {
+  if (enabledProviderIds.isEmpty || _albumSourceProviders.isEmpty) {
+    return _cachedAlbums;
+  }
+  return _cachedAlbums.where((album) {
+    final sources = _albumSourceProviders[album.itemId];
+    if (sources == null || sources.isEmpty) return true; // No tracking = show
+    return sources.any((s) => enabledProviderIds.contains(s));
+  }).toList();
+}
+
+// Similar methods for artists, audiobooks, playlists
+```
+
+### 4. Library Screen Updates
+
+**File:** `lib/screens/new_library_screen.dart`
+
+#### Hybrid Provider Toggle Handler
+
+```dart
+void _handleProviderToggle(String providerId, bool enabled) {
+  final maProvider = context.read<MusicAssistantProvider>();
+
+  // Instant UI update via global provider toggle
+  maProvider.toggleProviderEnabled(providerId, enabled);
+  setState(() {}); // Rebuild with client-side filtering
+
+  // Background sync after 1.5s debounce
+  _providerFilterDebounce?.cancel();
+  _providerFilterDebounce = Timer(const Duration(milliseconds: 1500), () async {
+    if (mounted) {
+      await maProvider.forceLibrarySync();
+      if (mounted) setState(() {});
+    }
+  });
+}
+```
+
+#### Updated Tab Builders
+
+Artists tab now uses source tracking:
+
+```dart
+Widget _buildArtistsTab(BuildContext context, S l10n) {
+  return Selector<MusicAssistantProvider, (List<Artist>, bool, Set<String>)>(
+    selector: (_, provider) => (
+      provider.artists,
+      provider.isLoading,
+      provider.enabledProviderIds.toSet()
+    ),
+    builder: (context, data, _) {
+      final (allArtists, isLoading, enabledProviders) = data;
+
+      // Client-side filtering using SyncService source tracking
+      final syncService = SyncService.instance;
+      final filteredArtists = syncService.hasSourceTracking && enabledProviders.isNotEmpty
+          ? syncService.getArtistsFilteredByProviders(enabledProviders)
+          : allArtists;
+
+      // ... rest of build
+    },
+  );
+}
+```
+
+Similar updates for albums, playlists, and audiobooks tabs.
+
+### 5. Provider Instance Model
+
+**File:** `lib/models/provider_instance.dart` (new file)
+
+```dart
+class ProviderInstance {
+  final String instanceId;  // e.g., "spotify--abc123"
+  final String domain;      // e.g., "spotify"
+  final String name;        // e.g., "Spotify (John's Account)"
+  final bool available;
+
+  /// Known music provider domains
+  static const Set<String> musicProviderDomains = {
+    'spotify', 'tidal', 'qobuz', 'deezer', 'ytmusic', 'soundcloud',
+    'apple_music', 'amazon_music', 'plex', 'subsonic', 'opensubsonic',
+    'jellyfin', 'emby', 'navidrome', 'audiobookshelf', 'filesystem',
+    'tunein', 'radiobrowser', 'snapcast', 'fully_kiosk',
+  };
+
+  bool get isMusicProvider => musicProviderDomains.contains(domain);
+}
+```
+
+## Data Flow
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                     User Toggles Provider                        │
+└─────────────────────────────────────────────────────────────────┘
+                                │
+                                ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  1. MusicAssistantProvider.toggleProviderEnabled()              │
+│     - Updates enabledProviderIds                                │
+│     - Triggers setState() for instant UI update                 │
+└─────────────────────────────────────────────────────────────────┘
+                                │
+                                ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  2. UI Rebuilds Immediately                                     │
+│     - Selector detects enabledProviderIds change                │
+│     - Calls SyncService.getArtistsFilteredByProviders()         │
+│     - Filters using source tracking (instant, no network)       │
+└─────────────────────────────────────────────────────────────────┘
+                                │
+                                ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  3. Background Sync (after 1.5s debounce)                       │
+│     - forceLibrarySync() called                                 │
+│     - Syncs each enabled provider separately                    │
+│     - Updates source tracking in database                       │
+│     - UI refreshes with fresh data                              │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Files Changed
+
+| File | Changes |
+|------|---------|
+| `lib/database/database.dart` | Added `sourceProviders` column, schema v6, migration |
+| `lib/database/database.g.dart` | Auto-generated from schema changes |
+| `lib/services/database_service.dart` | Added `sourceProvider` param, `getCachedItemsWithProviders()` |
+| `lib/services/sync_service.dart` | Per-provider sync, source tracking maps, filtering methods |
+| `lib/screens/new_library_screen.dart` | Hybrid toggle handler, updated tab builders |
+| `lib/models/provider_instance.dart` | New model for provider instances |
+
+## Testing Checklist
+
+- [ ] Fresh install: First sync should populate source tracking
+- [ ] Toggle single provider: UI updates instantly
+- [ ] Toggle multiple providers rapidly: Debounce prevents race conditions
+- [ ] Two Spotify accounts: Toggling one only shows that account's items
+- [ ] Mixed providers: Toggling Spotify doesn't affect Audiobookshelf items
+- [ ] Legacy cache: Items without source tracking show regardless of filter
+- [ ] Pull to refresh: Refreshes source tracking data
+
+## Known Limitations
+
+1. **First sync required:** Source tracking only works after at least one sync with providers enabled
+2. **Network cost:** Per-provider sync makes N API calls (one per provider) vs. 1 call for all providers
+3. **Items in multiple accounts:** If the same item exists in both Spotify accounts, it will show when either is enabled
+
+## Future Improvements
+
+1. **Incremental sync:** Only sync changed items instead of full library
+2. **Provider-specific cache age:** Different sync intervals per provider
+3. **Offline source tracking:** Persist source tracking independently of full cache
+
+## Branch
+
+All changes are on the `feature/per-provider-sync` branch.
+
+```bash
+git checkout feature/per-provider-sync
+```
+
+## Commit
+
+```
+feat: Add per-provider sync with source tracking for instant filtering
+
+- Add sourceProviders column to database schema (v6) for tracking which
+  provider instance each item came from
+- Update SyncService to sync each enabled provider separately and tag
+  items with their source provider
+- Add client-side filtering methods that use source tracking to properly
+  differentiate between multiple accounts of the same provider type
+- Update library UI to use instant client-side filtering with background
+  sync for data freshness
+```
@@ -0,0 +1,217 @@
+# Provider Filter Implementation Notes
+
+## Overview
+
+This document captures the context and learnings from an attempted implementation of provider filtering in the Ensemble app. The goal was to allow users to filter their library to show only items from a specific music provider (e.g., only one Spotify account when multiple are configured).
+
+## The Problem
+
+Users with multiple music provider accounts (e.g., two Spotify accounts: one personal, one family) want to filter their library view to show only items from one specific account. The Music Assistant (MA) web UI successfully implements this feature.
+
+## What Works vs What Failed
+
+### Works: Different Provider Types
+Filtering between different provider types (e.g., Spotify vs Tidal vs Plex) works correctly. Each provider type has distinct `provider_mappings` entries.
+
+### Failed: Multiple Accounts of Same Provider
+Filtering between multiple Spotify accounts (e.g., `spotify--abc123` vs `spotify--xyz789`) does NOT work correctly. The same library items appear regardless of which Spotify account is selected.
+
+## Root Cause Analysis
+
+### The provider_mappings Problem
+
+MA's `provider_mappings` field on media items does NOT indicate "which account ADDED this item to the library." Instead, it indicates "which providers CAN PLAY this item."
+
+Example: An artist "Ari Mason" that exists ONLY in User A's Spotify library will show provider_mappings containing BOTH Spotify accounts:
+```json
+{
+  "provider_mappings": [
+    {"provider_instance": "spotify--userA_id", "item_id": "..."},
+    {"provider_instance": "spotify--userB_id", "item_id": "..."}
+  ]
+}
+```
+
+This happens because:
+1. MA's internal database stores that the artist exists
+2. MA knows both Spotify accounts CAN play this artist (Spotify has the content)
+3. MA doesn't track WHICH account originally added the item to the library
+
+### MA Web UI Behavior
+
+The MA web UI's provider filter works differently - it appears to use server-side filtering via the `provider` parameter on library_items API calls. When you select a single provider in MA settings, the API returns only items from that provider's library.
+
+## API Investigation
+
+### Server-Side Filtering Parameter
+
+The MA server's `library_items` method accepts a `provider` parameter:
+- Parameter name: `provider` (string or list of strings)
+- Endpoint: `music/{type}/library_items` (e.g., `music/artists/library_items`)
+- Expected behavior: Filter to only return items from the specified provider's library
+
+### What We Tried
+
+1. **Client-side filtering based on provider_mappings**
+   - Result: Failed - all Spotify accounts appear in mappings regardless of which added the item
+
+2. **Server-side filtering with `provider` parameter**
+   - Result: Partially implemented but behavior was inconsistent
+   - The API accepts the parameter but may not filter correctly for same-provider-type accounts
+
+3. **Using `provider_instance_id_or_domain` parameter**
+   - Result: This parameter is for getting specific items by ID, not for filtering library_items
+
+## Code Locations
+
+### Files Modified (in stash)
+
+The implementation attempt is preserved in git stash:
+```bash
+git stash list  # Look for "provider-filter-and-dropdown-work"
+git stash show -p stash@{0}  # View the changes
+```
+
+Key files that were modified:
+
+1. **lib/providers/music_assistant_provider.dart**
+   - `_disabledProviders`: List of disabled provider instance IDs (local app setting)
+   - `selectedProviderForFilter`: Returns single enabled provider for server-side filtering
+   - `toggleProviderEnabled()`: Toggle provider on/off and trigger re-sync
+   - `loadDisabledProviders()`: Load from local settings
+   - `filterByProvider()`: Client-side filtering (enhanced version)
+   - `isItemAllowedByProviderFilter()`: Check if item should be visible
+
+2. **lib/services/music_assistant_api.dart**
+   - Added `provider` parameter to: `getArtists`, `getAlbums`, `getTracks`, `getRandomArtists`, `getRandomAlbums`
+   - Added `MusicProvider` model parsing from `/providers` endpoint
+   - `musicProviders` getter: List of available music providers
+
+3. **lib/services/sync_service.dart**
+   - Added `provider` parameter to `syncFromApi()` and `forceSync()`
+   - Pass provider filter to API calls during sync
+
+4. **lib/services/settings_service.dart**
+   - `getDisabledMusicProviders()`: Get list of disabled provider IDs
+   - `setDisabledMusicProviders()`: Save disabled providers
+   - `toggleProviderEnabled()`: Toggle and persist
+
+5. **lib/screens/settings_screen.dart**
+   - UI for toggling individual providers on/off
+   - Display provider name and instance ID
+
+6. **lib/screens/new_library_screen.dart**
+   - Integration with provider filtering
+
+7. **lib/models/music_provider.dart** (new file)
+   - Model for MA provider instances
+   - Fields: `instanceId`, `domain`, `name`, `available`
+
+## Race Condition Issue
+
+A race condition was identified where:
+1. Initial app sync starts WITHOUT provider filter
+2. User toggles provider filter
+3. `clearCache()` is called
+4. New sync with provider filter tries to start
+5. "Sync already in progress" - new sync is skipped
+6. Result: Old unfiltered data remains
+
+Fix attempted: Reset `_isSyncing = false` in `clearCache()` to allow fresh sync.
+
+## Potential Solutions to Explore
+
+### 1. Investigate MA Server-Side Filtering
+
+The MA server should support filtering by provider. Need to verify:
+- Does the `provider` parameter work for filtering between same-type providers?
+- Is there a different parameter or API endpoint?
+- Check MA source code: https://github.com/music-assistant/server
+
+### 2. Library Sync Per Provider
+
+Instead of syncing all items and filtering, sync each provider's library separately:
+```dart
+for (final provider in enabledProviders) {
+  final items = await api.getAlbums(provider: provider.instanceId);
+  // Store with provider association
+}
+```
+
+### 3. Track Item Origin
+
+Store which provider originally added each item:
+- Modify database schema to track `source_provider`
+- When syncing, record which provider the item came from
+- Filter based on source, not playability
+
+### 4. Use MA's Internal Library State
+
+MA might have internal state about which items are in which provider's library. Investigate:
+- `/music/library/items` endpoint
+- Provider-specific library endpoints
+- MA's database schema for library associations
+
+### 5. Check MA User Settings
+
+The MA web UI's provider filter might be stored in user settings:
+```dart
+final userInfo = await api.getCurrentUserInfo();
+// Check for provider_filter or similar field
+```
+
+## Testing Notes
+
+### Log Messages to Watch
+
+```
+🔌 Selected provider for filter: spotify--xxxxx
+🔍 API getArtists args: {limit: 1000, provider: spotify--xxxxx}
+🔍 API getArtists returned XXX items
+🔌 filterByProvider: XXX → YYY (disabled=[...])
+```
+
+### Test Scenario
+
+1. Configure two Spotify accounts in MA
+2. Add different artists to each account's library
+3. In Ensemble, select only one Spotify account
+4. Verify library shows ONLY that account's items
+5. Switch to other account, verify different items
+
+### Expected vs Actual
+
+- **Expected**: Artist "Ari Mason" (only in Account A) should NOT appear when Account B is selected
+- **Actual**: Artist appears regardless of which account is selected
+
+## MA API Reference
+
+### Get Providers
+```
+Command: providers
+Returns: List of provider instances with type, domain, instanceId, name, available
+```
+
+### Library Items with Filter
+```
+Command: music/artists/library_items
+Args: {
+  limit: int,
+  offset: int,
+  provider: string | list<string>,  // Filter to specific provider(s)
+  album_artists_only: bool,
+  order_by: string
+}
+```
+
+### Relevant MA Source Files
+
+- `music_assistant/server/controllers/music.py` - Library item retrieval
+- `music_assistant/server/models/provider.py` - Provider model
+- `music_assistant/server/providers/` - Individual provider implementations
+
+## Conclusion
+
+The core challenge is that MA's `provider_mappings` indicates playability, not ownership. Server-side filtering via the `provider` parameter should work but needs further investigation to understand why it doesn't differentiate between multiple accounts of the same provider type.
+
+The implementation is preserved in the git stash for future reference. The sorting/dropdown improvements were extracted and committed separately.
@@ -0,0 +1,271 @@
+# Audiobook Provider Filtering Fix
+
+## Date: January 17, 2026 (Continuation)
+
+## Overview
+
+This session focused on fixing provider filtering issues discovered after the initial provider filtering improvements:
+1. Audiobooks were not responding to provider filter changes (browse API ignoring `providerInstanceIds`)
+2. UI not updating instantly when toggling providers (missing `notifyListeners()` call)
+3. Audiobook tabs not rebuilding on provider changes (using `context.read` instead of `Selector`)
+
+---
+
+## Problem Statement
+
+After implementing capability-based provider filtering for the music library, two issues remained:
+
+### Issue 1: Audiobooks Not Filtering During Sync
+
+The bug report showed:
+```
+📊 Source tracking: 252 albums, 87 artists have provider info
+📚 Total audiobooks from browse: 186
+```
+
+- Albums and artists had provider source tracking
+- Audiobooks had NO provider source tracking (not listed)
+- All 186 audiobooks were returned regardless of provider selection
+
+### Issue 2: UI Not Updating Instantly
+
+When toggling providers in the library menu:
+- Music tabs weren't updating immediately
+- Audiobooks required manual pull-to-refresh
+- Changes only appeared after ~600ms (debounce timer)
+
+---
+
+## Root Cause Analysis
+
+### Cause 1: Browse API Ignoring Provider Filter
+
+In `lib/services/music_assistant_api.dart`, when ABS library filtering is enabled, the `getAudiobooks()` function uses the browse API but was **ignoring** the `providerInstanceIds` parameter:
+
+```dart
+// BEFORE: providerInstanceIds was ignored when using browse API
+if (enabledLibraries != null && enabledLibraries.isNotEmpty) {
+  return await _getAudiobooksFromBrowse(enabledLibraries, favoriteOnly: favoriteOnly);
+}
+```
+
+### Cause 2: `notifyListeners()` Called Too Late
+
+In `lib/providers/music_assistant_provider.dart`, the `toggleProviderEnabled()` function only called `notifyListeners()` **inside** the 600ms debounce timer:
+
+```dart
+// BEFORE: notifyListeners only called after 600ms debounce
+_providerFilterDebounceTimer = Timer(const Duration(milliseconds: 600), () {
+  forceLibrarySync();
+  notifyListeners();  // Too late! UI should update immediately
+});
+```
+
+### Cause 3: Audiobook Tabs Not Listening for Changes
+
+The audiobook tabs used `context.read<MusicAssistantProvider>()` which doesn't trigger rebuilds when the provider changes:
+
+```dart
+// BEFORE: context.read doesn't listen for changes
+Widget _buildBooksAuthorsTab(BuildContext context, S l10n) {
+  final maProvider = context.read<MusicAssistantProvider>();
+  final enabledProviders = maProvider.enabledProviderIds.toSet();
+  // ... widget doesn't rebuild when enabledProviders changes
+}
+```
+
+---
+
+## Solutions
+
+### Fix 1: Browse API Provider Filtering
+
+**File:** `lib/services/music_assistant_api.dart` (lines 760-785)
+
+Added logic to filter library paths by provider ID before browsing:
+
+```dart
+if (enabledLibraries != null && enabledLibraries.isNotEmpty) {
+  _logger.log('📚 getAudiobooks: enabledLibraries=$enabledLibraries, providerInstanceIds=$providerInstanceIds');
+
+  // If specific providers are requested, filter libraries to only matching providers
+  // Library paths start with provider ID (e.g., "audiobookshelf--abc123://lb...")
+  var librariesToBrowse = enabledLibraries;
+  if (providerInstanceIds != null && providerInstanceIds.isNotEmpty) {
+    librariesToBrowse = enabledLibraries.where((libPath) {
+      // Extract provider ID from library path (everything before "://")
+      final providerEnd = libPath.indexOf('://');
+      if (providerEnd == -1) return false;
+      final providerId = libPath.substring(0, providerEnd);
+      return providerInstanceIds.contains(providerId);
+    }).toList();
+
+    // If no libraries match the requested providers, return empty
+    if (librariesToBrowse.isEmpty) {
+      return [];
+    }
+  }
+  return await _getAudiobooksFromBrowse(librariesToBrowse, favoriteOnly: favoriteOnly);
+}
+```
+
+### Fix 2: Immediate `notifyListeners()` Call
+
+**File:** `lib/providers/music_assistant_provider.dart` (line 1149)
+
+Moved `notifyListeners()` to fire immediately after `_enabledProviderIds` changes:
+
+```dart
+// Reload the enabled providers
+final savedEnabled = await SettingsService.getEnabledMusicProviders();
+_enabledProviderIds = savedEnabled ?? [];
+
+// Notify listeners IMMEDIATELY so UI rebuilds with client-side filtering
+// This enables instant UI updates using cached data with source tracking
+notifyListeners();
+
+// Cancel any pending debounce timer
+_providerFilterDebounceTimer?.cancel();
+
+// Start debounced sync - waits 600ms for user to finish toggling
+// This refreshes the cache with new data from enabled providers
+_providerFilterDebounceTimer = Timer(const Duration(milliseconds: 600), () {
+  _logger.log('🔄 Debounce complete, starting library sync...');
+  forceLibrarySync();
+});
+```
+
+### Fix 3: Audiobook Tabs Use Selector
+
+**File:** `lib/screens/new_library_screen.dart`
+
+Wrapped `_buildBooksAuthorsTab` and `_buildAllBooksTab` in `Selector` to rebuild when `enabledProviderIds` changes:
+
+```dart
+Widget _buildBooksAuthorsTab(BuildContext context, S l10n) {
+  // Use Selector to rebuild when enabledProviderIds changes
+  return Selector<MusicAssistantProvider, Set<String>>(
+    selector: (_, provider) => provider.enabledProviderIds.toSet(),
+    builder: (context, enabledProviders, _) {
+      final syncService = SyncService.instance;
+
+      // Client-side filtering using SyncService source tracking for instant updates
+      var audiobooks = syncService.hasSourceTracking && enabledProviders.isNotEmpty
+          ? syncService.getAudiobooksFilteredByProviders(enabledProviders)
+          : List<Audiobook>.from(_audiobooks);
+
+      // ... rest of widget
+    },
+  );
+}
+```
+
+### Fix 4: Enhanced Sync Logging
+
+**File:** `lib/services/sync_service.dart`
+
+Added audiobook counts to logging:
+
+```dart
+// Per-provider log (line 237)
+_logger.log('  📥 Got ${albums.length} albums, ${artists.length} artists, ${audiobooks.length} audiobooks from $providerId');
+
+// Source tracking summary (line 323)
+_logger.log('📊 Source tracking: ${_albumSourceProviders.length} albums, ${_artistSourceProviders.length} artists, ${_audiobookSourceProviders.length} audiobooks have provider info');
+```
+
+---
+
+## Data Flow After Fixes
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    User Toggles Provider                         │
+│                                                                  │
+│   1. toggleProviderEnabled() called                             │
+│   2. _enabledProviderIds updated                                │
+│   3. notifyListeners() called IMMEDIATELY                       │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                    Selectors Detect Change                       │
+│                                                                  │
+│   Music tabs: Selector<..., (List, bool, Set<String>)>         │
+│   Audiobook tabs: Selector<..., Set<String>>                    │
+│                                                                  │
+│   → All tabs rebuild immediately                                 │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                Client-Side Filtering (Instant)                   │
+│                                                                  │
+│   syncService.getAlbumsFilteredByProviders(enabledProviders)    │
+│   syncService.getArtistsFilteredByProviders(enabledProviders)   │
+│   syncService.getAudiobooksFilteredByProviders(enabledProviders)│
+│                                                                  │
+│   → Uses EXISTING cache with source tracking                    │
+│   → Instant UI update, no network required                      │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│              Background Sync (After 600ms Debounce)              │
+│                                                                  │
+│   - Refreshes cache with new data from enabled providers        │
+│   - Updates source tracking                                      │
+│   - Only needed when ENABLING providers (to fetch new data)     │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Files Changed
+
+| File | Changes |
+|------|---------|
+| `lib/services/music_assistant_api.dart` | Added provider filtering to browse API path in `getAudiobooks()`, added debug logging |
+| `lib/services/sync_service.dart` | Added audiobook counts to per-provider and summary logs |
+| `lib/providers/music_assistant_provider.dart` | Moved `notifyListeners()` to fire immediately on provider toggle |
+| `lib/screens/new_library_screen.dart` | Wrapped audiobook tabs in `Selector` to rebuild on provider changes |
+
+---
+
+## Expected Behavior After Fixes
+
+1. **Instant UI Updates:** When you toggle a provider, the library immediately updates using client-side filtering
+2. **Audiobook Source Tracking:** Audiobooks now have provider source tracking (visible in logs)
+3. **Audiobook Tab Rebuilds:** Both audiobook tabs (Authors and All Books) rebuild instantly on provider toggle
+4. **Music Tab Consistency:** Music tabs continue to work as before, now with immediate rebuilds
+
+---
+
+## Testing Checklist
+
+- [ ] Toggle a music provider, verify instant UI update (no 600ms delay)
+- [ ] Toggle between different Spotify accounts, verify correct filtering
+- [ ] Sync with ABS library filtering enabled
+- [ ] Verify audiobooks appear in source tracking log
+- [ ] Toggle ABS provider off in library menu
+- [ ] Verify audiobooks list becomes empty immediately (no pull-to-refresh needed)
+- [ ] Toggle ABS provider back on
+- [ ] Verify audiobooks reappear after sync completes
+- [ ] Test with multiple providers (Spotify audiobooks + ABS)
+
+---
+
+## Related Documentation
+
+- `docs/SESSION_2026_01_17_PROVIDER_FILTERING.md` - Initial provider filtering implementation
+- `docs/PER_PROVIDER_SYNC_IMPLEMENTATION.md` - Per-provider sync architecture
+
+---
+
+## Known Limitations
+
+1. **Series Tab:** The Series tab still doesn't filter by provider. Series are fetched as `AudiobookSeries` objects without per-provider tracking.
+
+2. **Mixed Provider Scenario:** If user has both Spotify audiobooks and ABS audiobooks, and ABS library filtering is enabled, Spotify audiobooks may not be fetched because the browse API path is taken. This is a pre-existing architectural limitation.
+
+3. **Enabling Providers:** When ENABLING a previously disabled provider, the UI updates immediately but shows empty until the background sync completes (because the cache doesn't have that provider's data yet). This is expected behavior.
@@ -0,0 +1,217 @@
+# Session 2026-01-17: Optimistic Updates & Podcast Provider Filtering
+
+## Overview
+
+This session focused on fixing provider filtering for podcasts, resolving iTunes podcast provider issues, and implementing optimistic updates for library buttons across detail screens.
+
+## Issues Addressed
+
+### 1. Podcast Provider Counts Showing Incorrectly
+
+**Problem**: All Spotify accounts showed the same podcast count instead of only counting podcasts owned by each account.
+
+**Root Cause**: The podcast counting logic wasn't checking the `inLibrary` field on provider mappings.
+
+**Solution**:
+- Added `inLibrary` field to `ProviderMapping` model
+- Updated `getProvidersWithPodcasts()` to only count mappings where `inLibrary == true`
+- Updated podcast filtering in library screen to check `inLibrary` field
+
+**Files Modified**:
+- `lib/models/media_item.dart` - Added `inLibrary` field
+- `lib/providers/music_assistant_provider.dart` - Updated counting logic
+- `lib/screens/new_library_screen.dart` - Updated filtering logic
+
+### 2. iTunes Podcasts Not Appearing in Library
+
+**Problem**: Podcasts added from iTunes search weren't showing in library and iTunes provider filter showed 0 count.
+
+**Investigation**:
+- Added `itunes_podcasts` to provider capabilities and music provider domains
+- Added synthetic provider instance creation for search-only providers
+- Added debug logging to understand podcast loading
+
+**Resolution**: The issue was with Music Assistant's iTunes podcast provider itself - podcasts added via iTunes weren't being properly stored in the MA library. The user removed the iTunes provider from MA and re-added podcasts via Spotify search as a workaround.
+
+**Files Modified**:
+- `lib/models/provider_instance.dart` - Added `itunes_podcasts` to capabilities
+
+### 3. Episode Loading Failing for Non-Library Podcasts
+
+**Problem**: When a podcast was removed from library, the old library ID became invalid and episodes wouldn't load.
+
+**Solution**: Added fallback logic to try loading episodes via provider mappings when the primary ID fails.
+
+**Files Modified**:
+- `lib/screens/podcast_detail_screen.dart` - Added fallback episode loading
+
+### 4. Search Filtering Rework
+
+**Problem**: Server-side provider filtering was being applied to search results when it should only apply when the "in library" toggle is enabled.
+
+**Solution**:
+- Removed `filterSearchResults()` calls from search methods
+- Added client-side `_filterByEnabledProviders()` helper
+- Applied filtering only when `_libraryOnly` toggle is ON
+
+**Files Modified**:
+- `lib/providers/music_assistant_provider.dart` - Removed filterSearchResults calls
+- `lib/screens/search_screen.dart` - Added client-side filtering
+
+### 5. Library Buttons Not Updating Immediately
+
+**Problem**: Add/remove library buttons on detail screens waited for API response before updating, causing perceived lag.
+
+**Solution**: Implemented optimistic updates - update UI immediately, revert on failure.
+
+**Files Modified**:
+- `lib/screens/podcast_detail_screen.dart`
+- `lib/screens/album_details_screen.dart`
+- `lib/screens/artist_details_screen.dart`
+
+## Code Changes
+
+### ProviderMapping.inLibrary Field
+
+```dart
+// lib/models/media_item.dart
+class ProviderMapping {
+  final String itemId;
+  final String providerDomain;
+  final String providerInstance;
+  final bool available;
+  final Map<String, dynamic>? audioFormat;
+  final bool inLibrary;  // NEW: indicates ownership
+
+  factory ProviderMapping.fromJson(Map<String, dynamic> json) {
+    return ProviderMapping(
+      // ... other fields ...
+      inLibrary: json['in_library'] == true || json['in_library'] == 1,
+    );
+  }
+}
+```
+
+### Podcast Provider Counting
+
+```dart
+// lib/providers/music_assistant_provider.dart
+Map<String, int> getProvidersWithPodcasts() {
+  final counts = <String, int>{};
+  for (final item in _podcasts) {
+    final mappings = item.providerMappings;
+    if (mappings != null) {
+      for (final mapping in mappings) {
+        // Only count if this provider "owns" the item
+        if (mapping.inLibrary) {
+          final instanceId = mapping.providerInstance;
+          if (instanceId.isNotEmpty) {
+            counts[instanceId] = (counts[instanceId] ?? 0) + 1;
+          }
+        }
+      }
+    }
+  }
+  return counts;
+}
+```
+
+### Optimistic Update Pattern
+
+```dart
+// Example from podcast_detail_screen.dart
+Future<void> _toggleLibrary() async {
+  final newState = !_isInLibrary;
+
+  // OPTIMISTIC UPDATE: Update UI immediately
+  setState(() {
+    _isInLibrary = newState;
+  });
+
+  if (mounted) {
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(content: Text(S.of(context)!.addedToLibrary)),
+    );
+  }
+
+  // Fire and forget - API call happens in background
+  maProvider.addToLibrary(...).catchError((e) {
+    // Revert on failure
+    if (mounted) {
+      setState(() {
+        _isInLibrary = !newState;
+      });
+    }
+  });
+}
+```
+
+### Client-Side Search Filtering
+
+```dart
+// lib/screens/search_screen.dart
+Map<String, List<MediaItem>> _filterByEnabledProviders(
+  Map<String, List<MediaItem>> results,
+  Set<String> enabledProviders,
+) {
+  if (enabledProviders.isEmpty) return results;
+
+  bool isItemAllowed(MediaItem item) {
+    final mappings = item.providerMappings;
+    if (mappings == null || mappings.isEmpty) return true;
+    return mappings.any((m) => m.inLibrary && enabledProviders.contains(m.providerInstance));
+  }
+
+  return {
+    for (final entry in results.entries)
+      entry.key: entry.value.where(isItemAllowed).toList(),
+  };
+}
+
+// Applied when setting results:
+if (_libraryOnly) {
+  final enabledProviders = provider.enabledProviderIds.toSet();
+  combinedResults = _filterByEnabledProviders(combinedResults, enabledProviders);
+}
+```
+
+## Provider Capabilities Update
+
+```dart
+// lib/models/provider_instance.dart
+static const Map<String, Set<String>> providerCapabilities = {
+  'spotify': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks', 'podcasts'},
+  'ytmusic': {'artists', 'albums', 'tracks', 'playlists', 'podcasts'},
+  'apple_music': {'artists', 'albums', 'tracks', 'playlists', 'podcasts'},
+  'plex': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks', 'podcasts'},
+  'jellyfin': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks', 'podcasts'},
+  'emby': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks', 'podcasts'},
+  'audiobookshelf': {'audiobooks', 'podcasts'},
+  'itunes_podcasts': {'podcasts'},  // NEW
+  'tunein': {'radio', 'podcasts'},
+  // ... other providers
+};
+```
+
+## Summary of All Modified Files
+
+| File | Changes |
+|------|---------|
+| `lib/models/media_item.dart` | Added `inLibrary` field to ProviderMapping |
+| `lib/models/provider_instance.dart` | Added `itunes_podcasts`, podcasts to capabilities |
+| `lib/providers/music_assistant_provider.dart` | Updated podcast counting, removed filterSearchResults |
+| `lib/screens/new_library_screen.dart` | Updated podcast filtering with inLibrary check |
+| `lib/screens/search_screen.dart` | Added client-side filtering for in-library mode |
+| `lib/screens/podcast_detail_screen.dart` | Optimistic updates, fallback episode loading |
+| `lib/screens/album_details_screen.dart` | Optimistic updates for library button |
+| `lib/screens/artist_details_screen.dart` | Optimistic updates for library button |
+
+## Key Learnings
+
+1. **inLibrary field**: Music Assistant's provider mappings include an `in_library` field that indicates whether the user added the item from that specific provider account. This is essential for accurate per-provider filtering.
+
+2. **iTunes podcast provider**: The MA iTunes podcast provider is for search only - it doesn't properly store items in the library. Users should add podcasts from streaming providers like Spotify instead.
+
+3. **Optimistic updates**: For better UX, library toggle buttons should update immediately and only revert if the API call fails, rather than waiting for API response.
+
+4. **Search vs Library filtering**: Server-side provider filtering should only apply to library views, not search results (unless the "in library" toggle is enabled).
@@ -0,0 +1,263 @@
+# Provider Filtering Improvements
+
+## Date: January 17, 2026
+
+## Overview
+
+This session focused on improving the provider filtering system across the app, building on the per-provider sync implementation. Key improvements include a cleaner capability-based architecture, fixing filter visibility bugs, and extending filtering to the audiobooks library.
+
+---
+
+## Changes Made
+
+### 1. Provider Capability Mapping
+
+**File:** `lib/models/provider_instance.dart`
+
+Replaced the clunky item-count-based filtering with a static capability map that defines what content types each provider domain supports.
+
+```dart
+static const Map<String, Set<String>> providerCapabilities = {
+  // Music streaming services
+  'spotify': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks'},
+  'tidal': {'artists', 'albums', 'tracks', 'playlists'},
+  'qobuz': {'artists', 'albums', 'tracks', 'playlists'},
+  'deezer': {'artists', 'albums', 'tracks', 'playlists'},
+  'ytmusic': {'artists', 'albums', 'tracks', 'playlists'},
+  'soundcloud': {'artists', 'albums', 'tracks', 'playlists'},
+  'apple_music': {'artists', 'albums', 'tracks', 'playlists'},
+  'amazon_music': {'artists', 'albums', 'tracks', 'playlists'},
+
+  // Self-hosted media servers (can have music and audiobooks)
+  'plex': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks'},
+  'jellyfin': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks'},
+  'emby': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks'},
+
+  // Music-only servers
+  'subsonic': {'artists', 'albums', 'tracks', 'playlists'},
+  'opensubsonic': {'artists', 'albums', 'tracks', 'playlists'},
+  'navidrome': {'artists', 'albums', 'tracks', 'playlists'},
+  'filesystem': {'artists', 'albums', 'tracks', 'playlists'},
+
+  // Audiobook-only providers
+  'audiobookshelf': {'audiobooks'},
+
+  // Radio providers
+  'tunein': {'radio'},
+  'radiobrowser': {'radio'},
+
+  // Player/system providers (no library content)
+  'snapcast': <String>{},
+  'fully_kiosk': <String>{},
+};
+```
+
+**Added helper methods:**
+```dart
+Set<String> get supportedContentTypes => providerCapabilities[domain] ?? <String>{};
+bool supportsContentType(String category) => supportedContentTypes.contains(category);
+```
+
+**Benefits:**
+- Radio providers never show in Artists tab (by design, not by count)
+- Works immediately, even with empty libraries
+- Disabled providers still show in menu (if they support the content type)
+- Clean separation of concerns
+
+---
+
+### 2. Updated Provider Filtering in MusicAssistantProvider
+
+**File:** `lib/providers/music_assistant_provider.dart`
+
+Updated `getRelevantProvidersForCategory()` to filter by capability:
+
+```dart
+List<(ProviderInstance, int)> getRelevantProvidersForCategory(String category) {
+  // ... get counts ...
+
+  final result = <(ProviderInstance, int)>[];
+  for (final provider in _availableMusicProviders) {
+    // Only include providers that support this content type
+    if (provider.supportsContentType(category)) {
+      final count = counts[provider.instanceId] ?? 0;
+      result.add((provider, count));
+    }
+  }
+  // ...
+}
+```
+
+---
+
+### 3. Simplified Library Menu Provider Filter
+
+**File:** `lib/screens/new_library_screen.dart`
+
+Simplified the options menu overlay to show all providers that support the current category:
+
+**Before (clunky):**
+```dart
+if (widget.relevantProviders.where((p) {
+  final hasItems = p.$2 > 0;
+  final isDisabledByUser = widget.enabledProviderIds.isNotEmpty &&
+      !widget.enabledProviderIds.contains(p.$1.instanceId);
+  return hasItems || isDisabledByUser;
+}).length > 1) ...[
+```
+
+**After (clean):**
+```dart
+// relevantProviders is pre-filtered by capability
+if (widget.relevantProviders.length > 1) ...[
+  // Show all providers that support this category
+  ...widget.relevantProviders.map((providerData) {
+```
+
+---
+
+### 4. Removed Provider Toggles from Settings Screen
+
+**File:** `lib/screens/settings_screen.dart`
+
+Removed the "Music Providers" section entirely since provider filtering is now handled in the library menu:
+
+- Removed `_providerEnabled` state variable
+- Removed provider loading code from `_loadSettings()`
+- Removed the entire Music Providers UI section (~100 lines)
+
+**Rationale:** Single source of truth - provider toggles now only appear in the library menu where they're contextually relevant.
+
+---
+
+### 5. Fixed Audiobooks Library Provider Filtering
+
+**File:** `lib/screens/new_library_screen.dart`
+
+The audiobooks tabs were not filtering by provider - they loaded data once and displayed it without responding to provider changes.
+
+**Fixed `_buildBooksAuthorsTab()`:**
+```dart
+final syncService = SyncService.instance;
+final enabledProviders = maProvider.enabledProviderIds.toSet();
+
+// Client-side filtering using SyncService source tracking
+var audiobooks = syncService.hasSourceTracking && enabledProviders.isNotEmpty
+    ? syncService.getAudiobooksFilteredByProviders(enabledProviders)
+    : List<Audiobook>.from(_audiobooks);
+
+// Filter by favorites if enabled
+if (_showFavoritesOnly) {
+  audiobooks = audiobooks.where((a) => a.favorite == true).toList();
+}
+
+// Group filtered audiobooks by author (dynamic, not cached)
+final groupedByAuthor = <String, List<Audiobook>>{};
+for (final book in audiobooks) {
+  final authorName = book.authorsString;
+  groupedByAuthor.putIfAbsent(authorName, () => []).add(book);
+}
+```
+
+**Fixed `_buildAllBooksTab()`:**
+- Same provider filtering pattern
+- Dynamic sorting after filtering
+- Updated PageStorageKey to include provider count for proper rebuild
+
+---
+
+## Bug Fixes
+
+### Provider Filter Menu Disappearing
+
+**Problem:** When providers were deselected, the background sync would clear the cache and only fetch data for enabled providers. Disabled providers then had 0 items, and the menu required `> 1 providers WITH items` to show. The entire Providers section would disappear.
+
+**Solution:** Changed to capability-based filtering. The menu now shows all providers that support the category, regardless of item count.
+
+### Audiobooks Not Filtering by Provider
+
+**Problem:** Audiobooks tabs loaded data once into `_audiobooks` and displayed it without provider filtering. Toggling providers in the menu had no effect.
+
+**Solution:** Added inline provider filtering during build (same pattern as music tabs).
+
+---
+
+## Files Changed
+
+| File | Changes |
+|------|---------|
+| `lib/models/provider_instance.dart` | Added `providerCapabilities` map and helper methods |
+| `lib/providers/music_assistant_provider.dart` | Updated `getRelevantProvidersForCategory()` to filter by capability |
+| `lib/screens/new_library_screen.dart` | Simplified menu filter logic, added audiobook provider filtering |
+| `lib/screens/settings_screen.dart` | Removed Music Providers section |
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    Provider Capability Map                       │
+│         (ProviderInstance.providerCapabilities)                  │
+│                                                                  │
+│   spotify → {artists, albums, tracks, playlists, audiobooks}    │
+│   audiobookshelf → {audiobooks}                                 │
+│   tunein → {radio}                                              │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│            getRelevantProvidersForCategory(category)             │
+│                                                                  │
+│   - Filters _availableMusicProviders by capability              │
+│   - Returns only providers that support the category            │
+│   - Includes item counts for display                            │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                    Library Menu (Options)                        │
+│                                                                  │
+│   - Shows providers section if > 1 providers support category   │
+│   - All relevant providers shown (can toggle on/off)            │
+│   - Instant UI update via setState()                            │
+│   - Background sync after 1.5s debounce                         │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                   Tab Build Methods                              │
+│                                                                  │
+│   - Get enabledProviderIds from MusicAssistantProvider          │
+│   - Filter data using SyncService source tracking               │
+│   - Display filtered results                                    │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Known Limitations
+
+1. **Series Tab:** The Series tab in audiobooks doesn't filter by provider yet. Series are fetched separately as `AudiobookSeries` objects and don't have the same source tracking as individual audiobooks.
+
+2. **First Sync Required:** Source tracking only works after at least one sync with providers enabled.
+
+---
+
+## Testing Checklist
+
+- [x] Music tabs filter by provider correctly
+- [x] Provider menu shows only relevant providers per category
+- [x] Radio providers don't appear in Artists/Albums tabs
+- [x] Spotify appears in Audiobooks tab (has audiobooks)
+- [x] Audiobooks Authors tab filters by provider
+- [x] Audiobooks All Books tab filters by provider
+- [ ] Audiobooks Series tab filters by provider (not implemented)
+- [x] Disabled providers can be re-enabled from menu
+- [x] Settings screen no longer has provider toggles
+
+---
+
+## Related Documentation
+
+- `docs/PER_PROVIDER_SYNC_IMPLEMENTATION.md` - Original per-provider sync implementation
@@ -31,6 +31,9 @@ class Timings {
  /// Search debounce delay
  static const Duration searchDebounce = Duration(milliseconds: 500);

+  /// Navigation debounce to prevent double-tap navigation
+  static const Duration navigationDebounce = Duration(milliseconds: 500);
+
  /// Delay after track change before updating state
  static const Duration trackChangeDelay = Duration(milliseconds: 500);
 }
@@ -78,6 +78,10 @@ class LibraryCache extends Table {
  /// Whether this item was deleted on the server
  BoolColumn get isDeleted => boolean().withDefault(const Constant(false))();

+  /// Provider instance IDs that provided this item (JSON array)
+  /// Used for client-side filtering by source provider
+  TextColumn get sourceProviders => text().withDefault(const Constant('[]'))();
+
  @override
  Set<Column> get primaryKey => {cacheKey};
 }
@@ -191,7 +195,7 @@ class AppDatabase extends _$AppDatabase {
  AppDatabase([QueryExecutor? executor]) : super(executor ?? _openConnection());

  @override
-  int get schemaVersion => 5;
+  int get schemaVersion => 6;

  @override
  MigrationStrategy get migration {
@@ -226,6 +230,10 @@ class AppDatabase extends _$AppDatabase {
          await customStatement('CREATE INDEX IF NOT EXISTS idx_cached_queue_player ON cached_queue (player_id)');
          await customStatement('CREATE INDEX IF NOT EXISTS idx_cached_queue_player_position ON cached_queue (player_id, position)');
        }
+        // Migration from v5 to v6: Add source_providers column for client-side filtering
+        if (from < 6) {
+          await customStatement("ALTER TABLE library_cache ADD COLUMN source_providers TEXT NOT NULL DEFAULT '[]'");
+        }
      },
    );
  }
@@ -368,20 +376,57 @@ class AppDatabase extends _$AppDatabase {
  // ============================================

  /// Cache a library item
+  /// [sourceProvider] - the provider instance ID that provided this item (for filtering)
  Future<void> cacheItem({
    required String itemType,
    required String itemId,
    required String data,
+    String? sourceProvider,
  }) async {
    final cacheKey = '${itemType}_$itemId';

-    await into(libraryCache).insertOnConflictUpdate(LibraryCacheCompanion.insert(
-      cacheKey: cacheKey,
-      itemType: itemType,
-      itemId: itemId,
-      data: data,
-      lastSynced: DateTime.now(),
-    ));
+    // If sourceProvider is specified, we need to merge with existing providers
+    if (sourceProvider != null) {
+      final existing = await getCachedItem(itemType, itemId);
+      List<String> providers = [];
+      if (existing != null) {
+        try {
+          final existingProviders = existing.sourceProviders;
+          if (existingProviders.isNotEmpty && existingProviders != '[]') {
+            providers = List<String>.from(
+              (await Future.value(existingProviders))
+                  .replaceAll('[', '')
+                  .replaceAll(']', '')
+                  .replaceAll('"', '')
+                  .split(',')
+                  .where((s) => s.trim().isNotEmpty)
+                  .map((s) => s.trim()),
+            );
+          }
+        } catch (_) {}
+      }
+      if (!providers.contains(sourceProvider)) {
+        providers.add(sourceProvider);
+      }
+      final sourceProvidersJson = '[${providers.map((p) => '"$p"').join(',')}]';
+
+      await into(libraryCache).insertOnConflictUpdate(LibraryCacheCompanion.insert(
+        cacheKey: cacheKey,
+        itemType: itemType,
+        itemId: itemId,
+        data: data,
+        lastSynced: DateTime.now(),
+        sourceProviders: Value(sourceProvidersJson),
+      ));
+    } else {
+      await into(libraryCache).insertOnConflictUpdate(LibraryCacheCompanion.insert(
+        cacheKey: cacheKey,
+        itemType: itemType,
+        itemId: itemId,
+        data: data,
+        lastSynced: DateTime.now(),
+      ));
+    }
  }

  /// Get cached items by type
@@ -1140,6 +1140,10 @@
  "audiobookLibraries": "Audiobook Libraries",
  "chooseAudiobookLibraries": "Choose which Audiobookshelf libraries to include",
  "unknownLibrary": "Unknown Library",
+  "musicProviders": "Music Providers",
+  "musicProvidersDescription": "Choose which accounts to show in your library",
+  "libraryRefreshing": "Refreshing library...",
+  "cannotDisableLastProvider": "Cannot disable the last provider",
  "noSeriesFound": "No Series Found",
  "ensembleBugReport": "Ensemble Bug Report",
  "byOwner": "By {owner}",
@@ -1401,5 +1405,193 @@
        "type": "String"
      }
    }
+  },
+
+  "noTracks": "No tracks",
+  "@noTracks": {
+    "description": "Empty state title when no tracks exist in library"
+  },
+
+  "addTracksHint": "Add some music to your library to see tracks here",
+  "@addTracksHint": {
+    "description": "Hint for adding tracks to library"
+  },
+
+  "noFavoriteRadioStations": "No favorite radio stations",
+  "@noFavoriteRadioStations": {
+    "description": "Empty state when no favorite radio stations"
+  },
+
+  "longPressRadioHint": "Long-press a station and tap the heart to add it to favorites",
+  "@longPressRadioHint": {
+    "description": "Hint for favoriting radio stations"
+  },
+
+  "noFavoritePodcasts": "No favorite podcasts",
+  "@noFavoritePodcasts": {
+    "description": "Empty state when no favorite podcasts"
+  },
+
+  "longPressPodcastHint": "Long-press a podcast and tap the heart to add it to favorites",
+  "@longPressPodcastHint": {
+    "description": "Hint for favoriting podcasts"
+  },
+
+  "failedToPlayRadioStation": "Failed to play radio station: {error}",
+  "@failedToPlayRadioStation": {
+    "description": "Error when playing radio station fails",
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+
+  "itemAlreadyInLibrary": "Item is already in library",
+  "@itemAlreadyInLibrary": {
+    "description": "Message when trying to add item already in library"
+  },
+
+  "failedToAddToLibrary": "Failed to add to library",
+  "@failedToAddToLibrary": {
+    "description": "Error when adding to library fails"
+  },
+
+  "cannotFindLibraryId": "Cannot find library ID for removal",
+  "@cannotFindLibraryId": {
+    "description": "Error when library ID not found for removal"
+  },
+
+  "failedToRemoveFromLibrary": "Failed to remove from library",
+  "@failedToRemoveFromLibrary": {
+    "description": "Error when removing from library fails"
+  },
+
+  "failedToPlayAlbum": "Failed to play album: {error}",
+  "@failedToPlayAlbum": {
+    "description": "Error when playing album fails",
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+
+  "playingOnPlayer": "Playing {name} on {playerName}",
+  "@playingOnPlayer": {
+    "description": "Status when playing item on specific player",
+    "placeholders": {
+      "name": {
+        "type": "String"
+      },
+      "playerName": {
+        "type": "String"
+      }
+    }
+  },
+
+  "failedToPlayPlaylist": "Failed to play playlist: {error}",
+  "@failedToPlayPlaylist": {
+    "description": "Error when playing playlist fails",
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+
+  "failedToPlayAudiobook": "Failed to play audiobook: {error}",
+  "@failedToPlayAudiobook": {
+    "description": "Error when playing audiobook fails",
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+
+  "noOtherPlayersAvailable": "No other players available",
+  "@noOtherPlayersAvailable": {
+    "description": "Message when no other players available for transfer"
+  },
+
+  "transferQueue": "Transfer queue",
+  "@transferQueue": {
+    "description": "Tooltip for transfer queue button"
+  },
+
+  "clearQueue": "Clear queue",
+  "@clearQueue": {
+    "description": "Tooltip for clear queue button"
+  },
+
+  "syncingPlayer": "Syncing {playerName}...",
+  "@syncingPlayer": {
+    "description": "Status when syncing player",
+    "placeholders": {
+      "playerName": {
+        "type": "String"
+      }
+    }
+  },
+
+  "switchPlayer": "Switch Player",
+  "@switchPlayer": {
+    "description": "Label for switch player action"
+  },
+
+  "logsCopiedToClipboard": "Logs copied to clipboard",
+  "@logsCopiedToClipboard": {
+    "description": "Confirmation when logs copied"
+  },
+
+  "auto": "Auto",
+  "@auto": {
+    "description": "Auto option for language selection"
+  },
+
+  "transferQueueTo": "Transfer Queue To",
+  "@transferQueueTo": {
+    "description": "Title for transfer queue dialog"
+  },
+
+  "queueTransferredTo": "Queue transferred to {playerName}",
+  "@queueTransferredTo": {
+    "description": "Success message when queue transferred",
+    "placeholders": {
+      "playerName": {
+        "type": "String"
+      }
+    }
+  },
+
+  "failedToTransferQueue": "Failed to transfer queue: {error}",
+  "@failedToTransferQueue": {
+    "description": "Error when queue transfer fails",
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+
+  "failedToLoadQueue": "Failed to load queue: {error}",
+  "@failedToLoadQueue": {
+    "description": "Error when queue loading fails",
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+
+  "transferTo": "Transfer to...",
+  "@transferTo": {
+    "description": "Label for transfer destination selection"
+  },
+
+  "transferQueueToPlayer": "Transfer queue to another player",
+  "@transferQueueToPlayer": {
+    "description": "Tooltip for transfer queue button"
  }
 }
@@ -1,4 +1,5 @@
 import 'dart:async';
+import 'dart:ui';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:provider/provider.dart';
@@ -33,6 +34,10 @@ final _logger = DebugLogger();
 Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();

+  // Initialize SharedPreferences cache early for performance
+  await SettingsService.initialize();
+  _logger.log('⚡ SharedPreferences cached');
+
  // Initialize local database
  await DatabaseService.instance.initialize();
  _logger.log('💾 Database initialized');
@@ -84,7 +89,29 @@ Future<void> main() async {
    ),
  );

-  runApp(const MusicAssistantApp());
+  // Set up Flutter error boundary to catch and log widget build errors
+  FlutterError.onError = (FlutterErrorDetails details) {
+    _logger.error('Flutter error: ${details.exceptionAsString()}', context: 'FlutterError');
+    _logger.error('Stack trace:\n${details.stack}', context: 'FlutterError');
+    // Still report to Flutter's default handler in debug mode
+    FlutterError.presentError(details);
+  };
+
+  // Catch errors from the platform dispatcher (platform channel errors)
+  PlatformDispatcher.instance.onError = (error, stack) {
+    _logger.error('Platform error: $error', context: 'PlatformDispatcher');
+    _logger.error('Stack trace:\n$stack', context: 'PlatformDispatcher');
+    return true; // Handled
+  };
+
+  // Wrap app in zone to catch async errors
+  runZonedGuarded(
+    () => runApp(const MusicAssistantApp()),
+    (error, stackTrace) {
+      _logger.error('Uncaught async error: $error', context: 'ZoneError');
+      _logger.error('Stack trace:\n$stackTrace', context: 'ZoneError');
+    },
+  );
 }

 class MusicAssistantApp extends StatefulWidget {
@@ -16,6 +16,10 @@ class ProviderMapping {
  final String providerInstance;
  final bool available;
  final Map<String, dynamic>? audioFormat;
+  /// Whether this item is in the library for this specific provider instance.
+  /// True = this provider "owns" the item (user added it from this account)
+  /// False = item exists but wasn't added from this provider
+  final bool inLibrary;

  ProviderMapping({
    required this.itemId,
@@ -23,6 +27,7 @@ class ProviderMapping {
    required this.providerInstance,
    required this.available,
    this.audioFormat,
+    this.inLibrary = true,
  });

  factory ProviderMapping.fromJson(Map<String, dynamic> json) {
@@ -32,6 +37,8 @@ class ProviderMapping {
      providerInstance: json['provider_instance'] as String? ?? '',
      available: json['available'] as bool? ?? true,
      audioFormat: json['audio_format'] as Map<String, dynamic>?,
+      // Parse in_library field - MA uses 1/0 or true/false
+      inLibrary: json['in_library'] == true || json['in_library'] == 1,
    );
  }

@@ -42,6 +49,7 @@ class ProviderMapping {
      'provider_instance': providerInstance,
      'available': available,
      if (audioFormat != null) 'audio_format': audioFormat,
+      'in_library': inLibrary,
    };
  }
 }
@@ -0,0 +1,128 @@
+/// Represents a music provider instance from Music Assistant.
+///
+/// Each provider (like Spotify, Tidal) can have multiple instances
+/// (e.g., two different Spotify accounts). This class represents
+/// a single provider instance with its unique ID.
+class ProviderInstance {
+  /// Unique identifier for this provider instance (e.g., "spotify--abc123")
+  final String instanceId;
+
+  /// The provider domain/type (e.g., "spotify", "tidal", "qobuz")
+  final String domain;
+
+  /// Display name for this instance (e.g., "Spotify (John's Account)")
+  final String name;
+
+  /// Whether this provider is currently available/connected
+  final bool available;
+
+  ProviderInstance({
+    required this.instanceId,
+    required this.domain,
+    required this.name,
+    required this.available,
+  });
+
+  /// Provider capabilities - maps domain to supported content types
+  /// This determines which tabs/categories show which providers
+  static const Map<String, Set<String>> providerCapabilities = {
+    // Music streaming services (support artists, albums, tracks, playlists)
+    // Spotify also has audiobooks and podcasts
+    'spotify': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks', 'podcasts'},
+    'tidal': {'artists', 'albums', 'tracks', 'playlists'},
+    'qobuz': {'artists', 'albums', 'tracks', 'playlists'},
+    'deezer': {'artists', 'albums', 'tracks', 'playlists'},
+    'ytmusic': {'artists', 'albums', 'tracks', 'playlists', 'podcasts'},
+    'soundcloud': {'artists', 'albums', 'tracks', 'playlists'},
+    'apple_music': {'artists', 'albums', 'tracks', 'playlists', 'podcasts'},
+    'amazon_music': {'artists', 'albums', 'tracks', 'playlists'},
+    // Self-hosted media servers (can have music, audiobooks, and podcasts)
+    'plex': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks', 'podcasts'},
+    'jellyfin': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks', 'podcasts'},
+    'emby': {'artists', 'albums', 'tracks', 'playlists', 'audiobooks', 'podcasts'},
+    // Music-only servers
+    'subsonic': {'artists', 'albums', 'tracks', 'playlists'},
+    'opensubsonic': {'artists', 'albums', 'tracks', 'playlists'},
+    'navidrome': {'artists', 'albums', 'tracks', 'playlists'},
+    'filesystem': {'artists', 'albums', 'tracks', 'playlists'},
+    // Audiobook and podcast providers
+    'audiobookshelf': {'audiobooks', 'podcasts'},
+    'itunes_podcasts': {'podcasts'},
+    // Radio providers (tunein also has podcasts)
+    'tunein': {'radio', 'podcasts'},
+    'radiobrowser': {'radio'},
+    // Player/system providers (no library content)
+    'snapcast': <String>{},
+    'fully_kiosk': <String>{},
+  };
+
+  /// Known music provider domains that provide library content
+  static const Set<String> musicProviderDomains = {
+    // Streaming services
+    'spotify',
+    'tidal',
+    'qobuz',
+    'deezer',
+    'ytmusic',
+    'soundcloud',
+    'apple_music',
+    'amazon_music',
+    // Self-hosted / local
+    'plex',
+    'subsonic',
+    'opensubsonic',
+    'jellyfin',
+    'emby',
+    'navidrome',
+    'audiobookshelf',
+    'filesystem',
+    'itunes_podcasts',
+    // Other
+    'tunein',
+    'radiobrowser',
+    'snapcast',
+    'fully_kiosk',
+  };
+
+  /// Whether this is a music provider (vs. player provider, metadata provider, etc.)
+  bool get isMusicProvider => musicProviderDomains.contains(domain);
+
+  /// Get supported content types for this provider
+  Set<String> get supportedContentTypes =>
+      providerCapabilities[domain] ?? <String>{};
+
+  /// Check if this provider supports a specific content type/category
+  bool supportsContentType(String category) =>
+      supportedContentTypes.contains(category);
+
+  factory ProviderInstance.fromJson(Map<String, dynamic> json) {
+    return ProviderInstance(
+      instanceId: json['instance_id'] as String? ?? '',
+      domain: json['domain'] as String? ?? json['type'] as String? ?? '',
+      name: json['name'] as String? ?? json['instance_id'] as String? ?? 'Unknown',
+      available: json['available'] as bool? ?? true,
+    );
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      'instance_id': instanceId,
+      'domain': domain,
+      'name': name,
+      'available': available,
+    };
+  }
+
+  @override
+  String toString() => 'ProviderInstance($instanceId: $name)';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ProviderInstance &&
+          runtimeType == other.runtimeType &&
+          instanceId == other.instanceId;
+
+  @override
+  int get hashCode => instanceId.hashCode;
+}
@@ -1,258 +0,0 @@
-import 'dart:async';
-import 'package:flutter/foundation.dart';
-import '../services/music_assistant_api.dart';
-import '../services/settings_service.dart';
-import '../services/database_service.dart';
-import '../services/profile_service.dart';
-import '../services/debug_logger.dart';
-import '../services/error_handler.dart';
-import '../services/auth/auth_manager.dart';
-import '../services/cache_service.dart';
-
-/// Provider for managing connection state to Music Assistant server
-/// Handles WebSocket connection, authentication, and reconnection
-class ConnectionProvider with ChangeNotifier {
-  MusicAssistantAPI? _api;
-  final AuthManager _authManager = AuthManager();
-  final DebugLogger _logger = DebugLogger();
-  final CacheService _cacheService = CacheService();
-
-  MAConnectionState _connectionState = MAConnectionState.disconnected;
-  String? _serverUrl;
-  String? _error;
-
-  // Callbacks for post-connection initialization
-  VoidCallback? onConnected;
-  VoidCallback? onAuthenticated;
-  VoidCallback? onDisconnected;
-
-  MAConnectionState get connectionState => _connectionState;
-  String? get serverUrl => _serverUrl;
-  String? get error => _error;
-  bool get isConnected => _connectionState == MAConnectionState.connected ||
-                          _connectionState == MAConnectionState.authenticated;
-
-  MusicAssistantAPI? get api => _api;
-  AuthManager get authManager => _authManager;
-  CacheService get cacheService => _cacheService;
-
-  ConnectionProvider() {
-    _initialize();
-  }
-
-  Future<void> _initialize() async {
-    _serverUrl = await SettingsService.getServerUrl();
-    if (_serverUrl != null && _serverUrl!.isNotEmpty) {
-      await _restoreAuthCredentials();
-      await connectToServer(_serverUrl!);
-    }
-  }
-
-  /// Restore auth credentials from persistent storage
-  Future<void> _restoreAuthCredentials() async {
-    final savedCredentials = await SettingsService.getAuthCredentials();
-    if (savedCredentials != null) {
-      _logger.log('🔐 Restoring saved auth credentials...');
-      _authManager.deserializeCredentials(savedCredentials);
-      _logger.log('🔐 Auth credentials restored: ${_authManager.currentStrategy?.name ?? "none"}');
-    } else {
-      _logger.log('🔐 No saved auth credentials found');
-    }
-  }
-
-  /// Handle Music Assistant native authentication after WebSocket connection
-  Future<bool> handleMaAuthentication() async {
-    if (_api == null) return false;
-
-    try {
-      // First, try stored MA token
-      final storedToken = await SettingsService.getMaAuthToken();
-      if (storedToken != null) {
-        _logger.log('🔐 Trying stored MA token...');
-        final success = await _api!.authenticateWithToken(storedToken);
-        if (success) {
-          _logger.log('✅ MA authentication with stored token successful');
-          await _fetchAndSetUserProfileName();
-          return true;
-        }
-        _logger.log('⚠️ Stored MA token invalid, clearing...');
-        await SettingsService.clearMaAuthToken();
-      }
-
-      // No valid token - try stored credentials
-      final username = await SettingsService.getUsername();
-      final password = await SettingsService.getPassword();
-
-      if (username != null && password != null && username.isNotEmpty && password.isNotEmpty) {
-        _logger.log('🔐 Trying stored credentials...');
-        final accessToken = await _api!.loginWithCredentials(username, password);
-
-        if (accessToken != null) {
-          _logger.log('✅ MA login with stored credentials successful');
-
-          final longLivedToken = await _api!.createLongLivedToken();
-          if (longLivedToken != null) {
-            await SettingsService.setMaAuthToken(longLivedToken);
-            _logger.log('✅ Saved new long-lived MA token');
-          } else {
-            await SettingsService.setMaAuthToken(accessToken);
-          }
-
-          await _fetchAndSetUserProfileName();
-          return true;
-        }
-      }
-
-      _logger.log('❌ MA authentication failed - no valid token or credentials');
-      return false;
-    } catch (e) {
-      _logger.log('❌ MA authentication error: $e');
-      return false;
-    }
-  }
-
-  /// Fetch user profile from MA and set owner name + create/activate local profile
-  Future<void> _fetchAndSetUserProfileName() async {
-    if (_api == null) return;
-
-    try {
-      final userInfo = await _api!.getCurrentUserInfo();
-      if (userInfo == null) {
-        _logger.log('⚠️ Could not fetch user profile');
-        return;
-      }
-
-      final displayName = userInfo['display_name'] as String?;
-      final username = userInfo['username'] as String?;
-
-      _logger.log('🔍 Profile data: display_name="$displayName", username="$username"');
-
-      final profileName = (displayName != null && displayName.isNotEmpty)
-          ? displayName
-          : username;
-
-      if (profileName != null && profileName.isNotEmpty) {
-        await SettingsService.setOwnerName(profileName);
-        _logger.log('✅ Set owner name from MA profile: $profileName');
-
-        // Create/activate profile in local database
-        if (DatabaseService.instance.isInitialized && username != null) {
-          await ProfileService.instance.onMaAuthenticated(
-            username: username,
-            displayName: displayName,
-          );
-          _logger.log('✅ Local profile activated: $username');
-        }
-      } else {
-        _logger.log('⚠️ No valid name in profile');
-      }
-    } catch (e) {
-      _logger.log('⚠️ Could not fetch user profile (non-fatal): $e');
-    }
-  }
-
-  Future<void> connectToServer(String serverUrl) async {
-    try {
-      _error = null;
-      _serverUrl = serverUrl;
-      await SettingsService.setServerUrl(serverUrl);
-
-      // Disconnect existing connection
-      await _api?.disconnect();
-
-      _api = MusicAssistantAPI(serverUrl, _authManager);
-
-      // Listen to connection state changes
-      _api!.connectionState.listen(
-        (state) async {
-          _connectionState = state;
-          notifyListeners();
-
-          if (state == MAConnectionState.connected) {
-            _logger.log('🔗 WebSocket connected to MA server');
-
-            if (_api!.authRequired && !_api!.isAuthenticated) {
-              _logger.log('🔐 MA auth required, attempting authentication...');
-              final authenticated = await handleMaAuthentication();
-              if (!authenticated) {
-                _logger.log('❌ MA authentication failed - stopping connection flow');
-                _error = 'Authentication required. Please log in again.';
-                notifyListeners();
-                return;
-              }
-              return;
-            }
-
-            // No auth required - notify connected
-            onConnected?.call();
-          } else if (state == MAConnectionState.authenticated) {
-            _logger.log('✅ MA authentication successful');
-            onAuthenticated?.call();
-          } else if (state == MAConnectionState.disconnected) {
-            // DON'T clear caches on disconnect - keep showing cached data
-            // This allows instant UI display when app resumes or reconnects
-            // Caches will be refreshed when connection is restored
-            onDisconnected?.call();
-          }
-        },
-        onError: (error) {
-          _logger.log('Connection state stream error: $error');
-          _connectionState = MAConnectionState.error;
-          notifyListeners();
-        },
-      );
-
-      await _api!.connect();
-      notifyListeners();
-    } catch (e) {
-      final errorInfo = ErrorHandler.handleError(e, context: 'Connect to server');
-      _error = errorInfo.userMessage;
-      _connectionState = MAConnectionState.error;
-      _logger.log('Connection error: ${errorInfo.technicalMessage}');
-      notifyListeners();
-      rethrow;
-    }
-  }
-
-  Future<void> disconnect() async {
-    await _api?.disconnect();
-    _connectionState = MAConnectionState.disconnected;
-    // DON'T clear caches on disconnect - keep showing cached data for instant reconnect
-    notifyListeners();
-  }
-
-  /// Clear all caches and state (for logout or server change)
-  void clearCachesOnLogout() {
-    _cacheService.clearAll();
-    notifyListeners();
-  }
-
-  /// Check connection and reconnect if needed (called when app resumes)
-  Future<void> checkAndReconnect() async {
-    _logger.log('🔄 checkAndReconnect called - state: $_connectionState');
-
-    if (_serverUrl == null) {
-      _logger.log('🔄 No server URL saved, skipping reconnect');
-      return;
-    }
-
-    if (_connectionState != MAConnectionState.connected &&
-        _connectionState != MAConnectionState.authenticated) {
-      _logger.log('🔄 Not connected, attempting reconnect to $_serverUrl');
-      try {
-        await connectToServer(_serverUrl!);
-        _logger.log('🔄 Reconnection successful');
-      } catch (e) {
-        _logger.log('🔄 Reconnection failed: $e');
-      }
-    } else {
-      _logger.log('🔄 Already connected, connection verified');
-    }
-  }
-
-  @override
-  void dispose() {
-    _api?.dispose();
-    super.dispose();
-  }
-}
@@ -1,392 +0,0 @@
-import 'package:flutter/foundation.dart';
-import '../models/media_item.dart';
-import '../services/music_assistant_api.dart';
-import '../services/debug_logger.dart';
-import '../services/error_handler.dart';
-import '../services/cache_service.dart';
-import '../services/settings_service.dart';
-import '../constants/timings.dart';
-
-/// Provider for managing library data (artists, albums, tracks, playlists)
-class LibraryProvider with ChangeNotifier {
-  final DebugLogger _logger = DebugLogger();
-  final CacheService _cacheService;
-
-  MusicAssistantAPI? _api;
-
-  List<Artist> _artists = [];
-  List<Album> _albums = [];
-  List<Track> _tracks = [];
-  bool _isLoading = false;
-  String? _error;
-
-  // Search state persistence
-  String _lastSearchQuery = '';
-  Map<String, List<MediaItem>> _lastSearchResults = {
-    'artists': [],
-    'albums': [],
-    'tracks': [],
-  };
-
-  // Getters
-  List<Artist> get artists => _artists;
-  List<Album> get albums => _albums;
-  List<Track> get tracks => _tracks;
-  bool get isLoading => _isLoading;
-  String? get error => _error;
-  String get lastSearchQuery => _lastSearchQuery;
-  Map<String, List<MediaItem>> get lastSearchResults => _lastSearchResults;
-
-  LibraryProvider(this._cacheService);
-
-  /// Initialize with API reference after connection
-  void initialize(MusicAssistantAPI api) {
-    _api = api;
-  }
-
-  void saveSearchState(String query, Map<String, List<MediaItem>> results) {
-    _lastSearchQuery = query;
-    _lastSearchResults = results;
-  }
-
-  void clearSearchState() {
-    _lastSearchQuery = '';
-    _lastSearchResults = {
-      'artists': [],
-      'albums': [],
-      'tracks': [],
-    };
-  }
-
-  // ============================================================================
-  // HOME SCREEN DATA
-  // ============================================================================
-
-  /// Get recently played albums with caching
-  Future<List<Album>> getRecentAlbumsWithCache({bool forceRefresh = false}) async {
-    if (_cacheService.isRecentAlbumsCacheValid(forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached recent albums');
-      return _cacheService.getCachedRecentAlbums()!;
-    }
-
-    if (_api == null) return _cacheService.getCachedRecentAlbums() ?? [];
-
-    try {
-      _logger.log('🔄 Fetching fresh recent albums...');
-      final albums = await _api!.getRecentAlbums(limit: LibraryConstants.defaultRecentLimit);
-      _cacheService.setCachedRecentAlbums(albums);
-      return albums;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch recent albums: $e');
-      return _cacheService.getCachedRecentAlbums() ?? [];
-    }
-  }
-
-  /// Get discover artists (random) with caching
-  Future<List<Artist>> getDiscoverArtistsWithCache({bool forceRefresh = false}) async {
-    if (_cacheService.isDiscoverArtistsCacheValid(forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached discover artists');
-      return _cacheService.getCachedDiscoverArtists()!;
-    }
-
-    if (_api == null) return _cacheService.getCachedDiscoverArtists() ?? [];
-
-    try {
-      _logger.log('🔄 Fetching fresh discover artists...');
-      final artists = await _api!.getRandomArtists(limit: LibraryConstants.defaultRecentLimit);
-      _cacheService.setCachedDiscoverArtists(artists);
-      return artists;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch discover artists: $e');
-      return _cacheService.getCachedDiscoverArtists() ?? [];
-    }
-  }
-
-  /// Get discover albums (random) with caching
-  Future<List<Album>> getDiscoverAlbumsWithCache({bool forceRefresh = false}) async {
-    if (_cacheService.isDiscoverAlbumsCacheValid(forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached discover albums');
-      return _cacheService.getCachedDiscoverAlbums()!;
-    }
-
-    if (_api == null) return _cacheService.getCachedDiscoverAlbums() ?? [];
-
-    try {
-      _logger.log('🔄 Fetching fresh discover albums...');
-      final albums = await _api!.getRandomAlbums(limit: LibraryConstants.defaultRecentLimit);
-      _cacheService.setCachedDiscoverAlbums(albums);
-      return albums;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch discover albums: $e');
-      return _cacheService.getCachedDiscoverAlbums() ?? [];
-    }
-  }
-
-  /// Invalidate home screen cache (call on pull-to-refresh)
-  void invalidateHomeCache() {
-    _cacheService.invalidateHomeCache();
-  }
-
-  // ============================================================================
-  // LIBRARY DATA
-  // ============================================================================
-
-  Future<void> loadLibrary() async {
-    if (_api == null) return;
-
-    try {
-      _isLoading = true;
-      _error = null;
-      notifyListeners();
-
-      // Read artist filter setting - when ON, only fetch artists that have albums
-      final showOnlyArtistsWithAlbums = await SettingsService.getShowOnlyArtistsWithAlbums();
-      _logger.log('🎨 loadLibrary using albumArtistsOnly: $showOnlyArtistsWithAlbums');
-
-      final results = await Future.wait([
-        _api!.getArtists(limit: LibraryConstants.maxLibraryItems, albumArtistsOnly: showOnlyArtistsWithAlbums),
-        _api!.getAlbums(limit: LibraryConstants.maxLibraryItems),
-        _api!.getTracks(limit: LibraryConstants.maxLibraryItems),
-      ]);
-
-      _artists = results[0] as List<Artist>;
-      _albums = results[1] as List<Album>;
-      _tracks = results[2] as List<Track>;
-
-      _isLoading = false;
-      notifyListeners();
-    } catch (e) {
-      final errorInfo = ErrorHandler.handleError(e, context: 'Load library');
-      _error = errorInfo.userMessage;
-      _isLoading = false;
-      notifyListeners();
-    }
-  }
-
-  Future<void> loadArtists({int? limit, int? offset, String? search}) async {
-    if (_api == null) return;
-
-    try {
-      _isLoading = true;
-      _error = null;
-      notifyListeners();
-
-      // Read artist filter setting - when ON, only fetch artists that have albums
-      final showOnlyArtistsWithAlbums = await SettingsService.getShowOnlyArtistsWithAlbums();
-
-      _artists = await _api!.getArtists(
-        limit: limit ?? LibraryConstants.maxLibraryItems,
-        offset: offset,
-        search: search,
-        albumArtistsOnly: showOnlyArtistsWithAlbums,
-      );
-
-      _isLoading = false;
-      notifyListeners();
-    } catch (e) {
-      final errorInfo = ErrorHandler.handleError(e, context: 'Load artists');
-      _error = errorInfo.userMessage;
-      _isLoading = false;
-      notifyListeners();
-    }
-  }
-
-  Future<void> loadAlbums({int? limit, int? offset, String? search, String? artistId}) async {
-    if (_api == null) return;
-
-    try {
-      _isLoading = true;
-      _error = null;
-      notifyListeners();
-
-      _albums = await _api!.getAlbums(
-        limit: limit ?? LibraryConstants.maxLibraryItems,
-        offset: offset,
-        search: search,
-        artistId: artistId,
-      );
-
-      _isLoading = false;
-      notifyListeners();
-    } catch (e) {
-      final errorInfo = ErrorHandler.handleError(e, context: 'Load albums');
-      _error = errorInfo.userMessage;
-      _isLoading = false;
-      notifyListeners();
-    }
-  }
-
-  // ============================================================================
-  // DETAIL SCREEN DATA
-  // ============================================================================
-
-  /// Get album tracks with caching
-  Future<List<Track>> getAlbumTracksWithCache(String provider, String itemId, {bool forceRefresh = false}) async {
-    final cacheKey = '${provider}_$itemId';
-
-    if (_cacheService.isAlbumTracksCacheValid(cacheKey, forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached album tracks for $cacheKey');
-      return _cacheService.getCachedAlbumTracks(cacheKey)!;
-    }
-
-    if (_api == null) return _cacheService.getCachedAlbumTracks(cacheKey) ?? [];
-
-    try {
-      _logger.log('🔄 Fetching fresh album tracks for $cacheKey...');
-      final tracks = await _api!.getAlbumTracks(provider, itemId);
-      _cacheService.setCachedAlbumTracks(cacheKey, tracks);
-      return tracks;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch album tracks: $e');
-      return _cacheService.getCachedAlbumTracks(cacheKey) ?? [];
-    }
-  }
-
-  /// Get playlist tracks with caching
-  Future<List<Track>> getPlaylistTracksWithCache(String provider, String itemId, {bool forceRefresh = false}) async {
-    final cacheKey = '${provider}_$itemId';
-
-    if (_cacheService.isPlaylistTracksCacheValid(cacheKey, forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached playlist tracks for $cacheKey');
-      return _cacheService.getCachedPlaylistTracks(cacheKey)!;
-    }
-
-    if (_api == null) return _cacheService.getCachedPlaylistTracks(cacheKey) ?? [];
-
-    try {
-      _logger.log('🔄 Fetching fresh playlist tracks for $cacheKey...');
-      final tracks = await _api!.getPlaylistTracks(provider, itemId);
-      _cacheService.setCachedPlaylistTracks(cacheKey, tracks);
-      return tracks;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch playlist tracks: $e');
-      return _cacheService.getCachedPlaylistTracks(cacheKey) ?? [];
-    }
-  }
-
-  /// Get artist albums with caching
-  Future<List<Album>> getArtistAlbumsWithCache(String artistName, {bool forceRefresh = false}) async {
-    final cacheKey = artistName.toLowerCase();
-
-    if (_cacheService.isArtistAlbumsCacheValid(cacheKey, forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached artist albums for "$artistName"');
-      return _cacheService.getCachedArtistAlbums(cacheKey)!;
-    }
-
-    if (_api == null) return _cacheService.getCachedArtistAlbums(cacheKey) ?? [];
-
-    try {
-      _logger.log('🔄 Fetching albums for artist "$artistName"...');
-
-      final libraryAlbums = await _api!.getAlbums();
-      final artistAlbums = libraryAlbums.where((album) {
-        final albumArtists = album.artists;
-        if (albumArtists == null || albumArtists.isEmpty) return false;
-        return albumArtists.any((a) => a.name.toLowerCase() == artistName.toLowerCase());
-      }).toList();
-
-      final searchResults = await _api!.search(artistName);
-      final searchAlbums = searchResults['albums'] as List<MediaItem>? ?? [];
-      final providerAlbums = searchAlbums.whereType<Album>().where((album) {
-        final albumArtists = album.artists;
-        if (albumArtists == null || albumArtists.isEmpty) return false;
-        return albumArtists.any((a) => a.name.toLowerCase() == artistName.toLowerCase());
-      }).toList();
-
-      final allAlbums = <Album>[];
-      final seenNames = <String>{};
-
-      for (final album in [...artistAlbums, ...providerAlbums]) {
-        final key = album.name.toLowerCase();
-        if (!seenNames.contains(key)) {
-          seenNames.add(key);
-          allAlbums.add(album);
-        }
-      }
-
-      _cacheService.setCachedArtistAlbums(cacheKey, allAlbums);
-      return allAlbums;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch artist albums: $e');
-      return _cacheService.getCachedArtistAlbums(cacheKey) ?? [];
-    }
-  }
-
-  /// Invalidate album tracks cache
-  void invalidateAlbumTracksCache(String albumId) {
-    _cacheService.invalidateAlbumTracksCache(albumId);
-  }
-
-  /// Invalidate playlist tracks cache
-  void invalidatePlaylistTracksCache(String playlistId) {
-    _cacheService.invalidatePlaylistTracksCache(playlistId);
-  }
-
-  // ============================================================================
-  // SEARCH
-  // ============================================================================
-
-  /// Search with caching
-  Future<Map<String, List<MediaItem>>> searchWithCache(String query, {bool forceRefresh = false}) async {
-    final cacheKey = query.toLowerCase().trim();
-    if (cacheKey.isEmpty) return {'artists': [], 'albums': [], 'tracks': []};
-
-    if (_cacheService.isSearchCacheValid(cacheKey, forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached search results for "$query"');
-      return _cacheService.getCachedSearchResults(cacheKey)!;
-    }
-
-    if (_api == null) {
-      return _cacheService.getCachedSearchResults(cacheKey) ?? {'artists': [], 'albums': [], 'tracks': []};
-    }
-
-    try {
-      _logger.log('🔄 Searching for "$query"...');
-      final results = await _api!.search(query);
-
-      final cachedResults = <String, List<MediaItem>>{
-        'artists': results['artists'] ?? [],
-        'albums': results['albums'] ?? [],
-        'tracks': results['tracks'] ?? [],
-      };
-
-      _cacheService.setCachedSearchResults(cacheKey, cachedResults);
-      return cachedResults;
-    } catch (e) {
-      _logger.log('❌ Search failed: $e');
-      return _cacheService.getCachedSearchResults(cacheKey) ?? {'artists': [], 'albums': [], 'tracks': []};
-    }
-  }
-
-  Future<Map<String, List<MediaItem>>> search(String query, {bool libraryOnly = false}) async {
-    if (_api == null) return {'artists': [], 'albums': [], 'tracks': []};
-
-    try {
-      return await _api!.search(query, libraryOnly: libraryOnly);
-    } catch (e) {
-      ErrorHandler.logError('Search', e);
-      return {'artists': [], 'albums': [], 'tracks': []};
-    }
-  }
-
-  Future<List<Track>> getAlbumTracks(String provider, String itemId) async {
-    if (_api == null) return [];
-
-    try {
-      return await _api!.getAlbumTracks(provider, itemId);
-    } catch (e) {
-      ErrorHandler.logError('Get album tracks', e);
-      return [];
-    }
-  }
-
-  void clearState() {
-    _artists = [];
-    _albums = [];
-    _tracks = [];
-    _isLoading = false;
-    _error = null;
-    clearSearchState();
-    notifyListeners();
-  }
-}
@@ -7,6 +7,7 @@ import 'package:cached_network_image/cached_network_image.dart';
 import 'package:flutter_volume_controller/flutter_volume_controller.dart';
 import '../models/media_item.dart';
 import '../models/player.dart';
+import '../models/provider_instance.dart';
 import '../services/music_assistant_api.dart';
 import '../services/settings_service.dart';
 import '../services/debug_logger.dart';
@@ -114,6 +115,13 @@ class MusicAssistantProvider with ChangeNotifier {
  // Empty list means all players are allowed
  List<String> _playerFilter = [];

+  // User-controlled music provider filter (local settings in Ensemble)
+  // Empty list means all providers are enabled (no filtering)
+  List<String> _enabledProviderIds = [];
+
+  // Available music providers discovered from MA
+  List<ProviderInstance> _availableMusicProviders = [];
+
  // ============================================================================
  // GETTERS
  // ============================================================================
@@ -134,6 +142,8 @@ class MusicAssistantProvider with ChangeNotifier {
  // Raw unfiltered access (for internal use only)
  List<Artist> get artistsUnfiltered => _artists;
  List<Album> get albumsUnfiltered => _albums;
+  List<MediaItem> get podcastsUnfiltered => _podcasts;
+  List<MediaItem> get radioStationsUnfiltered => _radioStations;
  bool get isLoading => _isLoading;
  bool get isLoadingRadio => _isLoadingRadio;
  bool get isLoadingPodcasts => _isLoadingPodcasts;
@@ -204,6 +214,210 @@ class MusicAssistantProvider with ChangeNotifier {
    return players.where(isPlayerAllowedByFilter).toList();
  }

+  // ============================================================================
+  // USER-CONTROLLED MUSIC PROVIDER FILTER
+  // ============================================================================
+
+  /// List of available music providers from MA
+  List<ProviderInstance> get availableMusicProviders => _availableMusicProviders;
+
+  /// List of enabled provider instance IDs (empty = all enabled)
+  List<String> get enabledProviderIds => _enabledProviderIds;
+
+  /// Whether user has enabled specific providers (not all)
+  bool get hasUserProviderFilter => _enabledProviderIds.isNotEmpty;
+
+  /// Get provider IDs to pass to API calls
+  /// Returns null if all providers are enabled (no filtering needed)
+  /// Returns the list of enabled provider IDs otherwise
+  List<String>? get providerIdsForApiCalls {
+    if (_enabledProviderIds.isEmpty) return null; // All enabled
+    return _enabledProviderIds;
+  }
+
+  /// Check if a specific provider is enabled by the user
+  bool isProviderEnabled(String instanceId) {
+    if (_enabledProviderIds.isEmpty) return true; // All enabled by default
+    return _enabledProviderIds.contains(instanceId);
+  }
+
+  /// Get providers that have content in artists library (with item counts)
+  Map<String, int> getProvidersWithArtists() {
+    return _getProvidersWithCounts(_artists);
+  }
+
+  /// Get providers that have content in albums library (with item counts)
+  Map<String, int> getProvidersWithAlbums() {
+    return _getProvidersWithCounts(_albums);
+  }
+
+  /// Get providers that have content in tracks library (with item counts)
+  Map<String, int> getProvidersWithTracks() {
+    return _getProvidersWithCounts(_tracks);
+  }
+
+  /// Get providers that have content in playlists (with item counts)
+  Map<String, int> getProvidersWithPlaylists() {
+    return _getProvidersWithCounts(SyncService.instance.cachedPlaylists);
+  }
+
+  /// Get providers that have audiobooks (with item counts)
+  Map<String, int> getProvidersWithAudiobooks() {
+    return _getProvidersWithCounts(SyncService.instance.cachedAudiobooks);
+  }
+
+  /// Get providers that have radio stations (with item counts)
+  Map<String, int> getProvidersWithRadio() {
+    return _getProvidersWithCounts(_radioStations);
+  }
+
+  /// Get providers that have podcasts (with item counts)
+  /// Only counts mappings where inLibrary is true - this indicates which provider
+  /// the user actually added the podcast from (vs providers that can play it)
+  Map<String, int> getProvidersWithPodcasts() {
+    final counts = <String, int>{};
+    for (final item in _podcasts) {
+      final mappings = item.providerMappings;
+      if (mappings != null) {
+        for (final mapping in mappings) {
+          // Only count if this provider "owns" the item (user added it from this account)
+          if (mapping.inLibrary) {
+            final instanceId = mapping.providerInstance;
+            if (instanceId.isNotEmpty) {
+              counts[instanceId] = (counts[instanceId] ?? 0) + 1;
+            }
+          }
+        }
+      }
+    }
+    return counts;
+  }
+
+  /// Internal helper to count items per provider from a list of media items
+  /// Only counts mappings where inLibrary is true - this indicates which provider
+  /// the user actually added the item from (vs providers that can play it)
+  Map<String, int> _getProvidersWithCounts<T extends MediaItem>(List<T> items) {
+    final counts = <String, int>{};
+    for (final item in items) {
+      final mappings = item.providerMappings;
+      if (mappings != null) {
+        for (final mapping in mappings) {
+          // Only count if this provider "owns" the item (user added it from this account)
+          if (mapping.inLibrary) {
+            final instanceId = mapping.providerInstance;
+            if (instanceId.isNotEmpty) {
+              counts[instanceId] = (counts[instanceId] ?? 0) + 1;
+            }
+          }
+        }
+      }
+    }
+    return counts;
+  }
+
+  /// Get ProviderInstance objects for providers that have content in a category
+  /// Returns list of (ProviderInstance, itemCount) tuples, sorted by name
+  List<(ProviderInstance, int)> getRelevantProvidersForCategory(String category) {
+    final Map<String, int> counts;
+    switch (category) {
+      case 'artists':
+        counts = getProvidersWithArtists();
+        break;
+      case 'albums':
+        counts = getProvidersWithAlbums();
+        break;
+      case 'tracks':
+        counts = getProvidersWithTracks();
+        break;
+      case 'playlists':
+        counts = getProvidersWithPlaylists();
+        break;
+      case 'audiobooks':
+        counts = getProvidersWithAudiobooks();
+        break;
+      case 'radio':
+        counts = getProvidersWithRadio();
+        break;
+      case 'podcasts':
+        counts = getProvidersWithPodcasts();
+        break;
+      default:
+        counts = {};
+    }
+
+    // Build list of providers that support this category, with their item counts
+    // Only include providers that have at least 1 item (hides providers not synced to library)
+    final result = <(ProviderInstance, int)>[];
+    final addedInstanceIds = <String>{};
+
+    for (final provider in _availableMusicProviders) {
+      // Only include providers that support this content type AND have items
+      if (provider.supportsContentType(category)) {
+        final count = counts[provider.instanceId] ?? 0;
+        if (count > 0) {
+          result.add((provider, count));
+          addedInstanceIds.add(provider.instanceId);
+        }
+      }
+    }
+
+    // Also include providers that have items but aren't in _availableMusicProviders
+    // (e.g., search-only providers like iTunes)
+    for (final entry in counts.entries) {
+      if (!addedInstanceIds.contains(entry.key) && entry.value > 0) {
+        // Create a synthetic ProviderInstance from the instance ID
+        // Format is typically "domain--uniqueId" (e.g., "itunes--abc123")
+        final instanceId = entry.key;
+        final domain = instanceId.contains('--')
+            ? instanceId.split('--').first
+            : instanceId;
+        // Only add if this domain supports the category
+        final capabilities = ProviderInstance.providerCapabilities[domain];
+        if (capabilities != null && capabilities.contains(category)) {
+          result.add((
+            ProviderInstance(
+              instanceId: instanceId,
+              domain: domain,
+              name: _formatProviderName(domain),
+              available: true,
+            ),
+            entry.value,
+          ));
+        }
+      }
+    }
+
+    // Sort by name
+    result.sort((a, b) => a.$1.name.compareTo(b.$1.name));
+    return result;
+  }
+
+  /// Format a provider domain into a readable display name
+  String _formatProviderName(String domain) {
+    const names = {
+      'spotify': 'Spotify',
+      'tidal': 'Tidal',
+      'qobuz': 'Qobuz',
+      'deezer': 'Deezer',
+      'ytmusic': 'YouTube Music',
+      'soundcloud': 'SoundCloud',
+      'apple_music': 'Apple Music',
+      'amazon_music': 'Amazon Music',
+      'plex': 'Plex',
+      'jellyfin': 'Jellyfin',
+      'emby': 'Emby',
+      'subsonic': 'Subsonic',
+      'opensubsonic': 'OpenSubsonic',
+      'navidrome': 'Navidrome',
+      'audiobookshelf': 'Audiobookshelf',
+      'filesystem': 'Filesystem',
+      'itunes_podcasts': 'iTunes Podcasts',
+      'tunein': 'TuneIn',
+      'radiobrowser': 'Radio Browser',
+    };
+    return names[domain] ?? domain[0].toUpperCase() + domain.substring(1);
+  }
+
  /// Whether library is syncing in background
  bool get isSyncing => SyncService.instance.isSyncing;

@@ -377,7 +591,7 @@ class MusicAssistantProvider with ChangeNotifier {
  }

  String get lastSearchQuery => _lastSearchQuery;
-  Map<String, List<MediaItem>> get lastSearchResults => filterSearchResults(_lastSearchResults);
+  Map<String, List<MediaItem>> get lastSearchResults => _lastSearchResults;

  MusicAssistantAPI? get api => _api;
  AuthManager get authManager => _authManager;
@@ -501,6 +715,12 @@ class MusicAssistantProvider with ChangeNotifier {
    return getImageUrl(track, size: size);
  }

+  /// Clear cached track for a player (e.g., after queue transfer)
+  void clearPlayerTrackCache(String playerId) {
+    _cacheService.clearCachedTrackForPlayer(playerId);
+    notifyListeners();
+  }
+
  /// Number of pending offline actions
  int get pendingOfflineActionsCount => OfflineActionQueue.instance.pendingCount;

@@ -944,6 +1164,83 @@ class MusicAssistantProvider with ChangeNotifier {
    }
  }

+  /// Load available music providers from MA and restore saved filter settings
+  Future<void> loadMusicProviders() async {
+    if (_api == null) return;
+
+    try {
+      _logger.log('🎵 Loading music providers...');
+
+      // Fetch available providers from MA
+      _availableMusicProviders = await _api!.getMusicProviders();
+
+      // Save discovered providers to settings
+      final discoveredList = _availableMusicProviders.map((p) => {
+        'instanceId': p.instanceId,
+        'domain': p.domain,
+        'name': p.name,
+      }).toList();
+      await SettingsService.setDiscoveredMusicProviders(discoveredList);
+
+      // Load saved enabled providers
+      final savedEnabled = await SettingsService.getEnabledMusicProviders();
+      if (savedEnabled != null) {
+        // Validate saved IDs against available providers
+        final availableIds = _availableMusicProviders.map((p) => p.instanceId).toSet();
+        _enabledProviderIds = savedEnabled.where((id) => availableIds.contains(id)).toList();
+
+        // If all saved providers are gone, reset to all enabled
+        if (_enabledProviderIds.isEmpty && savedEnabled.isNotEmpty) {
+          _enabledProviderIds = [];
+          await SettingsService.clearEnabledMusicProviders();
+          _logger.log('🔄 Reset provider filter - saved providers no longer available');
+        } else if (_enabledProviderIds.isNotEmpty) {
+          _logger.log('🔒 Loaded provider filter: ${_enabledProviderIds.length} providers enabled');
+        }
+      } else {
+        _enabledProviderIds = [];
+        _logger.log('🔓 No provider filter - all ${_availableMusicProviders.length} providers enabled');
+      }
+
+      notifyListeners();
+    } catch (e) {
+      _logger.log('⚠️ Could not load music providers (non-fatal): $e');
+    }
+  }
+
+  /// Toggle a specific music provider on/off
+  /// Uses debounce to allow multiple toggles before syncing
+  Future<bool> toggleProviderEnabled(String instanceId, bool enabled) async {
+    final allIds = _availableMusicProviders.map((p) => p.instanceId).toList();
+
+    // Don't allow disabling the last provider
+    if (!enabled && _enabledProviderIds.isNotEmpty && _enabledProviderIds.length <= 1) {
+      _logger.log('⚠️ Cannot disable last provider');
+      return false;
+    }
+
+    await SettingsService.toggleMusicProvider(instanceId, enabled, allIds);
+
+    // Reload the enabled providers
+    final savedEnabled = await SettingsService.getEnabledMusicProviders();
+    _enabledProviderIds = savedEnabled ?? [];
+
+    _logger.log('🔄 Provider filter updated: ${_enabledProviderIds.isEmpty ? "all enabled" : "${_enabledProviderIds.length} enabled"}');
+
+    // Clear discover caches so they get refetched with new filter
+    _cacheService.clearDiscoverCaches();
+
+    // Notify listeners IMMEDIATELY so UI rebuilds with client-side filtering
+    // This enables instant UI updates using cached data with source tracking
+    notifyListeners();
+
+    // NOTE: Debounced sync is handled by the UI layer (new_library_screen.dart)
+    // to avoid duplicate timers and ensure single point of control
+
+    // Return true to indicate UI should update
+    return true;
+  }
+
  Future<void> _initializeAfterConnection() async {
    if (_api == null) return;

@@ -956,6 +1253,9 @@ class MusicAssistantProvider with ChangeNotifier {
        await _fetchUserSettings();
      }

+      // Load available music providers and user's filter preferences
+      await loadMusicProviders();
+
      await _tryAdoptGhostPlayer();
      await _registerLocalPlayer();
      await _loadAndSelectPlayers(coldStart: true);
@@ -2721,7 +3021,10 @@ class MusicAssistantProvider with ChangeNotifier {

    try {
      _logger.log('🔄 Fetching fresh discover artists...');
-      final artists = await _api!.getRandomArtists(limit: LibraryConstants.defaultRecentLimit);
+      final artists = await _api!.getRandomArtists(
+        limit: LibraryConstants.defaultRecentLimit,
+        providerInstanceIds: providerIdsForApiCalls,
+      );
      _cacheService.setCachedDiscoverArtists(artists);
      return artists;
    } catch (e) {
@@ -2740,7 +3043,10 @@ class MusicAssistantProvider with ChangeNotifier {

    try {
      _logger.log('🔄 Fetching fresh discover albums...');
-      final albums = await _api!.getRandomAlbums(limit: LibraryConstants.defaultRecentLimit);
+      final albums = await _api!.getRandomAlbums(
+        limit: LibraryConstants.defaultRecentLimit,
+        providerInstanceIds: providerIdsForApiCalls,
+      );
      _cacheService.setCachedDiscoverAlbums(albums);
      return albums;
    } catch (e) {
@@ -2764,10 +3070,14 @@ class MusicAssistantProvider with ChangeNotifier {

  /// Force a full library sync (for pull-to-refresh)
  Future<void> forceLibrarySync() async {
-    if (_api == null) return;
+    if (_api == null) {
+      _logger.log('⚠️ forceLibrarySync: API is null, skipping');
+      return;
+    }

-    _logger.log('🔄 Forcing full library sync...');
-    await SyncService.instance.forceSync(_api!);
+    final providerIds = providerIdsForApiCalls;
+    _logger.log('🔄 Forcing full library sync with providers: ${providerIds ?? "ALL"}');
+    await SyncService.instance.forceSync(_api!, providerInstanceIds: providerIds);

    // Update local lists from sync result
    _albums = SyncService.instance.cachedAlbums;
@@ -2775,7 +3085,10 @@ class MusicAssistantProvider with ChangeNotifier {

    // Also refresh tracks from API
    try {
-      _tracks = await _api!.getTracks(limit: LibraryConstants.maxLibraryItems);
+      _tracks = await _api!.getTracks(
+        limit: LibraryConstants.maxLibraryItems,
+        providerInstanceIds: providerIdsForApiCalls,
+      );
    } catch (e) {
      _logger.log('⚠️ Failed to refresh tracks: $e');
    }
@@ -3083,12 +3396,11 @@ class MusicAssistantProvider with ChangeNotifier {

    if (_cacheService.isSearchCacheValid(cacheKey, forceRefresh: forceRefresh)) {
      _logger.log('📦 Using cached search results for "$query" (libraryOnly: $libraryOnly)');
-      return filterSearchResults(_cacheService.getCachedSearchResults(cacheKey)!);
+      return _cacheService.getCachedSearchResults(cacheKey)!;
    }

    if (_api == null) {
-      final cached = _cacheService.getCachedSearchResults(cacheKey) ?? {'artists': [], 'albums': [], 'tracks': [], 'playlists': [], 'audiobooks': []};
-      return filterSearchResults(cached);
+      return _cacheService.getCachedSearchResults(cacheKey) ?? {'artists': [], 'albums': [], 'tracks': [], 'playlists': [], 'audiobooks': []};
    }

    try {
@@ -3105,11 +3417,10 @@ class MusicAssistantProvider with ChangeNotifier {

      _cacheService.setCachedSearchResults(cacheKey, cachedResults);
      _logger.log('✅ Cached search results for "$query"');
-      return filterSearchResults(cachedResults);
+      return cachedResults;
    } catch (e) {
      _logger.log('❌ Search failed: $e');
-      final cached = _cacheService.getCachedSearchResults(cacheKey) ?? {'artists': [], 'albums': [], 'tracks': [], 'playlists': [], 'audiobooks': []};
-      return filterSearchResults(cached);
+      return _cacheService.getCachedSearchResults(cacheKey) ?? {'artists': [], 'albums': [], 'tracks': [], 'playlists': [], 'audiobooks': []};
    }
  }

@@ -4398,7 +4709,10 @@ class MusicAssistantProvider with ChangeNotifier {
      // Fetch tracks from API (not cached - too many items)
      if (_api != null) {
        try {
-          _tracks = await _api!.getTracks(limit: LibraryConstants.maxLibraryItems);
+          _tracks = await _api!.getTracks(
+            limit: LibraryConstants.maxLibraryItems,
+            providerInstanceIds: providerIdsForApiCalls,
+          );
          _logger.log('📥 Fetched ${_tracks.length} tracks from MA');
        } catch (e) {
          _logger.log('⚠️ Failed to fetch tracks: $e');
@@ -4438,18 +4752,18 @@ class MusicAssistantProvider with ChangeNotifier {
    }

    syncService.addListener(onSyncComplete);
-    await syncService.syncFromApi(_api!);
+    await syncService.syncFromApi(_api!, providerInstanceIds: providerIdsForApiCalls);
  }

  /// Load radio stations from the library
-  Future<void> loadRadioStations() async {
+  Future<void> loadRadioStations({String? orderBy}) async {
    if (!isConnected || _api == null) return;

    try {
      _isLoadingRadio = true;
      notifyListeners();

-      _radioStations = await _api!.getRadioStations(limit: 100);
+      _radioStations = await _api!.getRadioStations(limit: 100, orderBy: orderBy);
      _isLoadingRadio = false;
      notifyListeners();
    } catch (e) {
@@ -4459,14 +4773,14 @@ class MusicAssistantProvider with ChangeNotifier {
    }
  }

-  Future<void> loadPodcasts() async {
+  Future<void> loadPodcasts({String? orderBy}) async {
    if (!isConnected || _api == null) return;

    try {
      _isLoadingPodcasts = true;
      notifyListeners();

-      _podcasts = await _api!.getPodcasts(limit: 100);
+      _podcasts = await _api!.getPodcasts(limit: 100, orderBy: orderBy);

      _logger.log('🎙️ Loaded ${_podcasts.length} podcasts');
      _isLoadingPodcasts = false;
@@ -4509,7 +4823,7 @@ class MusicAssistantProvider with ChangeNotifier {
    }
  }

-  Future<void> loadArtists({int? limit, int? offset, String? search}) async {
+  Future<void> loadArtists({int? limit, int? offset, String? search, String? orderBy}) async {
    if (!isConnected) return;

    try {
@@ -4522,6 +4836,7 @@ class MusicAssistantProvider with ChangeNotifier {
        offset: offset,
        search: search,
        albumArtistsOnly: false, // Show ALL library artists, not just those with albums
+        orderBy: orderBy,
      );

      _isLoading = false;
@@ -4539,6 +4854,7 @@ class MusicAssistantProvider with ChangeNotifier {
    int? offset,
    String? search,
    String? artistId,
+    String? orderBy,
  }) async {
    if (!isConnected) return;

@@ -4552,6 +4868,7 @@ class MusicAssistantProvider with ChangeNotifier {
        offset: offset,
        search: search,
        artistId: artistId,
+        orderBy: orderBy,
      );

      _isLoading = false;
@@ -4582,7 +4899,7 @@ class MusicAssistantProvider with ChangeNotifier {

    try {
      final results = await _api!.search(query, libraryOnly: libraryOnly);
-      return filterSearchResults(results);
+      return results;
    } catch (e) {
      ErrorHandler.logError('Search', e);
      return {'artists': [], 'albums': [], 'tracks': []};
@@ -4590,10 +4907,10 @@ class MusicAssistantProvider with ChangeNotifier {
  }

  /// Get playlists with provider filtering applied
-  Future<List<Playlist>> getPlaylists({int? limit, bool? favoriteOnly}) async {
+  Future<List<Playlist>> getPlaylists({int? limit, bool? favoriteOnly, String? orderBy}) async {
    if (_api == null) return [];
    try {
-      final playlists = await _api!.getPlaylists(limit: limit, favoriteOnly: favoriteOnly);
+      final playlists = await _api!.getPlaylists(limit: limit, favoriteOnly: favoriteOnly, orderBy: orderBy);
      return filterByProvider(playlists);
    } catch (e) {
      _logger.log('❌ Failed to fetch playlists: $e');
@@ -1,964 +0,0 @@
-import 'dart:async';
-import 'package:flutter/foundation.dart';
-import 'package:flutter/painting.dart';
-import '../models/media_item.dart';
-import '../models/player.dart';
-import '../services/music_assistant_api.dart';
-import '../services/settings_service.dart';
-import '../services/debug_logger.dart';
-import '../services/error_handler.dart';
-import '../services/local_player_service.dart';
-import '../services/auth/auth_manager.dart';
-import '../services/device_id_service.dart';
-import '../services/cache_service.dart';
-import '../constants/timings.dart';
-import '../main.dart' show audioHandler;
-
-/// Provider for managing player state, selection, and controls
-class PlayerProvider with ChangeNotifier {
-  final DebugLogger _logger = DebugLogger();
-  late final LocalPlayerService _localPlayer;
-  final CacheService _cacheService;
-
-  // Dependencies injected from parent provider
-  MusicAssistantAPI? _api;
-  AuthManager? _authManager;
-  String? _serverUrl;
-
-  // Player selection
-  Player? _selectedPlayer;
-  List<Player> _availablePlayers = [];
-  Track? _currentTrack;
-  Timer? _playerStateTimer;
-  Timer? _adjacentPlayerCacheTimer;
-
-  // Local Playback
-  bool _isLocalPlayerPowered = true;
-  StreamSubscription? _localPlayerEventSubscription;
-  StreamSubscription? _playerUpdatedEventSubscription;
-  Timer? _localPlayerStateReportTimer;
-
-  // Pending metadata from player_updated events
-  TrackMetadata? _pendingTrackMetadata;
-  TrackMetadata? _currentNotificationMetadata;
-
-  // Registration guard
-  Completer<void>? _registrationInProgress;
-
-  // Getters
-  Player? get selectedPlayer => _selectedPlayer;
-  List<Player> get availablePlayers => _availablePlayers;
-  Track? get currentTrack => _currentTrack;
-  bool get isLocalPlayerPowered => _isLocalPlayerPowered;
-
-  /// Get cached track for a player (used for smooth swipe transitions)
-  Track? getCachedTrackForPlayer(String playerId) => _cacheService.getCachedTrackForPlayer(playerId);
-
-  PlayerProvider(this._cacheService, AuthManager authManager) {
-    _authManager = authManager;
-    _localPlayer = LocalPlayerService(authManager);
-  }
-
-  /// Initialize with API reference after connection
-  void initialize(MusicAssistantAPI api, String serverUrl) {
-    _api = api;
-    _serverUrl = serverUrl;
-  }
-
-  /// Set up event listeners after connection
-  Future<void> setupEventListeners() async {
-    if (_api == null) return;
-
-    // Listen to built-in player events
-    _localPlayerEventSubscription?.cancel();
-    _localPlayerEventSubscription = _api!.builtinPlayerEvents.listen(
-      _handleLocalPlayerEvent,
-      onError: (error) {
-        _logger.log('Builtin player event stream error: $error');
-      },
-    );
-
-    // Listen to player_updated events
-    _playerUpdatedEventSubscription?.cancel();
-    _playerUpdatedEventSubscription = _api!.playerUpdatedEvents.listen(
-      _handlePlayerUpdatedEvent,
-      onError: (error) {
-        _logger.log('Player updated event stream error: $error');
-      },
-    );
-  }
-
-  /// Initialize local playback
-  Future<void> initializeLocalPlayback() async {
-    await _localPlayer.initialize();
-    _isLocalPlayerPowered = true;
-
-    // Wire up skip button callbacks
-    audioHandler.onSkipToNext = () {
-      _logger.log('🎵 Notification: Skip to next pressed');
-      nextTrackSelectedPlayer();
-    };
-    audioHandler.onSkipToPrevious = () {
-      _logger.log('🎵 Notification: Skip to previous pressed');
-      previousTrackSelectedPlayer();
-    };
-
-    if (_api != null) {
-      await registerLocalPlayer();
-    }
-  }
-
-  /// Try to adopt an existing ghost player
-  Future<bool> tryAdoptGhostPlayer() async {
-    if (_api == null) return false;
-
-    try {
-      final isFresh = await DeviceIdService.isFreshInstallation();
-      if (!isFresh) {
-        _logger.log('👻 Not a fresh install, skipping ghost adoption');
-        return false;
-      }
-
-      final ownerName = await SettingsService.getOwnerName();
-      if (ownerName == null || ownerName.isEmpty) {
-        _logger.log('👻 No owner name set, cannot adopt ghost player');
-        return false;
-      }
-
-      _logger.log('👻 Fresh install detected, searching for adoptable ghost for "$ownerName"...');
-      final adoptableId = await _api!.findAdoptableGhostPlayer(ownerName);
-      if (adoptableId == null) {
-        _logger.log('👻 No matching ghost player found - will generate new ID');
-        return false;
-      }
-
-      _logger.log('👻 Found adoptable ghost: $adoptableId');
-      await DeviceIdService.adoptPlayerId(adoptableId);
-
-      _logger.log('✅ Successfully adopted ghost player');
-      return true;
-    } catch (e) {
-      _logger.log('⚠️ Ghost adoption failed (non-fatal): $e');
-      return false;
-    }
-  }
-
-  /// Register local player with MA server
-  Future<void> registerLocalPlayer() async {
-    if (_api == null) return;
-
-    if (_registrationInProgress != null) {
-      _logger.log('⏳ Registration already in progress, waiting...');
-      return _registrationInProgress!.future;
-    }
-
-    _registrationInProgress = Completer<void>();
-
-    try {
-      final playerId = await DeviceIdService.getOrCreateDevicePlayerId();
-      _logger.log('🆔 Using player ID: $playerId');
-
-      await SettingsService.setBuiltinPlayerId(playerId);
-      final name = await SettingsService.getLocalPlayerName();
-
-      final existingPlayers = await _api!.getPlayers();
-      final existingPlayer = existingPlayers.where((p) => p.playerId == playerId).firstOrNull;
-
-      if (existingPlayer != null && existingPlayer.available) {
-        _logger.log('✅ Player already registered and available: $playerId');
-        _startReportingLocalPlayerState();
-        if (_registrationInProgress != null && !_registrationInProgress!.isCompleted) {
-          _registrationInProgress!.complete();
-        }
-        _registrationInProgress = null;
-        return;
-      } else if (existingPlayer != null && !existingPlayer.available) {
-        _logger.log('⚠️ Player exists but unavailable (stale), re-registering: $playerId');
-      } else {
-        _logger.log('🆔 Player not found in MA, registering as new');
-      }
-
-      _logger.log('🎵 Registering player with MA: id=$playerId, name=$name');
-      await _api!.registerBuiltinPlayer(playerId, name);
-
-      _logger.log('✅ Player registration complete');
-      _startReportingLocalPlayerState();
-
-      if (_registrationInProgress != null && !_registrationInProgress!.isCompleted) {
-        _registrationInProgress!.complete();
-      }
-      _registrationInProgress = null;
-    } catch (e) {
-      _logger.log('❌ CRITICAL: Player registration failed: $e');
-      if (_registrationInProgress != null && !_registrationInProgress!.isCompleted) {
-        _registrationInProgress!.completeError(e);
-      }
-      _registrationInProgress = null;
-      rethrow;
-    }
-  }
-
-  void _startReportingLocalPlayerState() {
-    _localPlayerStateReportTimer?.cancel();
-    _localPlayerStateReportTimer = Timer.periodic(Timings.localPlayerReportInterval, (_) async {
-      try {
-        await _reportLocalPlayerState();
-      } catch (e) {
-        _logger.log('Error reporting local player state (will retry): $e');
-      }
-    });
-  }
-
-  Future<void> _reportLocalPlayerState() async {
-    if (_api == null) return;
-
-    // Don't try to report state if not authenticated - avoids spamming errors
-    if (_api!.currentConnectionState != MAConnectionState.authenticated) return;
-
-    final playerId = await SettingsService.getBuiltinPlayerId();
-    if (playerId == null) return;
-
-    final isPlaying = _localPlayer.isPlaying;
-    final position = _localPlayer.position.inSeconds;
-    final volume = (_localPlayer.volume * 100).round();
-    final isPaused = !isPlaying && position > 0;
-
-    await _api!.updateBuiltinPlayerState(
-      playerId,
-      powered: _isLocalPlayerPowered,
-      playing: isPlaying,
-      paused: isPaused,
-      position: position,
-      volume: volume,
-      muted: _localPlayer.volume == 0.0,
-    );
-  }
-
-  Future<void> _handleLocalPlayerEvent(Map<String, dynamic> event) async {
-    _logger.log('📥 Local player event received: ${event['type'] ?? event['command']}');
-
-    try {
-      final eventPlayerId = event['player_id'] as String?;
-      final myPlayerId = await SettingsService.getBuiltinPlayerId();
-
-      if (eventPlayerId != null && myPlayerId != null && eventPlayerId != myPlayerId) {
-        _logger.log('🚫 Ignoring event for different player: $eventPlayerId');
-        return;
-      }
-
-      final command = (event['type'] as String?) ?? (event['command'] as String?);
-
-      switch (command) {
-        case 'play_media':
-          final urlPath = event['media_url'] as String? ?? event['url'] as String?;
-
-          if (urlPath != null && _serverUrl != null) {
-            String fullUrl;
-            if (urlPath.startsWith('http')) {
-              fullUrl = urlPath;
-            } else {
-              var baseUrl = _serverUrl!;
-              if (!baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {
-                baseUrl = 'https://$baseUrl';
-              }
-              baseUrl = baseUrl.endsWith('/') ? baseUrl.substring(0, baseUrl.length - 1) : baseUrl;
-              final path = urlPath.startsWith('/') ? urlPath : '/$urlPath';
-              fullUrl = '$baseUrl$path';
-            }
-
-            TrackMetadata metadata;
-            if (_pendingTrackMetadata != null) {
-              metadata = _pendingTrackMetadata!;
-            } else {
-              final trackName = event['track_name'] as String? ?? event['name'] as String? ?? 'Unknown Track';
-              final artistName = event['artist_name'] as String? ?? event['artist'] as String? ?? 'Unknown Artist';
-              final albumName = event['album_name'] as String? ?? event['album'] as String?;
-              var artworkUrl = event['image_url'] as String? ?? event['artwork_url'] as String?;
-              final durationSecs = event['duration'] as int?;
-
-              if (artworkUrl != null && artworkUrl.startsWith('http://')) {
-                artworkUrl = artworkUrl.replaceFirst('http://', 'https://');
-              }
-
-              metadata = TrackMetadata(
-                title: trackName,
-                artist: artistName,
-                album: albumName,
-                artworkUrl: artworkUrl,
-                duration: durationSecs != null ? Duration(seconds: durationSecs) : null,
-              );
-            }
-
-            _localPlayer.setCurrentTrackMetadata(metadata);
-            _currentNotificationMetadata = metadata;
-            await _localPlayer.playUrl(fullUrl);
-          }
-          break;
-
-        case 'stop':
-          await _localPlayer.stop();
-          break;
-
-        case 'pause':
-          await _localPlayer.pause();
-          break;
-
-        case 'play':
-          await _localPlayer.play();
-          break;
-
-        case 'seek':
-          final position = event['position'] as int?;
-          if (position != null) {
-            await _localPlayer.seek(Duration(seconds: position));
-          }
-          break;
-
-        case 'volume_set':
-          final volume = event['volume_level'] as int?;
-          if (volume != null) {
-            await _localPlayer.setVolume(volume / 100.0);
-          }
-          break;
-
-        case 'power_on':
-        case 'power_off':
-        case 'power':
-          bool? newPowerState;
-          if (command == 'power_on') {
-            newPowerState = true;
-          } else if (command == 'power_off') {
-            newPowerState = false;
-          } else {
-            newPowerState = event['powered'] as bool?;
-          }
-
-          if (newPowerState != null) {
-            _isLocalPlayerPowered = newPowerState;
-            if (!_isLocalPlayerPowered) {
-              await _localPlayer.stop();
-            }
-          }
-          break;
-      }
-
-      await _reportLocalPlayerState();
-    } catch (e) {
-      _logger.log('Error handling local player event: $e');
-    }
-  }
-
-  Future<void> _handlePlayerUpdatedEvent(Map<String, dynamic> event) async {
-    try {
-      final playerId = event['player_id'] as String?;
-      if (playerId == null) return;
-
-      if (_selectedPlayer != null && playerId == _selectedPlayer!.playerId) {
-        _updatePlayerState();
-      }
-
-      final currentMedia = event['current_media'] as Map<String, dynamic>?;
-      final playerName = event['name'] as String? ?? playerId;
-
-      if (currentMedia != null) {
-        final mediaType = currentMedia['media_type'] as String?;
-        if (mediaType != 'flow_stream') {
-          final durationSecs = (currentMedia['duration'] as num?)?.toInt();
-          final albumName = currentMedia['album'] as String?;
-          final imageUrl = currentMedia['image_url'] as String?;
-
-          Map<String, dynamic>? metadata;
-          if (imageUrl != null && _serverUrl != null) {
-            var finalImageUrl = imageUrl;
-            try {
-              final imgUri = Uri.parse(imageUrl);
-              final queryString = imgUri.query;
-              var baseUrl = _serverUrl!;
-              if (!baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {
-                baseUrl = 'https://$baseUrl';
-              }
-              if (baseUrl.endsWith('/')) {
-                baseUrl = baseUrl.substring(0, baseUrl.length - 1);
-              }
-              finalImageUrl = '$baseUrl/imageproxy?$queryString';
-            } catch (e) {
-              // Use original URL
-            }
-            metadata = {
-              'images': [{'path': finalImageUrl, 'provider': 'direct'}]
-            };
-          }
-
-          final trackFromEvent = Track(
-            itemId: currentMedia['queue_item_id'] as String? ?? '',
-            provider: 'library',
-            name: currentMedia['title'] as String? ?? 'Unknown Track',
-            uri: currentMedia['uri'] as String?,
-            duration: durationSecs != null ? Duration(seconds: durationSecs) : null,
-            artists: [Artist(itemId: '', provider: 'library', name: currentMedia['artist'] as String? ?? 'Unknown Artist')],
-            album: albumName != null ? Album(itemId: '', provider: 'library', name: albumName) : null,
-            metadata: metadata,
-          );
-
-          _cacheService.setCachedTrackForPlayer(playerId, trackFromEvent);
-
-          if (_selectedPlayer != null && playerId == _selectedPlayer!.playerId) {
-            _currentTrack = trackFromEvent;
-          }
-
-          _logger.log('📋 Cached track for $playerName: ${trackFromEvent.name}');
-
-          if (imageUrl != null) {
-            final images = metadata?['images'] as List?;
-            if (images != null && images.isNotEmpty) {
-              final imagePath = images[0]['path'] as String?;
-              if (imagePath != null) {
-                _precacheImage(imagePath);
-              }
-            }
-          }
-
-          notifyListeners();
-        }
-      }
-
-      // Handle notification metadata for local player
-      final builtinPlayerId = await SettingsService.getBuiltinPlayerId();
-      if (builtinPlayerId == null || playerId != builtinPlayerId) return;
-
-      if (currentMedia == null) return;
-
-      final title = currentMedia['title'] as String? ?? 'Unknown Track';
-      final artist = currentMedia['artist'] as String? ?? 'Unknown Artist';
-      final album = currentMedia['album'] as String?;
-      var imageUrl = currentMedia['image_url'] as String?;
-      final durationSecs = (currentMedia['duration'] as num?)?.toInt();
-
-      if (imageUrl != null && _serverUrl != null) {
-        try {
-          final imgUri = Uri.parse(imageUrl);
-          final queryString = imgUri.query;
-          var baseUrl = _serverUrl!;
-          if (!baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {
-            baseUrl = 'https://$baseUrl';
-          }
-          if (baseUrl.endsWith('/')) {
-            baseUrl = baseUrl.substring(0, baseUrl.length - 1);
-          }
-          imageUrl = '$baseUrl/imageproxy?$queryString';
-        } catch (e) {
-          if (imageUrl != null && imageUrl.startsWith('http://')) {
-            imageUrl = imageUrl.replaceFirst('http://', 'https://');
-          }
-        }
-      }
-
-      final newMetadata = TrackMetadata(
-        title: title,
-        artist: artist,
-        album: album,
-        artworkUrl: imageUrl,
-        duration: durationSecs != null ? Duration(seconds: durationSecs) : null,
-      );
-
-      final mediaType = currentMedia['media_type'] as String?;
-      if (mediaType == 'flow_stream') return;
-
-      _pendingTrackMetadata = newMetadata;
-
-      final notificationNeedsUpdate = _currentNotificationMetadata != null &&
-          (_currentNotificationMetadata!.title != title ||
-           _currentNotificationMetadata!.artist != artist);
-
-      if (_localPlayer.isPlaying && notificationNeedsUpdate) {
-        await _localPlayer.updateNotificationWhilePlaying(newMetadata);
-        _currentNotificationMetadata = newMetadata;
-      }
-    } catch (e) {
-      _logger.log('Error handling player_updated event: $e');
-    }
-  }
-
-  // ============================================================================
-  // PLAYER SELECTION
-  // ============================================================================
-
-  Future<void> loadAndSelectPlayers({bool forceRefresh = false}) async {
-    if (_api == null) return;
-
-    try {
-      if (!forceRefresh && _cacheService.isPlayersCacheValid() && _availablePlayers.isNotEmpty) {
-        return;
-      }
-
-      final allPlayers = await _api!.getPlayers();
-      final builtinPlayerId = await SettingsService.getBuiltinPlayerId();
-
-      _logger.log('🎛️ getPlayers returned ${allPlayers.length} players');
-
-      int filteredCount = 0;
-
-      _availablePlayers = allPlayers.where((player) {
-        final nameLower = player.name.toLowerCase();
-
-        if (nameLower.contains('music assistant mobile')) {
-          filteredCount++;
-          return false;
-        }
-
-        // Filter out MA Web UI's built-in player (provider is 'builtin_player' and starts with 'ma_')
-        // Note: We check BOTH conditions to avoid filtering snapcast/other players that may have 'ma_' prefix
-        if (player.provider == 'builtin_player' && player.playerId.startsWith('ma_')) {
-          filteredCount++;
-          return false;
-        }
-
-        // Also filter "This Device" named players without proper provider
-        if (nameLower == 'this device') {
-          filteredCount++;
-          return false;
-        }
-
-        if (player.playerId.startsWith('ensemble_')) {
-          if (builtinPlayerId == null || player.playerId != builtinPlayerId) {
-            filteredCount++;
-            return false;
-          }
-        }
-
-        if (!player.available) {
-          if (builtinPlayerId != null && player.playerId == builtinPlayerId) {
-            return true;
-          }
-          filteredCount++;
-          return false;
-        }
-
-        return true;
-      }).toList();
-
-      _availablePlayers.sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
-      _cacheService.updatePlayersLastFetched();
-
-      _logger.log('🎛️ After filtering: ${_availablePlayers.length} players available');
-
-      if (_availablePlayers.isNotEmpty) {
-        Player? playerToSelect;
-
-        if (_selectedPlayer != null) {
-          final stillAvailable = _availablePlayers.any(
-            (p) => p.playerId == _selectedPlayer!.playerId && p.available,
-          );
-          if (stillAvailable) {
-            playerToSelect = _availablePlayers.firstWhere(
-              (p) => p.playerId == _selectedPlayer!.playerId,
-            );
-          }
-        }
-
-        if (playerToSelect == null) {
-          final lastSelectedPlayerId = await SettingsService.getLastSelectedPlayerId();
-
-          // Priority 1: Last selected player
-          if (lastSelectedPlayerId != null) {
-            playerToSelect = _availablePlayers.cast<Player?>().firstWhere(
-              (p) => p!.playerId == lastSelectedPlayerId && p.available,
-              orElse: () => null,
-            );
-          }
-
-          // Priority 2: Built-in (local) player
-          if (playerToSelect == null && builtinPlayerId != null) {
-            playerToSelect = _availablePlayers.cast<Player?>().firstWhere(
-              (p) => p!.playerId == builtinPlayerId && p.available,
-              orElse: () => null,
-            );
-          }
-
-          // Priority 3: Currently playing player (exclude external sources - not playing MA content)
-          if (playerToSelect == null) {
-            playerToSelect = _availablePlayers.cast<Player?>().firstWhere(
-              (p) => p!.state == 'playing' && p.available && !p.isExternalSource,
-              orElse: () => null,
-            );
-          }
-
-          if (playerToSelect == null) {
-            playerToSelect = _availablePlayers.firstWhere(
-              (p) => p.available,
-              orElse: () => _availablePlayers.first,
-            );
-          }
-        }
-
-        selectPlayer(playerToSelect);
-      }
-
-      _preloadAdjacentPlayers(preloadAll: true);
-    } catch (e) {
-      ErrorHandler.logError('Load and select players', e);
-    }
-  }
-
-  void selectPlayer(Player player, {bool skipNotify = false}) {
-    _selectedPlayer = player;
-    SettingsService.setLastSelectedPlayerId(player.playerId);
-    _startPlayerStatePolling();
-    _preloadAdjacentPlayers();
-
-    if (!skipNotify) {
-      notifyListeners();
-    }
-  }
-
-  Future<void> _preloadAdjacentPlayers({bool preloadAll = false}) async {
-    if (_api == null) return;
-
-    final players = _availablePlayers.where((p) => p.available).toList();
-    if (players.isEmpty) return;
-
-    if (preloadAll) {
-      _logger.log('🖼️ Preloading track info for all ${players.length} players...');
-      await Future.wait(players.map((player) => _preloadPlayerTrack(player)));
-      _logger.log('🖼️ Preloading complete');
-      return;
-    }
-
-    if (_selectedPlayer == null || players.length <= 1) return;
-
-    final currentIndex = players.indexWhere((p) => p.playerId == _selectedPlayer!.playerId);
-    if (currentIndex == -1) return;
-
-    final prevIndex = currentIndex <= 0 ? players.length - 1 : currentIndex - 1;
-    final nextIndex = currentIndex >= players.length - 1 ? 0 : currentIndex + 1;
-
-    final playersToPreload = <Player>{};
-    if (prevIndex != currentIndex) playersToPreload.add(players[prevIndex]);
-    if (nextIndex != currentIndex) playersToPreload.add(players[nextIndex]);
-
-    for (final player in playersToPreload) {
-      _preloadPlayerTrack(player);
-    }
-  }
-
-  Future<void> _preloadPlayerTrack(Player player) async {
-    if (_api == null) return;
-
-    try {
-      if (!player.available || !player.powered) {
-        _cacheService.setCachedTrackForPlayer(player.playerId, null);
-        return;
-      }
-
-      final queue = await _api!.getQueue(player.playerId);
-
-      if (queue != null && queue.currentItem != null) {
-        final track = queue.currentItem!.track;
-        final existingTrack = _cacheService.getCachedTrackForPlayer(player.playerId);
-        final existingHasImage = existingTrack?.metadata?['images'] != null;
-        final newHasImage = track.metadata?['images'] != null;
-
-        if (!existingHasImage || newHasImage) {
-          _cacheService.setCachedTrackForPlayer(player.playerId, track);
-        }
-
-        final artworkUrl512 = _api!.getImageUrl(existingHasImage ? existingTrack! : track, size: 512);
-        if (artworkUrl512 != null) {
-          await _precacheImage(artworkUrl512);
-        }
-      } else {
-        final existingTrack = _cacheService.getCachedTrackForPlayer(player.playerId);
-        if (existingTrack?.metadata?['images'] == null) {
-          _cacheService.setCachedTrackForPlayer(player.playerId, null);
-        }
-      }
-    } catch (e) {
-      _logger.log('Error preloading player track for ${player.name}: $e');
-    }
-  }
-
-  Future<void> _precacheImage(String url) async {
-    try {
-      final imageProvider = NetworkImage(url);
-      final imageStream = imageProvider.resolve(const ImageConfiguration());
-      final completer = Completer<void>();
-      late ImageStreamListener listener;
-
-      listener = ImageStreamListener(
-        (ImageInfo info, bool synchronousCall) {
-          if (!completer.isCompleted) completer.complete();
-          imageStream.removeListener(listener);
-        },
-        onError: (exception, stackTrace) {
-          if (!completer.isCompleted) completer.completeError(exception);
-          imageStream.removeListener(listener);
-        },
-      );
-
-      imageStream.addListener(listener);
-      await completer.future.timeout(const Duration(seconds: 10), onTimeout: () {
-        imageStream.removeListener(listener);
-      });
-    } catch (e) {
-      _logger.log('Image precache failed for $url: $e');
-    }
-  }
-
-  Future<void> preloadAllPlayerTracks() async {
-    if (_api == null) return;
-    final players = _availablePlayers.where((p) => p.available).toList();
-    await Future.wait(players.map((player) => _preloadPlayerTrack(player)));
-  }
-
-  void _startPlayerStatePolling() {
-    _playerStateTimer?.cancel();
-    if (_selectedPlayer == null) return;
-
-    _playerStateTimer = Timer.periodic(Timings.playerPollingInterval, (_) async {
-      try {
-        await _updatePlayerState();
-      } catch (e) {
-        _logger.log('Error updating player state (will retry): $e');
-      }
-    });
-
-    _updatePlayerState();
-  }
-
-  Future<void> _updatePlayerState() async {
-    if (_selectedPlayer == null || _api == null) return;
-
-    try {
-      bool stateChanged = false;
-
-      final allPlayers = await _api!.getPlayers();
-      final updatedPlayer = allPlayers.firstWhere(
-        (p) => p.playerId == _selectedPlayer!.playerId,
-        orElse: () => _selectedPlayer!,
-      );
-
-      _selectedPlayer = updatedPlayer;
-      stateChanged = true;
-
-      final isPlayingOrPaused = _selectedPlayer!.state == 'playing' || _selectedPlayer!.state == 'paused';
-      final isIdleWithContent = _selectedPlayer!.state == 'idle' && _selectedPlayer!.powered;
-      final shouldShowTrack = _selectedPlayer!.available && (isPlayingOrPaused || isIdleWithContent);
-
-      if (!shouldShowTrack) {
-        if (_currentTrack != null) {
-          _currentTrack = null;
-          stateChanged = true;
-        }
-        if (stateChanged) notifyListeners();
-        return;
-      }
-
-      final queue = await _api!.getQueue(_selectedPlayer!.playerId);
-
-      if (queue != null && queue.currentItem != null) {
-        if (_currentTrack == null ||
-            _currentTrack!.uri != queue.currentItem!.track.uri ||
-            _currentTrack!.name != queue.currentItem!.track.name) {
-          _currentTrack = queue.currentItem!.track;
-          stateChanged = true;
-
-          final builtinPlayerId = await SettingsService.getBuiltinPlayerId();
-          if (builtinPlayerId != null && _selectedPlayer!.playerId == builtinPlayerId) {
-            final track = _currentTrack!;
-            final artworkUrl = _api?.getImageUrl(track, size: 512);
-            _localPlayer.updateNotification(
-              id: track.uri ?? track.itemId,
-              title: track.name,
-              artist: track.artistsString,
-              album: track.album?.name,
-              artworkUrl: artworkUrl,
-              duration: track.duration,
-            );
-          }
-        }
-      } else {
-        if (_currentTrack != null) {
-          _currentTrack = null;
-          stateChanged = true;
-        }
-      }
-
-      if (stateChanged) notifyListeners();
-    } catch (e) {
-      _logger.log('❌ Error updating player state: $e');
-    }
-  }
-
-  // ============================================================================
-  // PLAYER CONTROLS
-  // ============================================================================
-
-  Future<void> playPauseSelectedPlayer() async {
-    if (_selectedPlayer == null || _api == null) return;
-
-    if (_selectedPlayer!.isPlaying) {
-      await _api!.pausePlayer(_selectedPlayer!.playerId);
-    } else {
-      await _api!.resumePlayer(_selectedPlayer!.playerId);
-    }
-
-    await refreshPlayers();
-  }
-
-  Future<void> nextTrackSelectedPlayer() async {
-    if (_selectedPlayer == null || _api == null) return;
-    await _api!.nextTrack(_selectedPlayer!.playerId);
-    await Future.delayed(Timings.trackChangeDelay);
-    await _updatePlayerState();
-  }
-
-  Future<void> previousTrackSelectedPlayer() async {
-    if (_selectedPlayer == null || _api == null) return;
-    await _api!.previousTrack(_selectedPlayer!.playerId);
-    await Future.delayed(Timings.trackChangeDelay);
-    await _updatePlayerState();
-  }
-
-  Future<void> refreshPlayers() async {
-    final previousState = _selectedPlayer?.state;
-    final previousVolume = _selectedPlayer?.volumeLevel;
-
-    await loadAndSelectPlayers(forceRefresh: true);
-
-    bool stateChanged = false;
-    if (_selectedPlayer != null && _availablePlayers.isNotEmpty) {
-      try {
-        final updatedPlayer = _availablePlayers.firstWhere(
-          (p) => p.playerId == _selectedPlayer!.playerId,
-        );
-
-        if (updatedPlayer.state != previousState || updatedPlayer.volumeLevel != previousVolume) {
-          stateChanged = true;
-        }
-
-        _selectedPlayer = updatedPlayer;
-      } catch (e) {
-        stateChanged = true;
-      }
-    }
-
-    if (stateChanged) notifyListeners();
-  }
-
-  Future<void> togglePower(String playerId) async {
-    if (_api == null) return;
-
-    try {
-      final localPlayerId = await SettingsService.getBuiltinPlayerId();
-      final isLocalPlayer = localPlayerId != null && playerId == localPlayerId;
-
-      if (isLocalPlayer) {
-        _isLocalPlayerPowered = !_isLocalPlayerPowered;
-        if (!_isLocalPlayerPowered) {
-          await _localPlayer.stop();
-        }
-        await _reportLocalPlayerState();
-        await refreshPlayers();
-      } else {
-        final player = _availablePlayers.firstWhere(
-          (p) => p.playerId == playerId,
-          orElse: () => _selectedPlayer != null && _selectedPlayer!.playerId == playerId
-              ? _selectedPlayer!
-              : throw Exception("Player not found"),
-        );
-
-        await _api!.setPower(playerId, !player.powered);
-        await refreshPlayers();
-      }
-    } catch (e) {
-      ErrorHandler.logError('Toggle power', e);
-    }
-  }
-
-  Future<void> setVolume(String playerId, int volumeLevel) async {
-    if (_api == null) return;
-    try {
-      await _api!.setVolume(playerId, volumeLevel);
-    } catch (e) {
-      ErrorHandler.logError('Set volume', e);
-      rethrow;
-    }
-  }
-
-  Future<void> setMute(String playerId, bool muted) async {
-    if (_api == null) return;
-    try {
-      await _api!.setMute(playerId, muted);
-      await refreshPlayers();
-    } catch (e) {
-      ErrorHandler.logError('Set mute', e);
-      rethrow;
-    }
-  }
-
-  Future<void> seek(String playerId, int position) async {
-    if (_api == null) return;
-    try {
-      await _api!.seek(playerId, position);
-    } catch (e) {
-      ErrorHandler.logError('Seek', e);
-      rethrow;
-    }
-  }
-
-  Future<void> toggleShuffle(String queueId, bool shuffleEnabled) async {
-    if (_api == null) return;
-    try {
-      await _api!.toggleShuffle(queueId, shuffleEnabled);
-    } catch (e) {
-      ErrorHandler.logError('Toggle shuffle', e);
-      rethrow;
-    }
-  }
-
-  Future<void> setRepeatMode(String queueId, String mode) async {
-    if (_api == null) return;
-    try {
-      await _api!.setRepeatMode(queueId, mode);
-    } catch (e) {
-      ErrorHandler.logError('Set repeat mode', e);
-      rethrow;
-    }
-  }
-
-  Future<void> cycleRepeatMode(String queueId, String? currentMode) async {
-    String nextMode;
-    switch (currentMode) {
-      case 'off':
-      case null:
-        nextMode = 'all';
-        break;
-      case 'all':
-        nextMode = 'one';
-        break;
-      case 'one':
-        nextMode = 'off';
-        break;
-      default:
-        nextMode = 'off';
-    }
-    await setRepeatMode(queueId, nextMode);
-  }
-
-  void clearState() {
-    _playerStateTimer?.cancel();
-    _playerStateTimer = null;
-    _localPlayerStateReportTimer?.cancel();
-    _localPlayerEventSubscription?.cancel();
-    _playerUpdatedEventSubscription?.cancel();
-    _availablePlayers = [];
-    _selectedPlayer = null;
-    _currentTrack = null;
-  }
-
-  @override
-  void dispose() {
-    clearState();
-    super.dispose();
-  }
-}
@@ -12,6 +12,7 @@ import '../services/recently_played_service.dart';
 import '../widgets/global_player_overlay.dart';
 import '../widgets/player_picker_sheet.dart';
 import '../l10n/app_localizations.dart';
+import '../theme/design_tokens.dart';
 import 'artist_details_screen.dart';

 class AlbumDetailsScreen extends StatefulWidget {
@@ -222,7 +223,6 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick

    try {
      final newState = !_isInLibrary;
-      bool success;

      if (newState) {
        // Add to library - MUST use non-library provider
@@ -253,12 +253,35 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
          }
        }

+        // OPTIMISTIC UPDATE: Update UI immediately
+        setState(() {
+          _isInLibrary = newState;
+        });
+
+        if (mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text(S.of(context)!.addedToLibrary),
+              duration: const Duration(seconds: 1),
+            ),
+          );
+        }
+
        _logger.log('Adding album to library: provider=$actualProvider, itemId=$actualItemId');
-        success = await maProvider.addToLibrary(
+        // Fire and forget - API call happens in background
+        maProvider.addToLibrary(
          mediaType: 'album',
          provider: actualProvider,
          itemId: actualItemId,
-        );
+        ).catchError((e) {
+          _logger.log('❌ Failed to add album to library: $e');
+          // Revert on failure
+          if (mounted) {
+            setState(() {
+              _isInLibrary = !newState;
+            });
+          }
+        });
      } else {
        // Remove from library
        int? libraryItemId;
@@ -279,13 +302,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
          return;
        }

-        success = await maProvider.removeFromLibrary(
-          mediaType: 'album',
-          libraryItemId: libraryItemId,
-        );
-      }
-
-      if (success) {
+        // OPTIMISTIC UPDATE: Update UI immediately
        setState(() {
          _isInLibrary = newState;
        });
@@ -293,13 +310,25 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
        if (mounted) {
          ScaffoldMessenger.of(context).showSnackBar(
            SnackBar(
-              content: Text(
-                _isInLibrary ? S.of(context)!.addedToLibrary : S.of(context)!.removedFromLibrary,
-              ),
+              content: Text(S.of(context)!.removedFromLibrary),
              duration: const Duration(seconds: 1),
            ),
          );
        }
+
+        // Fire and forget - API call happens in background
+        maProvider.removeFromLibrary(
+          mediaType: 'album',
+          libraryItemId: libraryItemId,
+        ).catchError((e) {
+          _logger.log('❌ Failed to remove album from library: $e');
+          // Revert on failure
+          if (mounted) {
+            setState(() {
+              _isInLibrary = !newState;
+            });
+          }
+        });
      }
    } catch (e) {
      _logger.log('Error toggling album library: $e');
@@ -529,12 +558,12 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            Text(
              S.of(context)!.addAlbumToQueueOn,
              style: Theme.of(context).textTheme.titleLarge,
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            if (players.isEmpty)
              Padding(
                padding: const EdgeInsets.all(32.0),
@@ -609,12 +638,12 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            Text(
              S.of(context)!.addToQueueOn,
              style: Theme.of(context).textTheme.titleLarge,
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            if (players.isEmpty)
              Padding(
                padding: const EdgeInsets.all(32.0),
@@ -672,8 +701,8 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick

  void _navigateToArtist() {
    // Navigate to the first artist if available
-    if (widget.album.artists != null && widget.album.artists!.isNotEmpty) {
-      final artist = widget.album.artists!.first;
+    if (_displayAlbum.artists != null && _displayAlbum.artists!.isNotEmpty) {
+      final artist = _displayAlbum.artists!.first;
      final maProvider = context.read<MusicAssistantProvider>();
      final imageUrl = maProvider.getImageUrl(artist, size: 256);
      Navigator.push(
@@ -902,7 +931,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                      ),
                    ),
                  ),
-                  const SizedBox(height: 8),
+                  Spacing.vGap8,
                  Hero(
                    tag: HeroTags.artistName + (widget.album.uri ?? widget.album.itemId) + _heroTagSuffix,
                    child: Material(
@@ -913,7 +942,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                        child: Padding(
                          padding: const EdgeInsets.symmetric(vertical: 4.0),
                          child: Text(
-                            widget.album.artistsString,
+                            _displayAlbum.artistsString,
                            style: textTheme.titleMedium?.copyWith(
                              color: colorScheme.onBackground.withOpacity(0.7),
                            ),
@@ -922,7 +951,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                      ),
                    ),
                  ),
-                  const SizedBox(height: 16),
+                  Spacing.vGap16,
                  // Album Description
                  if (_albumDescription != null && _albumDescription!.isNotEmpty) ...[
                    InkWell(
@@ -944,7 +973,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                        ),
                      ),
                    ),
-                    const SizedBox(height: 8),
+                    Spacing.vGap8,
                  ],
                  Row(
                    children: [
@@ -1015,7 +1044,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                          style: FilledButton.styleFrom(
                            padding: EdgeInsets.zero,
                            shape: RoundedRectangleBorder(
-                              borderRadius: BorderRadius.circular(25), // Circular
+                              borderRadius: BorderRadius.circular(Radii.xxl), // Circular
                            ),
                          ),
                          child: Icon(
@@ -1193,7 +1222,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                                        style: FilledButton.styleFrom(
                                          padding: EdgeInsets.zero,
                                          shape: RoundedRectangleBorder(
-                                            borderRadius: BorderRadius.circular(22),
+                                            borderRadius: BorderRadius.circular(Radii.xxl),
                                          ),
                                        ),
                                        child: Icon(
@@ -1216,7 +1245,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                childCount: _tracks.length,
              ),
            ),
-          const SliverToBoxAdapter(child: SizedBox(height: 164)), // Space for bottom nav + mini player
+          SliverToBoxAdapter(child: SizedBox(height: BottomSpacing.withMiniPlayer)), // Space for bottom nav + mini player
        ],
      );
          },
@@ -13,6 +13,7 @@ import '../services/settings_service.dart';
 import '../services/debug_logger.dart';
 import '../utils/page_transitions.dart';
 import '../l10n/app_localizations.dart';
+import '../theme/design_tokens.dart';

 class ArtistDetailsScreen extends StatefulWidget {
  final Artist artist;
@@ -307,7 +308,6 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {

    try {
      final newState = !_isInLibrary;
-      bool success;

      if (newState) {
        // Add to library - MUST use non-library provider
@@ -338,12 +338,35 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
          }
        }

+        // OPTIMISTIC UPDATE: Update UI immediately
+        setState(() {
+          _isInLibrary = newState;
+        });
+
+        if (mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text(S.of(context)!.addedToLibrary),
+              duration: const Duration(seconds: 1),
+            ),
+          );
+        }
+
        _logger.log('Adding artist to library: provider=$actualProvider, itemId=$actualItemId');
-        success = await maProvider.addToLibrary(
+        // Fire and forget - API call happens in background
+        maProvider.addToLibrary(
          mediaType: 'artist',
          provider: actualProvider,
          itemId: actualItemId,
-        );
+        ).catchError((e) {
+          _logger.log('❌ Failed to add artist to library: $e');
+          // Revert on failure
+          if (mounted) {
+            setState(() {
+              _isInLibrary = !newState;
+            });
+          }
+        });
      } else {
        // Remove from library
        int? libraryItemId;
@@ -364,13 +387,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
          return;
        }

-        success = await maProvider.removeFromLibrary(
-          mediaType: 'artist',
-          libraryItemId: libraryItemId,
-        );
-      }
-
-      if (success) {
+        // OPTIMISTIC UPDATE: Update UI immediately
        setState(() {
          _isInLibrary = newState;
        });
@@ -378,13 +395,25 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
        if (mounted) {
          ScaffoldMessenger.of(context).showSnackBar(
            SnackBar(
-              content: Text(
-                _isInLibrary ? S.of(context)!.addedToLibrary : S.of(context)!.removedFromLibrary,
-              ),
+              content: Text(S.of(context)!.removedFromLibrary),
              duration: const Duration(seconds: 1),
            ),
          );
        }
+
+        // Fire and forget - API call happens in background
+        maProvider.removeFromLibrary(
+          mediaType: 'artist',
+          libraryItemId: libraryItemId,
+        ).catchError((e) {
+          _logger.log('❌ Failed to remove artist from library: $e');
+          // Revert on failure
+          if (mounted) {
+            setState(() {
+              _isInLibrary = !newState;
+            });
+          }
+        });
      }
    } catch (e) {
      _logger.log('Error toggling artist library: $e');
@@ -417,12 +446,12 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            Text(
              S.of(context)!.startRadioOn(widget.artist.name),
              style: Theme.of(context).textTheme.titleLarge,
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            if (players.isEmpty)
              Padding(
                padding: const EdgeInsets.all(32.0),
@@ -497,12 +526,12 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            Text(
              S.of(context)!.addToQueueOn,
              style: Theme.of(context).textTheme.titleLarge,
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            if (players.isEmpty)
              Padding(
                padding: const EdgeInsets.all(32.0),
@@ -786,7 +815,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                      ),
                    ),
                  ),
-                  const SizedBox(height: 16),
+                  Spacing.vGap16,
                  if (_artistDescription != null && _artistDescription!.isNotEmpty) ...[
                    InkWell(
                      onTap: () {
@@ -807,7 +836,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                        ),
                      ),
                    ),
-                    const SizedBox(height: 8),
+                    Spacing.vGap8,
                  ],
                  // Action Buttons Row
                  Row(
@@ -861,7 +890,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                          style: FilledButton.styleFrom(
                            padding: EdgeInsets.zero,
                            shape: RoundedRectangleBorder(
-                              borderRadius: BorderRadius.circular(25),
+                              borderRadius: BorderRadius.circular(Radii.xxl),
                            ),
                          ),
                          child: Icon(
@@ -897,7 +926,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                      ),
                    ],
                  ),
-                  const SizedBox(height: 16),
+                  Spacing.vGap16,
                ],
              ),
            ),
@@ -947,7 +976,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                        onPressed: _toggleSortOrder,
                        visualDensity: VisualDensity.compact,
                        padding: EdgeInsets.zero,
-                        constraints: const BoxConstraints(minWidth: 36, minHeight: 36),
+                        constraints: const BoxConstraints(minWidth: 44, minHeight: 44),
                      ),
                      // View mode toggle
                      IconButton(
@@ -968,7 +997,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                        onPressed: _cycleViewMode,
                        visualDensity: VisualDensity.compact,
                        padding: EdgeInsets.zero,
-                        constraints: const BoxConstraints(minWidth: 36, minHeight: 36),
+                        constraints: const BoxConstraints(minWidth: 44, minHeight: 44),
                      ),
                    ],
                  ),
@@ -1004,7 +1033,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                          onPressed: _toggleSortOrder,
                          visualDensity: VisualDensity.compact,
                          padding: EdgeInsets.zero,
-                          constraints: const BoxConstraints(minWidth: 36, minHeight: 36),
+                          constraints: const BoxConstraints(minWidth: 44, minHeight: 44),
                        ),
                        IconButton(
                          icon: Icon(
@@ -1024,7 +1053,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                          onPressed: _cycleViewMode,
                          visualDensity: VisualDensity.compact,
                          padding: EdgeInsets.zero,
-                          constraints: const BoxConstraints(minWidth: 36, minHeight: 36),
+                          constraints: const BoxConstraints(minWidth: 44, minHeight: 44),
                        ),
                      ],
                    ],
@@ -1032,7 +1061,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                ),
              ),
              _buildAlbumSliver(_providerAlbums),
-              const SliverToBoxAdapter(child: SizedBox(height: 140)), // Space for bottom nav + mini player
+              SliverToBoxAdapter(child: SizedBox(height: BottomSpacing.withMiniPlayer)), // Space for bottom nav + mini player
            ],
          ],
        ],
@@ -1104,7 +1133,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
              ),
            ),
          ),
-          const SizedBox(height: 8),
+          Spacing.vGap8,
          Hero(
            tag: HeroTags.albumTitle + (album.uri ?? album.itemId) + '_$heroSuffix',
            child: Material(
@@ -150,10 +150,16 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
      },
      child: Scaffold(
        backgroundColor: colorScheme.surface,
-        body: CustomScrollView(
+        body: LayoutBuilder(
+          builder: (context, constraints) {
+            // Responsive cover size: 70% of screen width, clamped between 160-280 (same as artist detail)
+            final coverSize = (constraints.maxWidth * 0.7).clamp(160.0, 280.0);
+            final expandedHeight = coverSize + 100;
+
+            return CustomScrollView(
          slivers: [
            SliverAppBar(
-              expandedHeight: 200,
+              expandedHeight: expandedHeight,
              pinned: true,
              backgroundColor: colorScheme.surface,
              leading: IconButton(
@@ -172,37 +178,41 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
                    Hero(
                      tag: HeroTags.authorImage + widget.authorName + _heroTagSuffix,
                      child: Container(
-                        width: 200,
-                        height: 200,
+                        width: coverSize,
+                        height: coverSize,
                        decoration: BoxDecoration(
                          color: colorScheme.primaryContainer,
                          shape: BoxShape.circle,
                        ),
-                        child: ClipOval(
-                          child: _authorImageUrl != null
-                              ? CachedNetworkImage(
-                                  imageUrl: _authorImageUrl!,
-                                  fit: BoxFit.cover,
-                                  width: 200,
-                                  height: 200,
-                                  fadeInDuration: Duration.zero,
-                                  fadeOutDuration: Duration.zero,
-                                  placeholder: (_, __) => Icon(
-                                    MdiIcons.accountOutline,
-                                    size: 100,
-                                    color: colorScheme.onPrimaryContainer,
+                        child: Stack(
+                          alignment: Alignment.center,
+                          children: [
+                            // Icon always present underneath
+                            Icon(
+                              MdiIcons.accountOutline,
+                              size: coverSize * 0.5,
+                              color: colorScheme.onPrimaryContainer,
+                            ),
+                            // Image covers icon when loaded
+                            if (_authorImageUrl != null)
+                              SizedBox(
+                                width: coverSize,
+                                height: coverSize,
+                                child: ClipOval(
+                                  child: CachedNetworkImage(
+                                    imageUrl: _authorImageUrl!,
+                                    fit: BoxFit.cover,
+                                    width: coverSize,
+                                    height: coverSize,
+                                    memCacheWidth: 256,
+                                    fadeInDuration: Duration.zero,
+                                    fadeOutDuration: Duration.zero,
+                                    placeholder: (_, __) => const SizedBox.shrink(),
+                                    errorWidget: (_, __, ___) => const SizedBox.shrink(),
                                  ),
-                                  errorWidget: (_, __, ___) => Icon(
-                                    MdiIcons.accountOutline,
-                                    size: 100,
-                                    color: colorScheme.onPrimaryContainer,
-                                  ),
-                                )
-                              : Icon(
-                                  MdiIcons.accountOutline,
-                                  size: 100,
-                                  color: colorScheme.onPrimaryContainer,
                                ),
+                              ),
+                          ],
                        ),
                      ),
                    ),
@@ -287,8 +297,10 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
              ),
            ),
            _buildAudiobookSliver(),
-            const SliverToBoxAdapter(child: SizedBox(height: 140)),
+            SliverToBoxAdapter(child: SizedBox(height: BottomSpacing.withMiniPlayer)),
          ],
+            );
+          },
        ),
      ),
    );
@@ -12,6 +12,7 @@ import '../services/debug_logger.dart';
 import '../services/recently_played_service.dart';
 import '../constants/hero_tags.dart';
 import '../l10n/app_localizations.dart';
+import '../theme/design_tokens.dart';

 class AudiobookDetailScreen extends StatefulWidget {
  final Audiobook audiobook;
@@ -566,7 +567,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                        ),
                      ),
                    ),
-                    const SizedBox(height: 8),
+                    Spacing.vGap8,

                    // Author
                    Text(
@@ -588,7 +589,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                    ],

                    // Duration & Progress
-                    const SizedBox(height: 16),
+                    Spacing.vGap16,
                    Row(
                      children: [
                        if (book.duration != null) ...[
@@ -712,7 +713,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                            style: FilledButton.styleFrom(
                              padding: EdgeInsets.zero,
                              shape: RoundedRectangleBorder(
-                                borderRadius: BorderRadius.circular(25),
+                                borderRadius: BorderRadius.circular(Radii.xxl),
                              ),
                            ),
                            child: Icon(
@@ -736,7 +737,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                          fontWeight: FontWeight.bold,
                        ),
                      ),
-                      const SizedBox(height: 8),
+                      Spacing.vGap8,
                      InkWell(
                        onTap: () {
                          setState(() {
@@ -767,7 +768,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                        fontWeight: FontWeight.bold,
                      ),
                    ),
-                    const SizedBox(height: 8),
+                    Spacing.vGap8,
                  ],
                ),
              ),
@@ -777,7 +778,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
            // Use MA chapters if available, otherwise use ABS chapters
            ..._buildChapterSection(book, colorScheme, textTheme),

-            const SliverToBoxAdapter(child: SizedBox(height: 140)),
+            SliverToBoxAdapter(child: SizedBox(height: BottomSpacing.withMiniPlayer)),
          ],
        );
          },
@@ -9,6 +9,7 @@ import '../theme/theme_provider.dart';
 import '../utils/page_transitions.dart';
 import 'playlist_details_screen.dart';
 import '../l10n/app_localizations.dart';
+import '../theme/design_tokens.dart';

 class LibraryPlaylistsScreen extends StatefulWidget {
  const LibraryPlaylistsScreen({super.key});
@@ -168,7 +169,7 @@ class _LibraryPlaylistsScreenState extends State<LibraryPlaylistsScreen> {
          overflow: TextOverflow.ellipsis,
        ),
        trailing: playlist.favorite == true
-            ? const Icon(Icons.favorite, color: Colors.red, size: 20)
+            ? const Icon(Icons.favorite, color: StatusColors.favorite, size: 20)
            : null,
        onTap: () {
          updateAdaptiveColorsFromImage(context, imageUrl);
@@ -11,6 +11,7 @@ import '../services/recently_played_service.dart';
 import '../widgets/global_player_overlay.dart';
 import '../widgets/player_picker_sheet.dart';
 import '../l10n/app_localizations.dart';
+import '../theme/design_tokens.dart';

 class PlaylistDetailsScreen extends StatefulWidget {
  final Playlist playlist;
@@ -410,12 +411,12 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> with Sing
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            Text(
              S.of(context)!.addToQueueOn,
              style: Theme.of(context).textTheme.titleLarge,
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            if (players.isEmpty)
              Padding(
                padding: const EdgeInsets.all(32.0),
@@ -488,12 +489,12 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> with Sing
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            Text(
              S.of(context)!.addToQueueOn,
              style: Theme.of(context).textTheme.titleLarge,
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            if (players.isEmpty)
              Padding(
                padding: const EdgeInsets.all(32.0),
@@ -758,7 +759,7 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> with Sing
                            ),
                          ),
                        ),
-                        const SizedBox(height: 8),
+                        Spacing.vGap8,
                        // Owner info
                        if (widget.playlist.owner != null)
                          Text(
@@ -775,7 +776,7 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> with Sing
                            color: colorScheme.onSurface.withOpacity(0.5),
                          ),
                        ),
-                        const SizedBox(height: 16),
+                        Spacing.vGap16,
                        // Action buttons row
                        Row(
                          children: [
@@ -846,7 +847,7 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> with Sing
                                style: FilledButton.styleFrom(
                                  padding: EdgeInsets.zero,
                                  shape: RoundedRectangleBorder(
-                                    borderRadius: BorderRadius.circular(25),
+                                    borderRadius: BorderRadius.circular(Radii.xxl),
                                  ),
                                ),
                                child: Icon(
@@ -1031,7 +1032,7 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> with Sing
                                              style: FilledButton.styleFrom(
                                                padding: EdgeInsets.zero,
                                                shape: RoundedRectangleBorder(
-                                                  borderRadius: BorderRadius.circular(22),
+                                                  borderRadius: BorderRadius.circular(Radii.xxl),
                                                ),
                                              ),
                                              child: Icon(
@@ -1054,7 +1055,7 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> with Sing
                      childCount: _tracks.length,
                    ),
                  ),
-                const SliverToBoxAdapter(child: SizedBox(height: 164)), // Space for bottom nav + mini player
+                SliverToBoxAdapter(child: SizedBox(height: BottomSpacing.withMiniPlayer)), // Space for bottom nav + mini player
              ],
            );
          },
@@ -66,7 +66,6 @@ class _PodcastDetailScreenState extends State<PodcastDetailScreen> {

    try {
      final newState = !_isInLibrary;
-      bool success;

      if (newState) {
        // Add to library - MUST use non-library provider
@@ -97,12 +96,35 @@ class _PodcastDetailScreenState extends State<PodcastDetailScreen> {
          }
        }

+        // OPTIMISTIC UPDATE: Update UI immediately
+        setState(() {
+          _isInLibrary = newState;
+        });
+
+        if (mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text(S.of(context)!.addedToLibrary),
+              duration: const Duration(seconds: 1),
+            ),
+          );
+        }
+
        _logger.log('Adding podcast to library: provider=$actualProvider, itemId=$actualItemId');
-        success = await maProvider.addToLibrary(
+        // Fire and forget - API call happens in background
+        maProvider.addToLibrary(
          mediaType: 'podcast',
          provider: actualProvider,
          itemId: actualItemId,
-        );
+        ).catchError((e) {
+          _logger.log('❌ Failed to add podcast to library: $e');
+          // Revert on failure
+          if (mounted) {
+            setState(() {
+              _isInLibrary = !newState;
+            });
+          }
+        });
      } else {
        // Remove from library
        int? libraryItemId;
@@ -123,13 +145,7 @@ class _PodcastDetailScreenState extends State<PodcastDetailScreen> {
          return;
        }

-        success = await maProvider.removeFromLibrary(
-          mediaType: 'podcast',
-          libraryItemId: libraryItemId,
-        );
-      }
-
-      if (success) {
+        // OPTIMISTIC UPDATE: Update UI immediately
        setState(() {
          _isInLibrary = newState;
        });
@@ -137,13 +153,25 @@ class _PodcastDetailScreenState extends State<PodcastDetailScreen> {
        if (mounted) {
          ScaffoldMessenger.of(context).showSnackBar(
            SnackBar(
-              content: Text(
-                _isInLibrary ? S.of(context)!.addedToLibrary : S.of(context)!.removedFromLibrary,
-              ),
+              content: Text(S.of(context)!.removedFromLibrary),
              duration: const Duration(seconds: 1),
            ),
          );
        }
+
+        // Fire and forget - API call happens in background
+        maProvider.removeFromLibrary(
+          mediaType: 'podcast',
+          libraryItemId: libraryItemId,
+        ).catchError((e) {
+          _logger.log('❌ Failed to remove podcast from library: $e');
+          // Revert on failure
+          if (mounted) {
+            setState(() {
+              _isInLibrary = !newState;
+            });
+          }
+        });
      }
    } catch (e) {
      _logger.log('Error toggling podcast library: $e');
@@ -190,10 +218,38 @@ class _PodcastDetailScreenState extends State<PodcastDetailScreen> {
    try {
      final maProvider = context.read<MusicAssistantProvider>();
      if (maProvider.api != null) {
-        final episodes = await maProvider.api!.getPodcastEpisodes(
-          widget.podcast.itemId,
-          provider: widget.podcast.provider,
-        );
+        List<MediaItem> episodes = [];
+
+        // Try loading with the podcast's own ID and provider first
+        try {
+          episodes = await maProvider.api!.getPodcastEpisodes(
+            widget.podcast.itemId,
+            provider: widget.podcast.provider,
+          );
+        } catch (e) {
+          _logger.log('🎙️ Primary episode load failed: $e');
+        }
+
+        // If that failed and we have provider mappings, try those
+        if (episodes.isEmpty && widget.podcast.providerMappings != null) {
+          for (final mapping in widget.podcast.providerMappings!) {
+            if (mapping.itemId.isNotEmpty && mapping.providerInstance.isNotEmpty) {
+              try {
+                _logger.log('🎙️ Trying provider mapping: ${mapping.providerInstance}');
+                episodes = await maProvider.api!.getPodcastEpisodes(
+                  mapping.itemId,
+                  provider: mapping.providerInstance,
+                );
+                if (episodes.isNotEmpty) {
+                  _logger.log('🎙️ Loaded episodes via provider mapping');
+                  break;
+                }
+              } catch (e) {
+                _logger.log('🎙️ Provider mapping failed: $e');
+              }
+            }
+          }
+        }

        if (mounted) {
          _logger.log('🎙️ Loaded ${episodes.length} episodes for ${widget.podcast.name}');
@@ -860,8 +916,8 @@ class _PodcastDetailScreenState extends State<PodcastDetailScreen> {
                  ),

                // Bottom padding for mini player
-                const SliverToBoxAdapter(
-                  child: SizedBox(height: 100),
+                SliverToBoxAdapter(
+                  child: SizedBox(height: BottomSpacing.withMiniPlayer),
                ),
              ],
            );
@@ -4,6 +4,7 @@ import '../providers/music_assistant_provider.dart';
 import '../models/player.dart';
 import '../services/debug_logger.dart';
 import '../widgets/common/empty_state.dart';
+import '../widgets/player_picker_sheet.dart';
 import '../l10n/app_localizations.dart';

 class QueueScreen extends StatefulWidget {
@@ -67,6 +68,68 @@ class _QueueScreenState extends State<QueueScreen> {
    }
  }

+  Future<void> _handleTransferQueue(MusicAssistantProvider maProvider) async {
+    final player = maProvider.selectedPlayer;
+    if (player == null) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text(S.of(context)!.noPlayerSelected)),
+      );
+      return;
+    }
+
+    // Get available players, excluding the current source player
+    final allPlayers = maProvider.availablePlayers;
+    final targetPlayers = allPlayers
+        .where((p) => p.playerId != player.playerId && p.available)
+        .toList();
+
+    if (targetPlayers.isEmpty) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(
+          content: Text(S.of(context)!.noOtherPlayersAvailable),
+          duration: const Duration(seconds: 2),
+        ),
+      );
+      return;
+    }
+
+    // Show player picker sheet
+    await showPlayerPickerSheet(
+      context: context,
+      title: S.of(context)!.transferQueueTo,
+      players: targetPlayers,
+      onPlayerSelected: (targetPlayer) async {
+        try {
+          await maProvider.api?.transferQueue(
+            sourceQueueId: player.playerId,
+            targetQueueId: targetPlayer.playerId,
+            autoPlay: true,
+          );
+
+          if (mounted) {
+            ScaffoldMessenger.of(context).showSnackBar(
+              SnackBar(
+                content: Text(S.of(context)!.queueTransferredTo(targetPlayer.name)),
+                duration: const Duration(seconds: 2),
+              ),
+            );
+          }
+        } catch (e) {
+          _logger.log('Error transferring queue: $e');
+          if (mounted) {
+            ScaffoldMessenger.of(context).showSnackBar(
+              SnackBar(
+                content: Text(S.of(context)!.failedToTransferQueue(e.toString())),
+                backgroundColor: Colors.red.shade700,
+                duration: const Duration(seconds: 3),
+              ),
+            );
+          }
+        }
+      },
+    );
+  }
+
  @override
  Widget build(BuildContext context) {
    final maProvider = context.watch<MusicAssistantProvider>();
@@ -87,6 +150,11 @@ class _QueueScreenState extends State<QueueScreen> {
        ),
        centerTitle: true,
        actions: [
+          IconButton(
+            icon: const Icon(Icons.swap_horiz_rounded),
+            tooltip: S.of(context)!.transferQueue,
+            onPressed: () => _handleTransferQueue(maProvider),
+          ),
          IconButton(
            icon: const Icon(Icons.refresh),
            onPressed: _loadQueue,
@@ -22,6 +22,7 @@ import 'playlist_details_screen.dart';
 import 'audiobook_detail_screen.dart';
 import 'podcast_detail_screen.dart';
 import '../l10n/app_localizations.dart';
+import '../theme/design_tokens.dart';

 class SearchScreen extends StatefulWidget {
  const SearchScreen({super.key});
@@ -168,6 +169,27 @@ class SearchScreenState extends State<SearchScreen> {
    return filters;
  }

+  /// Filter search results by enabled providers (only when in-library mode is on)
+  /// Uses the client-side provider toggles from the library screen
+  Map<String, List<MediaItem>> _filterByEnabledProviders(
+    Map<String, List<MediaItem>> results,
+    Set<String> enabledProviders,
+  ) {
+    if (enabledProviders.isEmpty) return results; // No filter = show all
+
+    bool isItemAllowed(MediaItem item) {
+      final mappings = item.providerMappings;
+      if (mappings == null || mappings.isEmpty) return true; // No mappings = show
+      // Item is allowed if it has inLibrary=true for any enabled provider
+      return mappings.any((m) => m.inLibrary && enabledProviders.contains(m.providerInstance));
+    }
+
+    return {
+      for (final entry in results.entries)
+        entry.key: entry.value.where(isItemAllowed).toList(),
+    };
+  }
+
  /// Animate to a specific filter
  void _animateToFilter(String filter) {
    final filters = _getAvailableFilters();
@@ -427,12 +449,21 @@ class SearchScreenState extends State<SearchScreen> {
      }

      if (mounted) {
+        // Combine all results
+        var combinedResults = {
+          ...results,
+          'radios': allRadios.values.toList(),
+          'podcasts': allPodcasts.values.toList(),
+        };
+
+        // When "in library" mode is on, also filter by enabled providers
+        if (_libraryOnly) {
+          final enabledProviders = provider.enabledProviderIds.toSet();
+          combinedResults = _filterByEnabledProviders(combinedResults, enabledProviders);
+        }
+
        setState(() {
-          _searchResults = {
-            ...results,
-            'radios': allRadios.values.toList(),
-            'podcasts': allPodcasts.values.toList(),
-          };
+          _searchResults = combinedResults;
          _isSearching = false;
          _hasSearched = true;
          _cachedListItems.clear(); // PERF: Clear cache on new results
@@ -486,81 +517,97 @@ class SearchScreenState extends State<SearchScreen> {
              decoration: const BoxDecoration(),
              child: Padding(
                padding: const EdgeInsets.fromLTRB(16, 8, 16, 8),
-                child: Container(
-                  decoration: BoxDecoration(
-                    color: colorScheme.surfaceVariant.withOpacity(0.5),
-                    borderRadius: BorderRadius.circular(12),
-                  ),
-                  child: Row(
-                    children: [
-                      // Search field
-                      Expanded(
-                        child: Padding(
-                          padding: const EdgeInsets.only(left: 16),
-                          child: TextField(
-                            controller: _searchController,
-                            focusNode: _focusNode,
-                            style: TextStyle(color: colorScheme.onSurface),
-                            cursorColor: colorScheme.primary,
-                            textInputAction: TextInputAction.search,
-                            textAlignVertical: TextAlignVertical.center,
-                            decoration: InputDecoration(
-                              isDense: true,
-                              contentPadding: const EdgeInsets.symmetric(vertical: 12),
-                              hintText: S.of(context)!.searchMusic,
-                              hintStyle: TextStyle(color: colorScheme.onSurface.withOpacity(0.5)),
-                              border: InputBorder.none,
-                              suffixIcon: _hasSearchText
-                                  ? IconButton(
-                                      icon: Icon(Icons.clear_rounded, color: colorScheme.onSurface.withOpacity(0.5)),
-                                      onPressed: () {
-                                        _searchController.clear();
-                                        setState(() {
-                                          _hasSearchText = false;
-                                          _searchResults = {'artists': [], 'albums': [], 'tracks': [], 'playlists': [], 'audiobooks': [], 'podcasts': []};
-                                          _hasSearched = false;
-                                          _searchError = null;
-                                          _cachedListItems.clear();
-                                          _cachedAvailableFilters = null;
-                                        });
-                                      },
-                                    )
-                                  : null,
+                child: Row(
+                  children: [
+                    // Search field container
+                    Expanded(
+                      child: Container(
+                        decoration: BoxDecoration(
+                          color: colorScheme.surfaceVariant.withOpacity(0.5),
+                          borderRadius: BorderRadius.circular(12),
+                        ),
+                        child: TextField(
+                          controller: _searchController,
+                          focusNode: _focusNode,
+                          style: TextStyle(color: colorScheme.onSurface),
+                          cursorColor: colorScheme.primary,
+                          textInputAction: TextInputAction.search,
+                          textAlignVertical: TextAlignVertical.center,
+                          decoration: InputDecoration(
+                            isDense: true,
+                            contentPadding: const EdgeInsets.symmetric(vertical: 12),
+                            hintText: S.of(context)!.searchMusic,
+                            hintStyle: TextStyle(color: colorScheme.onSurface.withOpacity(0.5)),
+                            border: InputBorder.none,
+                            prefixIcon: Icon(
+                              Icons.search_rounded,
+                              color: colorScheme.onSurface.withOpacity(0.5),
                            ),
-                            onChanged: (value) {
-                              // PERF: Only rebuild when clear button visibility changes
-                              final hasText = value.isNotEmpty;
-                              if (hasText != _hasSearchText) {
-                                setState(() {
-                                  _hasSearchText = hasText;
-                                });
-                              }
-                              _onSearchChanged(value);
-                            },
-                            onSubmitted: (query) => _performSearch(query),
+                            suffixIcon: _hasSearchText
+                                ? IconButton(
+                                    icon: Icon(Icons.clear_rounded, color: colorScheme.onSurface.withOpacity(0.5)),
+                                    onPressed: () {
+                                      _searchController.clear();
+                                      setState(() {
+                                        _hasSearchText = false;
+                                        _searchResults = {'artists': [], 'albums': [], 'tracks': [], 'playlists': [], 'audiobooks': [], 'podcasts': []};
+                                        _hasSearched = false;
+                                        _searchError = null;
+                                        _cachedListItems.clear();
+                                        _cachedAvailableFilters = null;
+                                      });
+                                    },
+                                  )
+                                : null,
                          ),
-                        ),
-                      ),
-                      // Library-only toggle
-                      Tooltip(
-                        message: S.of(context)!.libraryOnly,
-                        child: IconButton(
-                          icon: Icon(
-                            _libraryOnly ? Icons.library_music : Icons.library_music_outlined,
-                            color: _libraryOnly ? colorScheme.primary : colorScheme.onSurface.withOpacity(0.5),
-                          ),
-                          onPressed: () {
-                            setState(() {
-                              _libraryOnly = !_libraryOnly;
-                            });
-                            if (_searchController.text.isNotEmpty) {
-                              _performSearch(_searchController.text);
+                          onChanged: (value) {
+                            // PERF: Only rebuild when clear button visibility changes
+                            final hasText = value.isNotEmpty;
+                            if (hasText != _hasSearchText) {
+                              setState(() {
+                                _hasSearchText = hasText;
+                              });
                            }
+                            _onSearchChanged(value);
                          },
+                          onSubmitted: (query) => _performSearch(query),
                        ),
                      ),
-                    ],
-                  ),
+                    ),
+                    const SizedBox(width: 8),
+                    // Library-only toggle with circle background
+                    Tooltip(
+                      message: S.of(context)!.libraryOnly,
+                      child: SizedBox(
+                        width: 44,
+                        height: 44,
+                        child: Material(
+                          color: _libraryOnly
+                              ? colorScheme.primary
+                              : colorScheme.surfaceVariant.withOpacity(0.6),
+                          shape: const CircleBorder(),
+                          child: InkWell(
+                            onTap: () {
+                              setState(() {
+                                _libraryOnly = !_libraryOnly;
+                              });
+                              if (_searchController.text.isNotEmpty) {
+                                _performSearch(_searchController.text);
+                              }
+                            },
+                            customBorder: const CircleBorder(),
+                            child: Icon(
+                              _libraryOnly ? Icons.library_music : Icons.library_music_outlined,
+                              size: 22,
+                              color: _libraryOnly
+                                  ? colorScheme.onPrimary
+                                  : colorScheme.onSurface,
+                            ),
+                          ),
+                        ),
+                      ),
+                    ),
+                  ],
                ),
              ),
            ),
@@ -602,7 +649,7 @@ class SearchScreenState extends State<SearchScreen> {
              size: 80,
              color: colorScheme.onBackground.withOpacity(0.3),
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            Text(
              S.of(context)!.searchForContent,
              style: TextStyle(
@@ -655,7 +702,7 @@ class SearchScreenState extends State<SearchScreen> {
              size: 64,
              color: colorScheme.error.withOpacity(0.7),
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            Text(
              _searchError!,
              style: TextStyle(
@@ -664,7 +711,7 @@ class SearchScreenState extends State<SearchScreen> {
              ),
              textAlign: TextAlign.center,
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            FilledButton.tonal(
              onPressed: () => _performSearch(_searchController.text),
              child: Text(S.of(context)!.retry),
@@ -785,7 +832,7 @@ class SearchScreenState extends State<SearchScreen> {
                        end: Alignment.bottomCenter,
                        colors: [
                          colorScheme.background,
-                          colorScheme.surface.withOpacity(0),
+                          colorScheme.background.withOpacity(0),
                        ],
                      ),
                    ),
@@ -1222,7 +1269,7 @@ class SearchScreenState extends State<SearchScreen> {
                            style: FilledButton.styleFrom(
                              padding: EdgeInsets.zero,
                              shape: RoundedRectangleBorder(
-                                borderRadius: BorderRadius.circular(22),
+                                borderRadius: BorderRadius.circular(Radii.xxl),
                              ),
                            ),
                            child: Icon(
@@ -1438,7 +1485,7 @@ class SearchScreenState extends State<SearchScreen> {
                            style: FilledButton.styleFrom(
                              padding: EdgeInsets.zero,
                              shape: RoundedRectangleBorder(
-                                borderRadius: BorderRadius.circular(22),
+                                borderRadius: BorderRadius.circular(Radii.xxl),
                              ),
                            ),
                            child: Icon(
@@ -1632,7 +1679,7 @@ class SearchScreenState extends State<SearchScreen> {
                            style: FilledButton.styleFrom(
                              padding: EdgeInsets.zero,
                              shape: RoundedRectangleBorder(
-                                borderRadius: BorderRadius.circular(22),
+                                borderRadius: BorderRadius.circular(Radii.xxl),
                              ),
                            ),
                            child: Icon(
@@ -1997,7 +2044,7 @@ class SearchScreenState extends State<SearchScreen> {
                            style: FilledButton.styleFrom(
                              padding: EdgeInsets.zero,
                              shape: RoundedRectangleBorder(
-                                borderRadius: BorderRadius.circular(22),
+                                borderRadius: BorderRadius.circular(Radii.xxl),
                              ),
                            ),
                            child: Icon(
@@ -2368,7 +2415,7 @@ class SearchScreenState extends State<SearchScreen> {
    } catch (e) {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Failed to play radio station: $e')),
+          SnackBar(content: Text(S.of(context)!.failedToPlayRadioStation(e.toString()))),
        );
      }
    }
@@ -2565,7 +2612,7 @@ class SearchScreenState extends State<SearchScreen> {
      _logger.log('Error toggling favorite: $e');
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Failed to update favorite: $e')),
+          SnackBar(content: Text(S.of(context)!.failedToUpdateFavorite(e.toString()))),
        );
      }
    }
@@ -2616,7 +2663,7 @@ class SearchScreenState extends State<SearchScreen> {
        // Item is library-only, can't add
        if (mounted) {
          ScaffoldMessenger.of(context).showSnackBar(
-            SnackBar(content: Text('Item is already in library')),
+            SnackBar(content: Text(S.of(context)!.itemAlreadyInLibrary)),
          );
        }
        return;
@@ -2652,7 +2699,7 @@ class SearchScreenState extends State<SearchScreen> {
        if (mounted) {
          setState(() {});
          ScaffoldMessenger.of(context).showSnackBar(
-            SnackBar(content: Text('Failed to add to library')),
+            SnackBar(content: Text(S.of(context)!.failedToAddToLibrary)),
          );
        }
      }
@@ -2679,7 +2726,7 @@ class SearchScreenState extends State<SearchScreen> {

    if (libraryItemId == null) {
      ScaffoldMessenger.of(context).showSnackBar(
-        SnackBar(content: Text('Cannot find library ID for removal')),
+        SnackBar(content: Text(S.of(context)!.cannotFindLibraryId)),
      );
      return;
    }
@@ -2711,7 +2758,7 @@ class SearchScreenState extends State<SearchScreen> {
        if (mounted) {
          setState(() {});
          ScaffoldMessenger.of(context).showSnackBar(
-            SnackBar(content: Text('Failed to remove from library')),
+            SnackBar(content: Text(S.of(context)!.failedToRemoveFromLibrary)),
          );
        }
      }
@@ -2855,7 +2902,7 @@ class SearchScreenState extends State<SearchScreen> {
      _logger.log('Error toggling artist favorite: $e');
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Failed to update favorite: $e')),
+          SnackBar(content: Text(S.of(context)!.failedToUpdateFavorite(e.toString()))),
        );
      }
    }
@@ -2886,7 +2933,7 @@ class SearchScreenState extends State<SearchScreen> {
    } catch (e) {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Failed to play album: $e')),
+          SnackBar(content: Text(S.of(context)!.failedToPlayAlbum(e.toString()))),
        );
      }
    }
@@ -2910,7 +2957,7 @@ class SearchScreenState extends State<SearchScreen> {
          if (mounted) {
            ScaffoldMessenger.of(context).showSnackBar(
              SnackBar(
-                content: Text('Playing ${album.name} on ${player.name}'),
+                content: Text(S.of(context)!.playingOnPlayer(album.name, player.name)),
                duration: const Duration(seconds: 1),
              ),
            );
@@ -2918,7 +2965,7 @@ class SearchScreenState extends State<SearchScreen> {
        } catch (e) {
          if (mounted) {
            ScaffoldMessenger.of(context).showSnackBar(
-              SnackBar(content: Text('Failed to play album: $e')),
+              SnackBar(content: Text(S.of(context)!.failedToPlayAlbum(e.toString()))),
            );
          }
        }
@@ -3034,7 +3081,7 @@ class SearchScreenState extends State<SearchScreen> {
      _logger.log('Error toggling album favorite: $e');
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Failed to update favorite: $e')),
+          SnackBar(content: Text(S.of(context)!.failedToUpdateFavorite(e.toString()))),
        );
      }
    }
@@ -3065,7 +3112,7 @@ class SearchScreenState extends State<SearchScreen> {
    } catch (e) {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Failed to play playlist: $e')),
+          SnackBar(content: Text(S.of(context)!.failedToPlayPlaylist(e.toString()))),
        );
      }
    }
@@ -3089,7 +3136,7 @@ class SearchScreenState extends State<SearchScreen> {
          if (mounted) {
            ScaffoldMessenger.of(context).showSnackBar(
              SnackBar(
-                content: Text('Playing ${playlist.name} on ${player.name}'),
+                content: Text(S.of(context)!.playingOnPlayer(playlist.name, player.name)),
                duration: const Duration(seconds: 1),
              ),
            );
@@ -3097,7 +3144,7 @@ class SearchScreenState extends State<SearchScreen> {
        } catch (e) {
          if (mounted) {
            ScaffoldMessenger.of(context).showSnackBar(
-              SnackBar(content: Text('Failed to play playlist: $e')),
+              SnackBar(content: Text(S.of(context)!.failedToPlayPlaylist(e.toString()))),
            );
          }
        }
@@ -3124,7 +3171,7 @@ class SearchScreenState extends State<SearchScreen> {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
-            content: Text('Playing ${audiobook.name}'),
+            content: Text(S.of(context)!.playing(audiobook.name)),
            duration: const Duration(seconds: 1),
          ),
        );
@@ -3132,7 +3179,7 @@ class SearchScreenState extends State<SearchScreen> {
    } catch (e) {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Failed to play audiobook: $e')),
+          SnackBar(content: Text(S.of(context)!.failedToPlayAudiobook(e.toString()))),
        );
      }
    }
@@ -3156,7 +3203,7 @@ class SearchScreenState extends State<SearchScreen> {
          if (mounted) {
            ScaffoldMessenger.of(context).showSnackBar(
              SnackBar(
-                content: Text('Playing ${audiobook.name} on ${player.name}'),
+                content: Text(S.of(context)!.playingOnPlayer(audiobook.name, player.name)),
                duration: const Duration(seconds: 1),
              ),
            );
@@ -3164,7 +3211,7 @@ class SearchScreenState extends State<SearchScreen> {
        } catch (e) {
          if (mounted) {
            ScaffoldMessenger.of(context).showSnackBar(
-              SnackBar(content: Text('Failed to play audiobook: $e')),
+              SnackBar(content: Text(S.of(context)!.failedToPlayAudiobook(e.toString()))),
            );
          }
        }
@@ -3249,7 +3296,7 @@ class SearchScreenState extends State<SearchScreen> {
      _logger.log('Error toggling audiobook favorite: $e');
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Failed to update favorite: $e')),
+          SnackBar(content: Text(S.of(context)!.failedToUpdateFavorite(e.toString()))),
        );
      }
    }
@@ -3273,7 +3320,7 @@ class SearchScreenState extends State<SearchScreen> {
          if (mounted) {
            ScaffoldMessenger.of(context).showSnackBar(
              SnackBar(
-                content: Text('Playing ${radio.name} on ${player.name}'),
+                content: Text(S.of(context)!.playingOnPlayer(radio.name, player.name)),
                duration: const Duration(seconds: 1),
              ),
            );
@@ -3281,7 +3328,7 @@ class SearchScreenState extends State<SearchScreen> {
        } catch (e) {
          if (mounted) {
            ScaffoldMessenger.of(context).showSnackBar(
-              SnackBar(content: Text('Failed to play radio station: $e')),
+              SnackBar(content: Text(S.of(context)!.failedToPlayRadioStation(e.toString()))),
            );
          }
        }
@@ -38,17 +38,12 @@ class _SettingsScreenState extends State<SettingsScreen> {
  bool _showDiscoverSeries = false;
  // Home row order
  List<String> _homeRowOrder = List.from(SettingsService.defaultHomeRowOrder);
-  // Audiobook libraries
-  List<Map<String, String>> _discoveredLibraries = [];
-  Map<String, bool> _libraryEnabled = {};
  // Player settings
  bool _preferLocalPlayer = false;
  bool _smartSortPlayers = false;
  bool _volumePrecisionMode = true;
  // Hint settings
  bool _showHints = true;
-  // Library settings
-  bool _showOnlyArtistsWithAlbums = false;

  @override
  void initState() {
@@ -86,16 +81,6 @@ class _SettingsScreenState extends State<SettingsScreen> {
    // Load home row order
    final rowOrder = await SettingsService.getHomeRowOrder();

-    // Load audiobook library settings
-    final discovered = await SettingsService.getDiscoveredAbsLibraries() ?? [];
-    final enabled = await SettingsService.getEnabledAbsLibraries();
-    final libraryEnabled = <String, bool>{};
-    for (final lib in discovered) {
-      final path = lib['path'] ?? '';
-      // null means all enabled
-      libraryEnabled[path] = enabled == null || enabled.contains(path);
-    }
-
    // Load player settings
    final preferLocal = await SettingsService.getPreferLocalPlayer();
    final smartSort = await SettingsService.getSmartSortPlayers();
@@ -104,9 +89,6 @@ class _SettingsScreenState extends State<SettingsScreen> {
    // Load hint settings
    final showHints = await SettingsService.getShowHints();

-    // Load library settings
-    final showOnlyArtistsWithAlbums = await SettingsService.getShowOnlyArtistsWithAlbums();
-
    if (mounted) {
      setState(() {
        _showRecentAlbums = showRecent;
@@ -122,13 +104,10 @@ class _SettingsScreenState extends State<SettingsScreen> {
        _showDiscoverAudiobooks = showDiscAudiobooks;
        _showDiscoverSeries = showDiscSeries;
        _homeRowOrder = rowOrder;
-        _discoveredLibraries = discovered;
-        _libraryEnabled = libraryEnabled;
        _preferLocalPlayer = preferLocal;
        _smartSortPlayers = smartSort;
        _volumePrecisionMode = volumePrecision;
        _showHints = showHints;
-        _showOnlyArtistsWithAlbums = showOnlyArtistsWithAlbums;
      });
    }
  }
@@ -649,7 +628,7 @@ class _SettingsScreenState extends State<SettingsScreen> {
                            children: [
                              RadioListTile<String?>(
                                title: Text(S.of(context)!.system),
-                                subtitle: const Text('Auto'),
+                                subtitle: Text(S.of(context)!.auto),
                                value: null,
                                groupValue: localeProvider.locale?.languageCode,
                                onChanged: (value) {
@@ -658,7 +637,7 @@ class _SettingsScreenState extends State<SettingsScreen> {
                                },
                              ),
                              RadioListTile<String?>(
-                                title: const Text('English'),
+                                title: Text(S.of(context)!.english),
                                value: 'en',
                                groupValue: localeProvider.locale?.languageCode,
                                onChanged: (value) {
@@ -667,7 +646,7 @@ class _SettingsScreenState extends State<SettingsScreen> {
                                },
                              ),
                              RadioListTile<String?>(
-                                title: const Text('Deutsch'),
+                                title: Text(S.of(context)!.german),
                                value: 'de',
                                groupValue: localeProvider.locale?.languageCode,
                                onChanged: (value) {
@@ -676,7 +655,7 @@ class _SettingsScreenState extends State<SettingsScreen> {
                                },
                              ),
                              RadioListTile<String?>(
-                                title: const Text('Español'),
+                                title: Text(S.of(context)!.spanish),
                                value: 'es',
                                groupValue: localeProvider.locale?.languageCode,
                                onChanged: (value) {
@@ -685,7 +664,7 @@ class _SettingsScreenState extends State<SettingsScreen> {
                                },
                              ),
                              RadioListTile<String?>(
-                                title: const Text('Français'),
+                                title: Text(S.of(context)!.french),
                                value: 'fr',
                                groupValue: localeProvider.locale?.languageCode,
                                onChanged: (value) {
@@ -834,49 +813,6 @@ class _SettingsScreenState extends State<SettingsScreen> {

            const SizedBox(height: 32),

-            // Library section
-            Text(
-              S.of(context)!.library,
-              style: textTheme.titleMedium?.copyWith(
-                color: colorScheme.onBackground,
-                fontWeight: FontWeight.bold,
-              ),
-            ),
-            const SizedBox(height: 16),
-            Container(
-              padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
-              decoration: BoxDecoration(
-                color: colorScheme.surfaceVariant.withOpacity(0.3),
-                borderRadius: BorderRadius.circular(12),
-              ),
-              child: SwitchListTile(
-                title: Text(
-                  'Show only artists with albums',
-                  style: TextStyle(color: colorScheme.onSurface),
-                ),
-                subtitle: Text(
-                  'Hide artists that have no albums in your library',
-                  style: TextStyle(
-                    color: colorScheme.onSurface.withOpacity(0.6),
-                    fontSize: 12,
-                  ),
-                ),
-                value: _showOnlyArtistsWithAlbums,
-                onChanged: (value) async {
-                  setState(() => _showOnlyArtistsWithAlbums = value);
-                  await SettingsService.setShowOnlyArtistsWithAlbums(value);
-                  // Force sync library to apply the new filter at API level
-                  if (mounted) {
-                    context.read<MusicAssistantProvider>().forceLibrarySync();
-                  }
-                },
-                activeColor: colorScheme.primary,
-                contentPadding: EdgeInsets.zero,
-              ),
-            ),
-
-            const SizedBox(height: 32),
-
            // Home Screen section
            Text(
              S.of(context)!.homeScreen,
@@ -1053,76 +989,6 @@ class _SettingsScreenState extends State<SettingsScreen> {

            const SizedBox(height: 32),

-            // Audiobook Libraries section
-            if (_discoveredLibraries.isNotEmpty) ...[
-              Text(
-                S.of(context)!.audiobookLibraries,
-                style: textTheme.titleMedium?.copyWith(
-                  color: colorScheme.onBackground,
-                  fontWeight: FontWeight.bold,
-                ),
-              ),
-              const SizedBox(height: 8),
-              Text(
-                S.of(context)!.chooseAudiobookLibraries,
-                style: textTheme.bodySmall?.copyWith(
-                  color: colorScheme.onBackground.withOpacity(0.6),
-                ),
-              ),
-              const SizedBox(height: 16),
-
-              Container(
-                decoration: BoxDecoration(
-                  color: colorScheme.surfaceVariant.withOpacity(0.3),
-                  borderRadius: BorderRadius.circular(12),
-                ),
-                child: Column(
-                  children: _discoveredLibraries.asMap().entries.map((entry) {
-                    final index = entry.key;
-                    final library = entry.value;
-                    final path = library['path'] ?? '';
-                    final name = library['name'] ?? S.of(context)!.unknownLibrary;
-                    final isEnabled = _libraryEnabled[path] ?? true;
-
-                    return Column(
-                      children: [
-                        SwitchListTile(
-                          title: Text(
-                            name,
-                            style: TextStyle(color: colorScheme.onSurface),
-                          ),
-                          value: isEnabled,
-                          onChanged: (value) async {
-                            setState(() {
-                              _libraryEnabled[path] = value;
-                            });
-                            await SettingsService.toggleAbsLibrary(path, value);
-                            if (mounted) {
-                              ScaffoldMessenger.of(context).showSnackBar(
-                                SnackBar(
-                                  content: Text(S.of(context)!.pullToRefresh),
-                                  duration: const Duration(seconds: 2),
-                                ),
-                              );
-                            }
-                          },
-                          activeColor: colorScheme.primary,
-                        ),
-                        if (index < _discoveredLibraries.length - 1)
-                          Divider(
-                            height: 1,
-                            indent: 16,
-                            endIndent: 16,
-                            color: colorScheme.onSurface.withOpacity(0.1),
-                          ),
-                      ],
-                    );
-                  }).toList(),
-                ),
-              ),
-              const SizedBox(height: 32),
-            ],
-
            SizedBox(
              width: double.infinity,
              height: 50,
@@ -213,6 +213,20 @@ class CacheService {
    _logger.log('🗑️ Home artist caches invalidated');
  }

+  /// Clear discover caches (call when provider filter changes)
+  /// This ensures discover rows are refetched with the new provider filter
+  void clearDiscoverCaches() {
+    _cachedDiscoverArtists = null;
+    _discoverArtistsLastFetched = null;
+    _cachedDiscoverAlbums = null;
+    _discoverAlbumsLastFetched = null;
+    _cachedRecentAlbums = null;
+    _recentAlbumsLastFetched = null;
+    _searchCache.clear();
+    _searchCacheTime.clear();
+    _logger.log('🗑️ Discover caches cleared for provider filter change');
+  }
+
  // ============================================================================
  // DETAIL SCREEN CACHING
  // ============================================================================
@@ -107,15 +107,18 @@ class DatabaseService {
  // ============================================

  /// Cache an item with JSON serialization
+  /// [sourceProvider] - optional provider instance ID that provided this item (for client-side filtering)
  Future<void> cacheItem<T>({
    required String itemType,
    required String itemId,
    required Map<String, dynamic> data,
+    String? sourceProvider,
  }) {
    return db.cacheItem(
      itemType: itemType,
      itemId: itemId,
      data: jsonEncode(data),
+      sourceProvider: sourceProvider,
    );
  }

@@ -132,6 +135,29 @@ class DatabaseService {
    }).where((item) => item.isNotEmpty).toList();
  }

+  /// Get cached items with source provider info for client-side filtering
+  /// Returns list of (data, sourceProviders) tuples
+  Future<List<(Map<String, dynamic>, List<String>)>> getCachedItemsWithProviders(String itemType) async {
+    final items = await db.getCachedItems(itemType);
+    return items.map((item) {
+      try {
+        final data = jsonDecode(item.data) as Map<String, dynamic>;
+        List<String> providers = [];
+        try {
+          if (item.sourceProviders.isNotEmpty && item.sourceProviders != '[]') {
+            providers = List<String>.from(
+              jsonDecode(item.sourceProviders) as List,
+            );
+          }
+        } catch (_) {}
+        return (data, providers);
+      } catch (e) {
+        _logger.log('Error decoding cached item: $e');
+        return (<String, dynamic>{}, <String>[]);
+      }
+    }).where((item) => item.$1.isNotEmpty).toList();
+  }
+
  /// Get a single cached item
  Future<Map<String, dynamic>?> getCachedItem(String itemType, String itemId) async {
    final item = await db.getCachedItem(itemType, itemId);
@@ -326,120 +326,301 @@ class MetadataService {
    return null;
  }

-  /// Fetches author image URL from multiple sources
-  /// Priority: 1. Audnexus, 2. Open Library, 3. Wikipedia
-  /// Returns the image URL if found, null otherwise
-  static Future<String?> getAuthorImageUrl(String authorName) async {
-    // Check cache first
-    final cacheKey = 'authorImage:$authorName';
-    if (_authorImageCache.containsKey(cacheKey)) {
-      return _authorImageCache[cacheKey];
+  /// Generate name variations for fuzzy matching
+  /// Returns a list of name variations to try, in priority order
+  static List<String> _generateNameVariations(String authorName) {
+    final variations = <String>[];
+    final original = authorName.trim();
+
+    // Always try original first
+    variations.add(original);
+
+    // Handle "Lastname, Firstname" format
+    if (original.contains(',')) {
+      final parts = original.split(',').map((p) => p.trim()).toList();
+      if (parts.length == 2) {
+        variations.add('${parts[1]} ${parts[0]}'); // "Firstname Lastname"
+      }
    }

-    // Try Audnexus (specifically for audiobook authors, uses Audible data)
+    // Normalize and expand initials for better matching
+    // Handles messy formats like "J. R.R Tolkien", "J.R.R. Tolkien", etc.
+    String normalized = original;
+
+    // First, normalize spacing around periods in initials: "R.R" -> "R. R", "J. R" -> "J. R"
+    // Match single letter followed by period and optional space, then another letter
+    normalized = normalized.replaceAllMapped(
+      RegExp(r'([A-Z])\.(\s?)([A-Z])'),
+      (m) => '${m.group(1)}. ${m.group(3)}',
+    );
+
+    // Also handle single letters without periods followed by period-letter: "R.R" in "J. R.R"
+    // This catches the case where we have "R.R" as a unit
+    normalized = normalized.replaceAllMapped(
+      RegExp(r'(\s)([A-Z])\.([A-Z])'),
+      (m) => '${m.group(1)}${m.group(2)}. ${m.group(3)}.',
+    );
+
+    // Add periods to standalone single uppercase letters (initials without periods)
+    // "J. R. R Tolkien" -> "J. R. R. Tolkien"
+    normalized = normalized.replaceAllMapped(
+      RegExp(r'(\s)([A-Z])(\s)'),
+      (m) => '${m.group(1)}${m.group(2)}.${m.group(3)}',
+    );
+
+    if (normalized != original && !variations.contains(normalized)) {
+      variations.add(normalized);
+    }
+
+    // Remove common titles
+    final titles = ['Dr.', 'Dr', 'Mr.', 'Mr', 'Mrs.', 'Mrs', 'Ms.', 'Ms',
+                    'Prof.', 'Prof', 'Professor', 'Sir', 'Dame', 'Lord', 'Lady'];
+    String withoutTitle = original;
+    for (final title in titles) {
+      if (withoutTitle.toLowerCase().startsWith(title.toLowerCase() + ' ')) {
+        withoutTitle = withoutTitle.substring(title.length).trim();
+        if (withoutTitle != original) {
+          variations.add(withoutTitle);
+        }
+        break;
+      }
+    }
+
+    // Remove suffixes
+    final suffixes = [', Jr.', ', Jr', ' Jr.', ' Jr', ', Sr.', ', Sr', ' Sr.', ' Sr',
+                      ', III', ' III', ', II', ' II', ', IV', ' IV', ', PhD', ', Ph.D.'];
+    String withoutSuffix = withoutTitle;
+    for (final suffix in suffixes) {
+      if (withoutSuffix.toLowerCase().endsWith(suffix.toLowerCase())) {
+        withoutSuffix = withoutSuffix.substring(0, withoutSuffix.length - suffix.length).trim();
+        if (withoutSuffix != withoutTitle && !variations.contains(withoutSuffix)) {
+          variations.add(withoutSuffix);
+        }
+        break;
+      }
+    }
+
+    // Split into parts for further variations (use normalized name for better splitting)
+    final nameToSplit = normalized != original ? normalized : withoutSuffix;
+    final parts = nameToSplit.split(RegExp(r'\s+')).where((p) => p.isNotEmpty).toList();
+
+    if (parts.length >= 2) {
+      // Try first + last only (skip middle names/initials)
+      final firstLast = '${parts.first} ${parts.last}';
+      if (!variations.contains(firstLast)) {
+        variations.add(firstLast);
+      }
+
+      // Check if name starts with initials (single letter or letter with period)
+      bool isInitial(String s) => s.length == 1 || (s.length == 2 && s.endsWith('.'));
+
+      // If first part looks like an initial, try just the last name
+      if (isInitial(parts.first)) {
+        if (!variations.contains(parts.last)) {
+          variations.add(parts.last);
+        }
+      }
+
+      // Handle multiple initials like "J. K. Rowling" or "J. R. R. Tolkien"
+      // Find where initials end and actual name begins
+      int initialsEnd = 0;
+      for (int i = 0; i < parts.length - 1; i++) {
+        if (isInitial(parts[i])) {
+          initialsEnd = i + 1;
+        } else {
+          break;
+        }
+      }
+
+      if (initialsEnd > 0 && initialsEnd < parts.length) {
+        // Try the non-initial part of the name
+        final restOfName = parts.sublist(initialsEnd).join(' ');
+        if (restOfName.isNotEmpty && !variations.contains(restOfName)) {
+          variations.add(restOfName);
+        }
+
+        // Also try initials without periods + last name (e.g., "JRR Tolkien", "JK Rowling")
+        final initialsNoPeriods = parts.sublist(0, initialsEnd)
+            .map((s) => s.replaceAll('.', ''))
+            .join('');
+        final compactInitials = '$initialsNoPeriods ${parts.last}';
+        if (!variations.contains(compactInitials)) {
+          variations.add(compactInitials);
+        }
+      }
+    }
+
+    // Remove duplicates while preserving order
+    return variations.toSet().toList();
+  }
+
+  /// Try to fetch author image from Audnexus
+  /// Audnexus requires a two-step process:
+  /// 1. Search by name to get the ASIN
+  /// 2. Fetch full author details by ASIN to get the image
+  static Future<String?> _tryAudnexus(String name) async {
    try {
-      final audnexusUri = Uri.https(
-        'api.audnex.us',
-        '/authors',
-        {'name': authorName},
-      );
+      // Step 1: Search for author to get ASIN
+      final searchUri = Uri.https('api.audnex.us', '/authors', {'name': name});
+      final searchResponse = await http.get(searchUri).timeout(const Duration(seconds: 5));

-      final audnexusResponse = await http.get(audnexusUri).timeout(const Duration(seconds: 5));
+      if (searchResponse.statusCode == 200) {
+        final searchData = json.decode(searchResponse.body);
+        if (searchData is List && searchData.isNotEmpty) {
+          // Find the best match - prefer exact name matches
+          String? bestAsin;
+          final nameLower = name.toLowerCase().replaceAll(RegExp(r'[.\s]+'), '');

-      if (audnexusResponse.statusCode == 200) {
-        final data = json.decode(audnexusResponse.body);
-        // Audnexus returns an array of authors
-        if (data is List && data.isNotEmpty) {
-          final author = data[0];
-          final imageUrl = author['image'] as String?;
-          if (imageUrl != null && imageUrl.isNotEmpty) {
-            _authorImageCache[cacheKey] = imageUrl;
-            return imageUrl;
+          for (final result in searchData) {
+            final resultName = (result['name'] as String?)?.toLowerCase().replaceAll(RegExp(r'[.\s]+'), '');
+            final asin = result['asin'] as String?;
+            if (asin != null) {
+              if (resultName == nameLower) {
+                bestAsin = asin;
+                break; // Exact match found
+              }
+              bestAsin ??= asin; // Keep first result as fallback
+            }
+          }
+
+          if (bestAsin != null) {
+            // Step 2: Fetch full author details by ASIN
+            final detailsUri = Uri.https('api.audnex.us', '/authors/$bestAsin');
+            final detailsResponse = await http.get(detailsUri).timeout(const Duration(seconds: 5));
+
+            if (detailsResponse.statusCode == 200) {
+              final detailsData = json.decode(detailsResponse.body);
+              final imageUrl = detailsData['image'] as String?;
+              if (imageUrl != null && imageUrl.isNotEmpty) {
+                return imageUrl;
+              }
+            }
          }
        }
      }
    } catch (e) {
-      _logger.warning('Audnexus author image error: $e', context: 'Metadata');
+      _logger.warning('Audnexus author image error for "$name": $e', context: 'Metadata');
    }
+    return null;
+  }

-    // Fall back to Open Library API
+  /// Try to fetch author image from Open Library
+  static Future<String?> _tryOpenLibrary(String name) async {
    try {
-      final uri = Uri.https(
-        'openlibrary.org',
-        '/search/authors.json',
-        {
-          'q': authorName,
-          'limit': '1',
-        },
-      );
-
+      final uri = Uri.https('openlibrary.org', '/search/authors.json', {
+        'q': name,
+        'limit': '1',
+      });
      final response = await http.get(uri).timeout(const Duration(seconds: 5));

      if (response.statusCode == 200) {
        final data = json.decode(response.body);
        final authors = data['docs'] as List?;
        if (authors != null && authors.isNotEmpty) {
-          final author = authors[0];
-          final authorKey = author['key'] as String?;
+          final authorKey = authors[0]['key'] as String?;
          if (authorKey != null) {
-            // Open Library author images are available at:
-            // https://covers.openlibrary.org/a/olid/{OLID}-L.jpg
            final olid = authorKey.replaceAll('/authors/', '');
            final imageUrl = 'https://covers.openlibrary.org/a/olid/$olid-L.jpg';

-            // Verify the image actually exists (Open Library returns 404 for missing images)
+            // Verify image exists - Open Library returns 302 redirects for valid images
            try {
-              final imageCheck = await http.head(Uri.parse(imageUrl)).timeout(const Duration(seconds: 3));
-              if (imageCheck.statusCode == 200) {
-                _authorImageCache[cacheKey] = imageUrl;
+              final check = await http.head(Uri.parse(imageUrl)).timeout(const Duration(seconds: 3));
+              // Accept 200 (direct), 301/302 (redirect to archive.org), or 307/308 (temporary redirect)
+              if (check.statusCode == 200 || check.statusCode == 301 ||
+                  check.statusCode == 302 || check.statusCode == 307 || check.statusCode == 308) {
                return imageUrl;
              }
-            } catch (_) {
-              // Image doesn't exist, continue to cache null
+            } catch (_) {}
+          }
+        }
+      }
+    } catch (e) {
+      _logger.warning('Open Library author image error for "$name": $e', context: 'Metadata');
+    }
+    return null;
+  }
+
+  /// Try to fetch author image from Wikidata (structured Wikipedia data)
+  static Future<String?> _tryWikidata(String name) async {
+    try {
+      // Search for entity by name
+      final searchUri = Uri.https('www.wikidata.org', '/w/api.php', {
+        'action': 'wbsearchentities',
+        'search': name,
+        'language': 'en',
+        'type': 'item',
+        'limit': '3',
+        'format': 'json',
+      });
+      final searchResponse = await http.get(searchUri).timeout(const Duration(seconds: 5));
+
+      if (searchResponse.statusCode == 200) {
+        final searchData = json.decode(searchResponse.body);
+        final results = searchData['search'] as List?;
+
+        // Try each result to find one with an image
+        for (final result in results ?? []) {
+          final entityId = result['id'] as String?;
+          if (entityId == null) continue;
+
+          // Get the image property (P18)
+          final claimsUri = Uri.https('www.wikidata.org', '/w/api.php', {
+            'action': 'wbgetclaims',
+            'entity': entityId,
+            'property': 'P18', // P18 is the "image" property
+            'format': 'json',
+          });
+          final claimsResponse = await http.get(claimsUri).timeout(const Duration(seconds: 5));
+
+          if (claimsResponse.statusCode == 200) {
+            final claimsData = json.decode(claimsResponse.body);
+            final claims = claimsData['claims'] as Map<String, dynamic>?;
+            final imageProperty = claims?['P18'] as List?;
+
+            if (imageProperty != null && imageProperty.isNotEmpty) {
+              final imageName = imageProperty[0]['mainsnak']?['datavalue']?['value'] as String?;
+              if (imageName != null && imageName.isNotEmpty) {
+                // Convert filename to Wikimedia Commons URL
+                final encodedName = Uri.encodeComponent(imageName.replaceAll(' ', '_'));
+                return 'https://commons.wikimedia.org/wiki/Special:FilePath/$encodedName?width=500';
+              }
            }
          }
        }
      }
    } catch (e) {
-      _logger.warning('Open Library author image error: $e', context: 'Metadata');
+      _logger.warning('Wikidata author image error for "$name": $e', context: 'Metadata');
    }
+    return null;
+  }

-    // Fall back to Wikipedia API
+  /// Try to fetch author image from Wikipedia
+  static Future<String?> _tryWikipedia(String name) async {
    try {
-      // Search for author on Wikipedia
-      final searchUri = Uri.https(
-        'en.wikipedia.org',
-        '/w/api.php',
-        {
-          'action': 'query',
-          'list': 'search',
-          'srsearch': '$authorName writer',
-          'srlimit': '1',
-          'format': 'json',
-        },
-      );
-
+      // Search for author - "writer author" suffix helps find the right page
+      final searchUri = Uri.https('en.wikipedia.org', '/w/api.php', {
+        'action': 'query',
+        'list': 'search',
+        'srsearch': '$name writer author',
+        'srlimit': '1',
+        'format': 'json',
+      });
      final searchResponse = await http.get(searchUri).timeout(const Duration(seconds: 5));

      if (searchResponse.statusCode == 200) {
        final searchData = json.decode(searchResponse.body);
-        final searchResults = searchData['query']?['search'] as List?;
-        if (searchResults != null && searchResults.isNotEmpty) {
-          final pageTitle = searchResults[0]['title'] as String?;
+        final results = searchData['query']?['search'] as List?;
+        if (results != null && results.isNotEmpty) {
+          final pageTitle = results[0]['title'] as String?;
          if (pageTitle != null) {
            // Get page image
-            final imageUri = Uri.https(
-              'en.wikipedia.org',
-              '/w/api.php',
-              {
-                'action': 'query',
-                'titles': pageTitle,
-                'prop': 'pageimages',
-                'pithumbsize': '500',
-                'format': 'json',
-              },
-            );
-
+            final imageUri = Uri.https('en.wikipedia.org', '/w/api.php', {
+              'action': 'query',
+              'titles': pageTitle,
+              'prop': 'pageimages',
+              'pithumbsize': '500',
+              'format': 'json',
+            });
            final imageResponse = await http.get(imageUri).timeout(const Duration(seconds: 5));

            if (imageResponse.statusCode == 200) {
@@ -450,7 +631,6 @@ class MetadataService {
                final thumbnail = page?['thumbnail'] as Map<String, dynamic>?;
                final imageUrl = thumbnail?['source'] as String?;
                if (imageUrl != null && imageUrl.isNotEmpty) {
-                  _authorImageCache[cacheKey] = imageUrl;
                  return imageUrl;
                }
              }
@@ -459,7 +639,100 @@ class MetadataService {
        }
      }
    } catch (e) {
-      _logger.warning('Wikipedia author image error: $e', context: 'Metadata');
+      _logger.warning('Wikipedia author image error for "$name": $e', context: 'Metadata');
+    }
+    return null;
+  }
+
+  /// Fetches author image URL from multiple sources with fuzzy name matching
+  /// Priority: 1. Audnexus, 2. Open Library, 3. Wikipedia
+  /// Tries name variations if exact match fails
+  static Future<String?> getAuthorImageUrl(String authorName) async {
+    // Check cache first
+    final cacheKey = 'authorImage:$authorName';
+    if (_authorImageCache.containsKey(cacheKey)) {
+      return _authorImageCache[cacheKey];
+    }
+
+    // Handle comma-separated author names (e.g., "Neil Gaiman, Dirk Maggs")
+    // Try to get image for the first/primary author
+    if (authorName.contains(',')) {
+      final authors = authorName.split(',').map((s) => s.trim()).where((s) => s.isNotEmpty).toList();
+
+      // Skip if this looks like "Lastname, Firstname" format or has suffixes
+      // - Second part is initials (J.R.R., J.K., etc.)
+      // - Second part is a suffix (Jr., Sr., III, PhD, etc.)
+      final suffixes = ['jr', 'jr.', 'sr', 'sr.', 'ii', 'iii', 'iv', 'phd', 'ph.d.', 'md', 'm.d.'];
+      if (authors.length == 2) {
+        final secondPart = authors[1].toLowerCase();
+        // Check if second part is a suffix or looks like initials
+        if (suffixes.contains(secondPart) ||
+            RegExp(r'^[a-z]\.?\s*[a-z]?\.?\s*[a-z]?\.?$').hasMatch(secondPart)) {
+          // This is "Lastname, First" or "Name, Jr." - don't split
+        } else if (authors[0].split(' ').length > 1 && authors[1].split(' ').length > 1) {
+          // Both parts have multiple words - likely "Author1, Author2"
+          for (final author in authors) {
+            final result = await getAuthorImageUrl(author);
+            if (result != null) {
+              _authorImageCache[cacheKey] = result;
+              return result;
+            }
+          }
+          // Don't cache null here - fall through to try the full name
+        }
+      } else if (authors.length > 2) {
+        // Multiple commas = definitely multiple authors
+        for (final author in authors) {
+          final result = await getAuthorImageUrl(author);
+          if (result != null) {
+            _authorImageCache[cacheKey] = result;
+            return result;
+          }
+        }
+        // Don't cache null - fall through to try full name
+      }
+    }
+
+    // Generate name variations for fuzzy matching
+    final variations = _generateNameVariations(authorName);
+
+    // Try each source with all variations before moving to next source
+    // This prioritizes source quality over name variation
+
+    // 1. Try Audnexus (best for audiobook authors)
+    for (final name in variations) {
+      final result = await _tryAudnexus(name);
+      if (result != null) {
+        _authorImageCache[cacheKey] = result;
+        return result;
+      }
+    }
+
+    // 2. Try Open Library
+    for (final name in variations) {
+      final result = await _tryOpenLibrary(name);
+      if (result != null) {
+        _authorImageCache[cacheKey] = result;
+        return result;
+      }
+    }
+
+    // 3. Try Wikidata (structured data, good for finding exact person)
+    for (final name in variations.take(2)) {
+      final wikidataResult = await _tryWikidata(name);
+      if (wikidataResult != null) {
+        _authorImageCache[cacheKey] = wikidataResult;
+        return wikidataResult;
+      }
+    }
+
+    // 4. Try Wikipedia (search-based, good fallback)
+    for (final name in variations.take(3)) {
+      final wikiResult = await _tryWikipedia(name);
+      if (wikiResult != null) {
+        _authorImageCache[cacheKey] = wikiResult;
+        return wikiResult;
+      }
    }

    // Cache the null result to avoid repeated failed lookups
@@ -8,6 +8,7 @@ import '../constants/network.dart';
 import '../constants/timings.dart' show Timings, LibraryConstants;
 import '../models/media_item.dart';
 import '../models/player.dart';
+import '../models/provider_instance.dart';
 import 'debug_logger.dart';
 import 'settings_service.dart';
 import 'device_id_service.dart';
@@ -376,23 +377,31 @@ class MusicAssistantAPI {
    String? search,
    bool? favoriteOnly,
    bool albumArtistsOnly = true,
+    String? orderBy,
+    List<String>? providerInstanceIds,
  }) async {
    try {
+      final args = {
+        if (limit != null) 'limit': limit,
+        if (offset != null) 'offset': offset,
+        if (search != null) 'search': search,
+        if (favoriteOnly != null) 'favorite': favoriteOnly,
+        'album_artists_only': albumArtistsOnly,
+        if (orderBy != null) 'order_by': orderBy,
+        if (providerInstanceIds != null && providerInstanceIds.isNotEmpty)
+          'provider': providerInstanceIds,
+      };
+      _logger.log('🔍 API getArtists args: $args');
      final response = await _sendCommand(
        'music/artists/library_items',
-        args: {
-          if (limit != null) 'limit': limit,
-          if (offset != null) 'offset': offset,
-          if (search != null) 'search': search,
-          if (favoriteOnly != null) 'favorite': favoriteOnly,
-          'album_artists_only': albumArtistsOnly,
-        },
+        args: args,
      );

      final items = response['result'] as List<dynamic>?;
      if (items == null) {
        return [];
      }
+      _logger.log('🔍 API getArtists returned ${items.length} items');
      return items
          .map((item) => Artist.fromJson(item as Map<String, dynamic>))
          .toList();
@@ -402,7 +411,11 @@ class MusicAssistantAPI {
    }
  }

-  Future<List<Artist>> getRandomArtists({int limit = 10, bool albumArtistsOnly = true}) async {
+  Future<List<Artist>> getRandomArtists({
+    int limit = 10,
+    bool albumArtistsOnly = true,
+    List<String>? providerInstanceIds,
+  }) async {
    try {
      final response = await _sendCommand(
        'music/artists/library_items',
@@ -410,6 +423,8 @@ class MusicAssistantAPI {
          'limit': limit,
          'order_by': 'random',
          'album_artists_only': albumArtistsOnly,
+          if (providerInstanceIds != null && providerInstanceIds.isNotEmpty)
+            'provider': providerInstanceIds,
        },
      );

@@ -431,6 +446,8 @@ class MusicAssistantAPI {
    String? search,
    bool? favoriteOnly,
    String? artistId,
+    String? orderBy,
+    List<String>? providerInstanceIds,
  }) async {
    try {
      final args = <String, dynamic>{
@@ -439,7 +456,11 @@ class MusicAssistantAPI {
        if (search != null) 'search': search,
        if (favoriteOnly != null) 'favorite': favoriteOnly,
        if (artistId != null) 'artist_id': artistId,
+        if (orderBy != null) 'order_by': orderBy,
+        if (providerInstanceIds != null && providerInstanceIds.isNotEmpty)
+          'provider': providerInstanceIds,
      };
+      _logger.log('🔍 API getAlbums args: $args');

      final response = await _sendCommand(
        'music/albums/library_items',
@@ -448,6 +469,7 @@ class MusicAssistantAPI {

      final items = response['result'] as List<dynamic>?;
      if (items == null) return [];
+      _logger.log('🔍 API getAlbums returned ${items.length} items');

      return items
          .map((item) => Album.fromJson(item as Map<String, dynamic>))
@@ -465,6 +487,8 @@ class MusicAssistantAPI {
    bool? favoriteOnly,
    String? artistId,
    String? albumId,
+    String? orderBy,
+    List<String>? providerInstanceIds,
  }) async {
    try {
      final response = await _sendCommand(
@@ -476,6 +500,9 @@ class MusicAssistantAPI {
          if (favoriteOnly != null) 'favorite': favoriteOnly,
          if (artistId != null) 'artist': artistId,
          if (albumId != null) 'album': albumId,
+          if (orderBy != null) 'order_by': orderBy,
+          if (providerInstanceIds != null && providerInstanceIds.isNotEmpty)
+            'provider': providerInstanceIds,
        },
      );

@@ -496,6 +523,7 @@ class MusicAssistantAPI {
    int? limit,
    int? offset,
    bool? favoriteOnly,
+    String? orderBy,
  }) async {
    try {
      final response = await _sendCommand(
@@ -504,6 +532,7 @@ class MusicAssistantAPI {
          if (limit != null) 'limit': limit,
          if (offset != null) 'offset': offset,
          if (favoriteOnly != null) 'favorite': favoriteOnly,
+          if (orderBy != null) 'order_by': orderBy,
        },
      );

@@ -555,6 +584,7 @@ class MusicAssistantAPI {
    int? limit,
    int? offset,
    bool? favoriteOnly,
+    String? orderBy,
  }) async {
    try {
      final response = await _sendCommand(
@@ -563,6 +593,7 @@ class MusicAssistantAPI {
          if (limit != null) 'limit': limit,
          if (offset != null) 'offset': offset,
          if (favoriteOnly != null) 'favorite': favoriteOnly,
+          if (orderBy != null) 'order_by': orderBy,
        },
      );

@@ -719,48 +750,113 @@ class MusicAssistantAPI {
    String? search,
    bool? favoriteOnly,
    String? authorId,
+    List<String>? providerInstanceIds,
  }) async {
    try {
-      // Check if library filtering is enabled
+      final allAudiobooks = <Audiobook>[];
+      final seenIds = <String>{};
+
+      // Check if library filtering is enabled (for ABS providers)
      final enabledLibraries = await SettingsService.getEnabledAbsLibraries();

-      // If specific libraries are enabled, use browse API for filtering
+      // Extract ABS provider IDs from library paths
+      final absProviderIds = <String>{};
      if (enabledLibraries != null && enabledLibraries.isNotEmpty) {
-        return await _getAudiobooksFromBrowse(enabledLibraries, favoriteOnly: favoriteOnly);
-      }
-
-      // Otherwise use the faster MA API (returns all audiobooks)
-      final args = <String, dynamic>{
-        if (limit != null) 'limit': limit,
-        if (offset != null) 'offset': offset,
-        if (search != null) 'search': search,
-        if (favoriteOnly != null) 'favorite': favoriteOnly,
-        if (authorId != null) 'author_id': authorId,
-      };
-
-      final response = await _sendCommand(
-        'music/audiobooks/library_items',
-        args: args,
-      );
-
-      // Check for error in response
-      if (response.containsKey('error_code')) {
-        return [];
-      }
-
-      final items = response['result'] as List<dynamic>?;
-      if (items == null) return [];
-
-      final audiobooks = <Audiobook>[];
-      for (int i = 0; i < items.length; i++) {
-        try {
-          final book = Audiobook.fromJson(items[i] as Map<String, dynamic>);
-          audiobooks.add(book);
-        } catch (e) {
-          // Skip items that fail to parse
+        for (final libPath in enabledLibraries) {
+          final providerEnd = libPath.indexOf('://');
+          if (providerEnd != -1) {
+            absProviderIds.add(libPath.substring(0, providerEnd));
+          }
        }
      }
-      return audiobooks;
+
+      _logger.log('📚 getAudiobooks: absProviderIds=$absProviderIds, providerInstanceIds=$providerInstanceIds');
+
+      // PART 1: Fetch from ABS providers using browse API (for library filtering support)
+      if (enabledLibraries != null && enabledLibraries.isNotEmpty) {
+        // If specific providers are requested, filter libraries to only matching ABS providers
+        var librariesToBrowse = enabledLibraries;
+        if (providerInstanceIds != null && providerInstanceIds.isNotEmpty) {
+          librariesToBrowse = enabledLibraries.where((libPath) {
+            final providerEnd = libPath.indexOf('://');
+            if (providerEnd == -1) return false;
+            final providerId = libPath.substring(0, providerEnd);
+            return providerInstanceIds.contains(providerId);
+          }).toList();
+        }
+
+        if (librariesToBrowse.isNotEmpty) {
+          final browseBooks = await _getAudiobooksFromBrowse(librariesToBrowse, favoriteOnly: favoriteOnly);
+          for (final book in browseBooks) {
+            if (!seenIds.contains(book.itemId)) {
+              seenIds.add(book.itemId);
+              allAudiobooks.add(book);
+            }
+          }
+          _logger.log('📚 Got ${browseBooks.length} audiobooks from ABS browse API');
+        }
+      }
+
+      // PART 2: Fetch from non-ABS providers using library_items API
+      // This gets audiobooks from Spotify, Plex, Jellyfin, etc.
+      List<String>? nonAbsProviders;
+      if (providerInstanceIds != null && providerInstanceIds.isNotEmpty) {
+        // Filter to only non-ABS providers from the requested list
+        nonAbsProviders = providerInstanceIds.where((id) => !absProviderIds.contains(id)).toList();
+      } else if (absProviderIds.isNotEmpty) {
+        // No specific providers requested, but we have ABS - need to also fetch from non-ABS
+        // Pass null to get all, then we'll deduplicate
+        nonAbsProviders = null; // Will fetch all
+      }
+
+      // Only call library_items API if:
+      // 1. No ABS libraries configured (traditional mode), OR
+      // 2. We have non-ABS providers to query
+      final shouldFetchFromApi = enabledLibraries == null ||
+                                  enabledLibraries.isEmpty ||
+                                  (nonAbsProviders == null && absProviderIds.isNotEmpty) ||
+                                  (nonAbsProviders != null && nonAbsProviders.isNotEmpty);
+
+      if (shouldFetchFromApi) {
+        final args = <String, dynamic>{
+          if (limit != null) 'limit': limit,
+          if (offset != null) 'offset': offset,
+          if (search != null) 'search': search,
+          if (favoriteOnly != null) 'favorite': favoriteOnly,
+          if (authorId != null) 'author_id': authorId,
+          if (nonAbsProviders != null && nonAbsProviders.isNotEmpty)
+            'provider': nonAbsProviders,
+        };
+
+        final response = await _sendCommand(
+          'music/audiobooks/library_items',
+          args: args,
+        );
+
+        if (!response.containsKey('error_code')) {
+          final items = response['result'] as List<dynamic>?;
+          if (items != null) {
+            int addedCount = 0;
+            for (int i = 0; i < items.length; i++) {
+              try {
+                final book = Audiobook.fromJson(items[i] as Map<String, dynamic>);
+                // Deduplicate by itemId
+                if (!seenIds.contains(book.itemId)) {
+                  seenIds.add(book.itemId);
+                  allAudiobooks.add(book);
+                  addedCount++;
+                }
+              } catch (e) {
+                // Skip items that fail to parse
+              }
+            }
+            _logger.log('📚 Got $addedCount audiobooks from library_items API');
+          }
+        }
+      }
+
+      _logger.log('📚 Total audiobooks: ${allAudiobooks.length}');
+      return allAudiobooks;
    } catch (e, stack) {
      _logger.log('Error getting audiobooks: $e');
      _logger.log('Stack: $stack');
@@ -1082,7 +1178,7 @@ class MusicAssistantAPI {
      for (final item in providerRoot) {
        final itemMap = item as Map<String, dynamic>;
        final path = itemMap['path'] as String? ?? '';
-        final name = itemMap['name'] as String? ?? '';
+        final name = (itemMap['name'] as String?) ?? (itemMap['label'] as String?) ?? '';
        if (path != 'root' && name != '..') {
          discoveredLibraries.add({'path': path, 'name': name});
        }
@@ -1101,7 +1197,7 @@ class MusicAssistantAPI {
      for (final libraryItem in providerRoot) {
        final libraryMap = libraryItem as Map<String, dynamic>;
        final libraryPath = libraryMap['path'] as String? ?? '';
-        final libraryName = libraryMap['name'] as String? ?? '';
+        final libraryName = (libraryMap['name'] as String?) ?? (libraryMap['label'] as String?) ?? '';

        // Skip "root" (parent navigation) item
        if (libraryPath == 'root' || libraryName == '..') continue;
@@ -1121,7 +1217,7 @@ class MusicAssistantAPI {
        // Log library contents to find series
        for (final item in libraryContents) {
          final itemMap = item as Map<String, dynamic>;
-          final name = itemMap['name'] as String? ?? '';
+          final name = (itemMap['name'] as String?) ?? (itemMap['label'] as String?) ?? '';
          final path = itemMap['path'] as String? ?? '';
          _logger.log('📚   Library item: name=$name, path=$path');
        }
@@ -1129,10 +1225,11 @@ class MusicAssistantAPI {
        // Look for "Series" folder in the library
        for (final item in libraryContents) {
          final itemMap = item as Map<String, dynamic>;
-          final name = (itemMap['name'] as String? ?? '').toLowerCase();
+          final name = ((itemMap['name'] as String?) ?? (itemMap['label'] as String?) ?? '').toLowerCase();
          final path = itemMap['path'] as String? ?? '';

-          if (name.contains('series') || path.contains('series')) {
+          // Check for "series" in name/path, or abbreviated path ending with "/s"
+          if (name.contains('series') || path.contains('series') || path.endsWith('/s')) {
            _logger.log('📚 Found series folder: $path');

            // Browse the series folder
@@ -1141,13 +1238,15 @@ class MusicAssistantAPI {

            for (final seriesItem in seriesItems) {
              final seriesMap = seriesItem as Map<String, dynamic>;
+              final seriesName = (seriesMap['name'] as String?) ?? (seriesMap['label'] as String?) ?? '';
+              final seriesPath = seriesMap['path'] as String? ?? '';
              // Skip parent navigation
-              if (seriesMap['path'] == 'root' || seriesMap['name'] == '..') continue;
+              if (seriesPath == 'root' || seriesName == '..' || seriesPath.endsWith('://')) continue;
              // Skip actual audiobook items (we only want series folders)
              final mediaType = seriesMap['media_type'] as String?;
              if (mediaType == 'audiobook' || mediaType == 'track') continue;

-              _logger.log('📚 Series: name=${seriesMap['name']}, path=${seriesMap['path']}, media_type=$mediaType');
+              _logger.log('📚 Series: name=$seriesName, path=$seriesPath, media_type=$mediaType');
              allSeries.add(AudiobookSeries.fromJson(seriesMap));
            }
            break; // Found series in this library, move to next library
@@ -1335,13 +1434,18 @@ class MusicAssistantAPI {
  }

  /// Get random albums
-  Future<List<Album>> getRandomAlbums({int limit = 10}) async {
+  Future<List<Album>> getRandomAlbums({
+    int limit = 10,
+    List<String>? providerInstanceIds,
+  }) async {
    try {
      final response = await _sendCommand(
        'music/albums/library_items',
        args: {
          'limit': limit,
          'order_by': 'random',
+          if (providerInstanceIds != null && providerInstanceIds.isNotEmpty)
+            'provider': providerInstanceIds,
        },
      );

@@ -1457,6 +1561,8 @@ class MusicAssistantAPI {
    int? offset,
    String? search,
    bool? favoriteOnly,
+    String? orderBy,
+    List<String>? providerInstanceIds,
  }) async {
    try {
      final response = await _sendCommand(
@@ -1466,6 +1572,9 @@ class MusicAssistantAPI {
          if (offset != null) 'offset': offset,
          if (search != null) 'search': search,
          if (favoriteOnly != null) 'favorite': favoriteOnly,
+          if (orderBy != null) 'order_by': orderBy,
+          if (providerInstanceIds != null && providerInstanceIds.isNotEmpty)
+            'provider': providerInstanceIds,
        },
      );

@@ -1487,7 +1596,7 @@ class MusicAssistantAPI {
      final response = await _sendCommand(
        'music/playlist',
        args: {
-          'provider': provider,
+          'provider_instance_id_or_domain': provider,
          'item_id': itemId,
        },
      );
@@ -2518,6 +2627,44 @@ class MusicAssistantAPI {
    }
  }

+  /// Transfer the current queue to another player
+  /// This moves the entire playback queue from source player to target player,
+  /// including shuffle and repeat settings.
+  ///
+  /// [sourceQueueId] - The queue ID of the source player (optional, uses first playing player if null)
+  /// [targetQueueId] - The queue ID of the target player (required)
+  /// [autoPlay] - Whether to automatically start playback on the target player (default: true)
+  Future<void> transferQueue({
+    String? sourceQueueId,
+    required String targetQueueId,
+    bool autoPlay = true,
+  }) async {
+    try {
+      _logger.log('🔄 Transferring queue to player: $targetQueueId (source: ${sourceQueueId ?? "auto"}, autoPlay: $autoPlay)');
+
+      final args = <String, dynamic>{
+        'target_queue_id': targetQueueId,
+        'auto_play': autoPlay,
+      };
+
+      // Only include source_queue_id if explicitly provided
+      // When null, MA will use the first playing player
+      if (sourceQueueId != null) {
+        args['source_queue_id'] = sourceQueueId;
+      }
+
+      await _sendCommand(
+        'player_queues/transfer',
+        args: args,
+      );
+
+      _logger.log('✅ Queue transferred successfully');
+    } catch (e) {
+      _logger.log('❌ Error transferring queue: $e');
+      rethrow;
+    }
+  }
+
  // ============================================================================
  // BUILT-IN PLAYER MANAGEMENT
  // ============================================================================
@@ -3228,14 +3375,6 @@ class MusicAssistantAPI {
        _logger.log('⚠️ Could not load provider manifests: $e');
      }

-      // Fetch provider instances (active providers)
-      try {
-        await _sendCommand('providers');
-        _logger.log('✓ Provider instances loaded');
-      } catch (e) {
-        _logger.log('⚠️ Could not load provider instances: $e');
-      }
-
      _logger.log('✅ Initial state fetch complete');
    } catch (e) {
      _logger.log('❌ Error fetching state: $e');
@@ -3243,6 +3382,39 @@ class MusicAssistantAPI {
    }
  }

+  /// Get all music provider instances configured in Music Assistant
+  /// Returns only music providers (spotify, tidal, filesystem, etc.) not player/metadata providers
+  Future<List<ProviderInstance>> getMusicProviders() async {
+    try {
+      final response = await _sendCommand('providers');
+
+      final result = response['result'];
+      if (result == null) {
+        _logger.log('⚠️ providers command returned no result');
+        return [];
+      }
+
+      final List<dynamic> providers = result is List ? result : [];
+      final musicProviders = <ProviderInstance>[];
+
+      for (final providerData in providers) {
+        if (providerData is Map<String, dynamic>) {
+          final instance = ProviderInstance.fromJson(providerData);
+          // Only include music providers (not player providers, metadata providers, etc.)
+          if (instance.isMusicProvider) {
+            musicProviders.add(instance);
+          }
+        }
+      }
+
+      _logger.log('🎵 Found ${musicProviders.length} music providers: ${musicProviders.map((p) => p.name).join(", ")}');
+      return musicProviders;
+    } catch (e) {
+      _logger.log('❌ Error getting music providers: $e');
+      return [];
+    }
+  }
+
  /// Get current authenticated user's profile
  /// Returns user info including display_name, username, groups, etc.
  Future<Map<String, dynamic>?> getCurrentUserInfo() async {
@@ -20,7 +20,17 @@ class SecureStorageService {

  // Auth Token (for stream requests)
  static Future<String?> getAuthToken() async {
-    return await _storage.read(key: _keyAuthToken);
+    try {
+      return await _storage.read(key: _keyAuthToken);
+    } catch (e) {
+      // Handle decryption errors (e.g., after keystore/signature change)
+      if (e.toString().contains('BadPaddingException') ||
+          e.toString().contains('BAD_DECRYPT')) {
+        await _storage.delete(key: _keyAuthToken);
+        return null;
+      }
+      rethrow;
+    }
  }

  static Future<void> setAuthToken(String? token) async {
@@ -33,7 +43,17 @@ class SecureStorageService {

  // Music Assistant Native Auth Token (long-lived token)
  static Future<String?> getMaAuthToken() async {
-    return await _storage.read(key: _keyMaAuthToken);
+    try {
+      return await _storage.read(key: _keyMaAuthToken);
+    } catch (e) {
+      // Handle decryption errors (e.g., after keystore/signature change)
+      if (e.toString().contains('BadPaddingException') ||
+          e.toString().contains('BAD_DECRYPT')) {
+        await _storage.delete(key: _keyMaAuthToken);
+        return null;
+      }
+      rethrow;
+    }
  }

  static Future<void> setMaAuthToken(String? token) async {
@@ -50,7 +70,18 @@ class SecureStorageService {

  // Auth Credentials (serialized auth strategy credentials)
  static Future<Map<String, dynamic>?> getAuthCredentials() async {
-    final json = await _storage.read(key: _keyAuthCredentials);
+    String? json;
+    try {
+      json = await _storage.read(key: _keyAuthCredentials);
+    } catch (e) {
+      // Handle decryption errors (e.g., after keystore/signature change)
+      if (e.toString().contains('BadPaddingException') ||
+          e.toString().contains('BAD_DECRYPT')) {
+        await _storage.delete(key: _keyAuthCredentials);
+        return null;
+      }
+      rethrow;
+    }
    if (json == null) return null;
    try {
      return jsonDecode(json) as Map<String, dynamic>;
@@ -69,7 +100,17 @@ class SecureStorageService {

  // Password
  static Future<String?> getPassword() async {
-    return await _storage.read(key: _keyPassword);
+    try {
+      return await _storage.read(key: _keyPassword);
+    } catch (e) {
+      // Handle decryption errors (e.g., after keystore/signature change)
+      if (e.toString().contains('BadPaddingException') ||
+          e.toString().contains('BAD_DECRYPT')) {
+        await _storage.delete(key: _keyPassword);
+        return null;
+      }
+      rethrow;
+    }
  }

  static Future<void> setPassword(String? password) async {
@@ -82,7 +123,17 @@ class SecureStorageService {

  // Audiobookshelf API Token
  static Future<String?> getAbsApiToken() async {
-    return await _storage.read(key: _keyAbsApiToken);
+    try {
+      return await _storage.read(key: _keyAbsApiToken);
+    } catch (e) {
+      // Handle decryption errors (e.g., after keystore/signature change)
+      if (e.toString().contains('BadPaddingException') ||
+          e.toString().contains('BAD_DECRYPT')) {
+        await _storage.delete(key: _keyAbsApiToken);
+        return null;
+      }
+      rethrow;
+    }
  }

  static Future<void> setAbsApiToken(String? token) async {
@@ -98,12 +149,21 @@ class SecureStorageService {
    await _storage.deleteAll();
  }

+  // Migration completed flag key
+  static const String _keyMigrationCompleted = 'secure_storage_migration_completed';
+
  /// Migrate credentials from SharedPreferences to secure storage.
  /// Call this once during app upgrade to migrate existing users.
+  /// Uses a flag to skip migration on subsequent runs for performance.
  static Future<void> migrateFromSharedPreferences() async {
    // Import SharedPreferences for migration
    final SharedPreferences prefs = await SharedPreferences.getInstance();

+    // Skip if migration already completed
+    if (prefs.getBool(_keyMigrationCompleted) == true) {
+      return;
+    }
+
    // Migrate auth token
    final authToken = prefs.getString('auth_token');
    if (authToken != null && authToken.isNotEmpty) {
@@ -144,5 +204,8 @@ class SecureStorageService {
      await setAbsApiToken(absApiToken);
      await prefs.remove('abs_api_token');
    }
+
+    // Mark migration as completed to skip on future runs
+    await prefs.setBool(_keyMigrationCompleted, true);
  }
 }
@@ -17,6 +17,7 @@ enum SyncStatus {

 /// Service for background library synchronization
 /// Loads from database cache first, then syncs from MA API in background
+/// Supports per-provider sync for accurate client-side filtering
 class SyncService with ChangeNotifier {
  static SyncService? _instance;
  static final _logger = DebugLogger();
@@ -42,6 +43,13 @@ class SyncService with ChangeNotifier {
  List<Audiobook> _cachedAudiobooks = [];
  List<Playlist> _cachedPlaylists = [];

+  // Source provider tracking for client-side filtering
+  // Maps itemId -> list of provider instance IDs that provided the item
+  Map<String, List<String>> _albumSourceProviders = {};
+  Map<String, List<String>> _artistSourceProviders = {};
+  Map<String, List<String>> _audiobookSourceProviders = {};
+  Map<String, List<String>> _playlistSourceProviders = {};
+
  // Getters
  SyncStatus get status => _status;
  String? get lastError => _lastError;
@@ -54,8 +62,15 @@ class SyncService with ChangeNotifier {
  bool get hasCache => _cachedAlbums.isNotEmpty || _cachedArtists.isNotEmpty ||
                       _cachedAudiobooks.isNotEmpty || _cachedPlaylists.isNotEmpty;

+  // Source provider getters for client-side filtering
+  Map<String, List<String>> get albumSourceProviders => _albumSourceProviders;
+  Map<String, List<String>> get artistSourceProviders => _artistSourceProviders;
+  Map<String, List<String>> get audiobookSourceProviders => _audiobookSourceProviders;
+  Map<String, List<String>> get playlistSourceProviders => _playlistSourceProviders;
+
  /// Load library data from database cache (instant)
  /// Call this on app startup for immediate data
+  /// Also loads source provider info for client-side filtering
  Future<void> loadFromCache() async {
    if (!_db.isInitialized) {
      _logger.log('⚠️ Database not initialized, skipping cache load');
@@ -65,52 +80,73 @@ class SyncService with ChangeNotifier {
    try {
      _logger.log('📦 Loading library from database cache...');

-      // Load albums from cache
-      final albumData = await _db.getCachedItems('album');
-      _cachedAlbums = albumData.map((data) {
+      // Load albums from cache with source providers
+      final albumDataWithProviders = await _db.getCachedItemsWithProviders('album');
+      _cachedAlbums = [];
+      _albumSourceProviders = {};
+      for (final (data, providers) in albumDataWithProviders) {
        try {
-          return Album.fromJson(data);
+          final album = Album.fromJson(data);
+          _cachedAlbums.add(album);
+          if (providers.isNotEmpty) {
+            _albumSourceProviders[album.itemId] = providers;
+          }
        } catch (e) {
          _logger.log('⚠️ Failed to parse cached album: $e');
-          return null;
        }
-      }).whereType<Album>().toList();
+      }

-      // Load artists from cache
-      final artistData = await _db.getCachedItems('artist');
-      _cachedArtists = artistData.map((data) {
+      // Load artists from cache with source providers
+      final artistDataWithProviders = await _db.getCachedItemsWithProviders('artist');
+      _cachedArtists = [];
+      _artistSourceProviders = {};
+      for (final (data, providers) in artistDataWithProviders) {
        try {
-          return Artist.fromJson(data);
+          final artist = Artist.fromJson(data);
+          _cachedArtists.add(artist);
+          if (providers.isNotEmpty) {
+            _artistSourceProviders[artist.itemId] = providers;
+          }
        } catch (e) {
          _logger.log('⚠️ Failed to parse cached artist: $e');
-          return null;
        }
-      }).whereType<Artist>().toList();
+      }

-      // Load audiobooks from cache
-      final audiobookData = await _db.getCachedItems('audiobook');
-      _cachedAudiobooks = audiobookData.map((data) {
+      // Load audiobooks from cache with source providers
+      final audiobookDataWithProviders = await _db.getCachedItemsWithProviders('audiobook');
+      _cachedAudiobooks = [];
+      _audiobookSourceProviders = {};
+      for (final (data, providers) in audiobookDataWithProviders) {
        try {
-          return Audiobook.fromJson(data);
+          final audiobook = Audiobook.fromJson(data);
+          _cachedAudiobooks.add(audiobook);
+          if (providers.isNotEmpty) {
+            _audiobookSourceProviders[audiobook.itemId] = providers;
+          }
        } catch (e) {
          _logger.log('⚠️ Failed to parse cached audiobook: $e');
-          return null;
        }
-      }).whereType<Audiobook>().toList();
+      }

-      // Load playlists from cache
-      final playlistData = await _db.getCachedItems('playlist');
-      _cachedPlaylists = playlistData.map((data) {
+      // Load playlists from cache with source providers
+      final playlistDataWithProviders = await _db.getCachedItemsWithProviders('playlist');
+      _cachedPlaylists = [];
+      _playlistSourceProviders = {};
+      for (final (data, providers) in playlistDataWithProviders) {
        try {
-          return Playlist.fromJson(data);
+          final playlist = Playlist.fromJson(data);
+          _cachedPlaylists.add(playlist);
+          if (providers.isNotEmpty) {
+            _playlistSourceProviders[playlist.itemId] = providers;
+          }
        } catch (e) {
          _logger.log('⚠️ Failed to parse cached playlist: $e');
-          return null;
        }
-      }).whereType<Playlist>().toList();
+      }

      _logger.log('📦 Loaded ${_cachedAlbums.length} albums, ${_cachedArtists.length} artists, '
                  '${_cachedAudiobooks.length} audiobooks, ${_cachedPlaylists.length} playlists from cache');
+      _logger.log('📦 Source providers: ${_albumSourceProviders.length} albums, ${_artistSourceProviders.length} artists tracked');
      notifyListeners();
    } catch (e) {
      _logger.log('❌ Failed to load from cache: $e');
@@ -119,7 +155,12 @@ class SyncService with ChangeNotifier {

  /// Sync library data from MA API in background
  /// Updates database cache and notifies listeners when complete
-  Future<void> syncFromApi(MusicAssistantAPI api, {bool force = false}) async {
+  /// [providerInstanceIds] - list of provider IDs to sync (fetches each provider separately for accurate source tracking)
+  Future<void> syncFromApi(
+    MusicAssistantAPI api, {
+    bool force = false,
+    List<String>? providerInstanceIds,
+  }) async {
    if (_isSyncing) {
      _logger.log('🔄 Sync already in progress, skipping');
      return;
@@ -155,33 +196,140 @@ class SyncService with ChangeNotifier {
      final showOnlyArtistsWithAlbums = await SettingsService.getShowOnlyArtistsWithAlbums();
      _logger.log('🎨 Sync using albumArtistsOnly: $showOnlyArtistsWithAlbums');

-      // Fetch fresh data from MA API (in parallel for speed)
-      final results = await Future.wait([
-        api.getAlbums(limit: 1000),
-        api.getArtists(limit: 1000, albumArtistsOnly: showOnlyArtistsWithAlbums),
-        api.getAudiobooks(limit: 1000),
-        api.getPlaylists(limit: 1000),
-      ]);
+      // Only clear cache for full syncs (no specific providers)
+      // Partial syncs preserve items from disabled providers for instant toggle-on
+      final isPartialSync = providerInstanceIds != null && providerInstanceIds.isNotEmpty;
+      if (!isPartialSync) {
+        await _db.clearCacheForType('album');
+        await _db.clearCacheForType('artist');
+        await _db.clearCacheForType('audiobook');
+        await _db.clearCacheForType('playlist');
+      }

-      final albums = results[0] as List<Album>;
-      final artists = results[1] as List<Artist>;
-      final audiobooks = results[2] as List<Audiobook>;
-      final playlists = results[3] as List<Playlist>;
+      // Build NEW source tracking maps - don't modify existing until sync is complete
+      // This prevents UI flicker from partial tracking during sync
+      final syncingProviders = providerInstanceIds?.toSet() ?? <String>{};
+      final newAlbumSourceProviders = <String, List<String>>{};
+      final newArtistSourceProviders = <String, List<String>>{};
+      final newAudiobookSourceProviders = <String, List<String>>{};
+      final newPlaylistSourceProviders = <String, List<String>>{};

-      _logger.log('📥 Fetched ${albums.length} albums, ${artists.length} artists, '
-                  '${audiobooks.length} audiobooks, ${playlists.length} playlists from MA');
+      // For partial syncs, copy tracking from non-syncing providers
+      if (isPartialSync) {
+        for (final entry in _albumSourceProviders.entries) {
+          final preserved = entry.value.where((p) => !syncingProviders.contains(p)).toList();
+          if (preserved.isNotEmpty) newAlbumSourceProviders[entry.key] = preserved;
+        }
+        for (final entry in _artistSourceProviders.entries) {
+          final preserved = entry.value.where((p) => !syncingProviders.contains(p)).toList();
+          if (preserved.isNotEmpty) newArtistSourceProviders[entry.key] = preserved;
+        }
+        for (final entry in _audiobookSourceProviders.entries) {
+          final preserved = entry.value.where((p) => !syncingProviders.contains(p)).toList();
+          if (preserved.isNotEmpty) newAudiobookSourceProviders[entry.key] = preserved;
+        }
+        for (final entry in _playlistSourceProviders.entries) {
+          final preserved = entry.value.where((p) => !syncingProviders.contains(p)).toList();
+          if (preserved.isNotEmpty) newPlaylistSourceProviders[entry.key] = preserved;
+        }
+      }

-      // Clear old cache before saving fresh data (removes stale items)
-      await _db.clearCacheForType('album');
-      await _db.clearCacheForType('artist');
-      await _db.clearCacheForType('audiobook');
-      await _db.clearCacheForType('playlist');
+      // Collect all items (deduped by itemId, but tracking all source providers)
+      final albumMap = <String, Album>{};
+      final artistMap = <String, Artist>{};
+      final audiobookMap = <String, Audiobook>{};
+      final playlistMap = <String, Playlist>{};

-      // Save to database cache
-      await _saveAlbumsToCache(albums);
-      await _saveArtistsToCache(artists);
-      await _saveAudiobooksToCache(audiobooks);
-      await _savePlaylistsToCache(playlists);
+      // If specific providers are requested, sync each separately for accurate source tracking
+      if (providerInstanceIds != null && providerInstanceIds.isNotEmpty) {
+        _logger.log('🔒 Per-provider sync for ${providerInstanceIds.length} providers');
+
+        for (final providerId in providerInstanceIds) {
+          _logger.log('  📡 Syncing provider: $providerId');
+
+          // Fetch from this specific provider
+          final results = await Future.wait([
+            api.getAlbums(limit: 1000, providerInstanceIds: [providerId]),
+            api.getArtists(limit: 1000, albumArtistsOnly: showOnlyArtistsWithAlbums, providerInstanceIds: [providerId]),
+            api.getAudiobooks(limit: 1000, providerInstanceIds: [providerId]),
+            api.getPlaylists(limit: 1000, providerInstanceIds: [providerId]),
+          ]);
+
+          final albums = results[0] as List<Album>;
+          final artists = results[1] as List<Artist>;
+          final audiobooks = results[2] as List<Audiobook>;
+          final playlists = results[3] as List<Playlist>;
+
+          _logger.log('  📥 Got ${albums.length} albums, ${artists.length} artists, ${audiobooks.length} audiobooks from $providerId');
+
+          // Add to maps and track source provider in NEW tracking maps
+          for (final album in albums) {
+            albumMap[album.itemId] = album;
+            newAlbumSourceProviders.putIfAbsent(album.itemId, () => []);
+            if (!newAlbumSourceProviders[album.itemId]!.contains(providerId)) {
+              newAlbumSourceProviders[album.itemId]!.add(providerId);
+            }
+          }
+          for (final artist in artists) {
+            artistMap[artist.itemId] = artist;
+            newArtistSourceProviders.putIfAbsent(artist.itemId, () => []);
+            if (!newArtistSourceProviders[artist.itemId]!.contains(providerId)) {
+              newArtistSourceProviders[artist.itemId]!.add(providerId);
+            }
+          }
+          for (final audiobook in audiobooks) {
+            audiobookMap[audiobook.itemId] = audiobook;
+            newAudiobookSourceProviders.putIfAbsent(audiobook.itemId, () => []);
+            if (!newAudiobookSourceProviders[audiobook.itemId]!.contains(providerId)) {
+              newAudiobookSourceProviders[audiobook.itemId]!.add(providerId);
+            }
+          }
+          for (final playlist in playlists) {
+            playlistMap[playlist.itemId] = playlist;
+            newPlaylistSourceProviders.putIfAbsent(playlist.itemId, () => []);
+            if (!newPlaylistSourceProviders[playlist.itemId]!.contains(providerId)) {
+              newPlaylistSourceProviders[playlist.itemId]!.add(providerId);
+            }
+          }
+        }
+      } else {
+        // No provider filter - fetch all at once (faster, but no source tracking)
+        _logger.log('📡 Fetching from all providers (no source tracking)');
+
+        final results = await Future.wait([
+          api.getAlbums(limit: 1000),
+          api.getArtists(limit: 1000, albumArtistsOnly: showOnlyArtistsWithAlbums),
+          api.getAudiobooks(limit: 1000),
+          api.getPlaylists(limit: 1000),
+        ]);
+
+        for (final album in results[0] as List<Album>) {
+          albumMap[album.itemId] = album;
+        }
+        for (final artist in results[1] as List<Artist>) {
+          artistMap[artist.itemId] = artist;
+        }
+        for (final audiobook in results[2] as List<Audiobook>) {
+          audiobookMap[audiobook.itemId] = audiobook;
+        }
+        for (final playlist in results[3] as List<Playlist>) {
+          playlistMap[playlist.itemId] = playlist;
+        }
+      }
+
+      final albums = albumMap.values.toList();
+      final artists = artistMap.values.toList();
+      final audiobooks = audiobookMap.values.toList();
+      final playlists = playlistMap.values.toList();
+
+      _logger.log('📥 Total: ${albums.length} albums, ${artists.length} artists, '
+                  '${audiobooks.length} audiobooks, ${playlists.length} playlists');
+
+      // Save to database cache with source provider info (using NEW tracking maps)
+      await _saveAlbumsToCache(albums, newAlbumSourceProviders);
+      await _saveArtistsToCache(artists, newArtistSourceProviders);
+      await _saveAudiobooksToCache(audiobooks, newAudiobookSourceProviders);
+      await _savePlaylistsToCache(playlists, newPlaylistSourceProviders);

      // Update sync metadata
      await _db.updateSyncMetadata('albums', albums.length);
@@ -190,14 +338,49 @@ class SyncService with ChangeNotifier {
      await _db.updateSyncMetadata('playlists', playlists.length);

      // Update in-memory cache
-      _cachedAlbums = albums;
-      _cachedArtists = artists;
-      _cachedAudiobooks = audiobooks;
-      _cachedPlaylists = playlists;
+      if (isPartialSync) {
+        // Partial sync: merge with existing cache to preserve items from disabled providers
+        final albumIds = albums.map((a) => a.itemId).toSet();
+        final artistIds = artists.map((a) => a.itemId).toSet();
+        final audiobookIds = audiobooks.map((a) => a.itemId).toSet();
+        final playlistIds = playlists.map((p) => p.itemId).toSet();
+
+        // Keep items not in current sync, add/update items from sync
+        _cachedAlbums = [
+          ..._cachedAlbums.where((a) => !albumIds.contains(a.itemId)),
+          ...albums,
+        ];
+        _cachedArtists = [
+          ..._cachedArtists.where((a) => !artistIds.contains(a.itemId)),
+          ...artists,
+        ];
+        _cachedAudiobooks = [
+          ..._cachedAudiobooks.where((a) => !audiobookIds.contains(a.itemId)),
+          ...audiobooks,
+        ];
+        _cachedPlaylists = [
+          ..._cachedPlaylists.where((p) => !playlistIds.contains(p.itemId)),
+          ...playlists,
+        ];
+      } else {
+        // Full sync: replace entire cache
+        _cachedAlbums = albums;
+        _cachedArtists = artists;
+        _cachedAudiobooks = audiobooks;
+        _cachedPlaylists = playlists;
+      }
+      // Atomically swap in the new source tracking maps
+      // This ensures filtering always sees complete data, never partial
+      _albumSourceProviders = newAlbumSourceProviders;
+      _artistSourceProviders = newArtistSourceProviders;
+      _audiobookSourceProviders = newAudiobookSourceProviders;
+      _playlistSourceProviders = newPlaylistSourceProviders;
+
      _lastSyncTime = DateTime.now();
      _status = SyncStatus.completed;

      _logger.log('✅ Library sync complete');
+      _logger.log('📊 Source tracking: ${_albumSourceProviders.length} albums, ${_artistSourceProviders.length} artists, ${_audiobookSourceProviders.length} audiobooks have provider info');
    } catch (e) {
      _logger.log('❌ Library sync failed: $e');
      _status = SyncStatus.error;
@@ -208,15 +391,28 @@ class SyncService with ChangeNotifier {
    }
  }

-  /// Save albums to database cache
-  Future<void> _saveAlbumsToCache(List<Album> albums) async {
+  /// Save albums to database cache with source provider tracking
+  Future<void> _saveAlbumsToCache(List<Album> albums, Map<String, List<String>> sourceProviders) async {
    for (final album in albums) {
      try {
-        await _db.cacheItem(
-          itemType: 'album',
-          itemId: album.itemId,
-          data: album.toJson(),
-        );
+        final providers = sourceProviders[album.itemId];
+        // Save with first source provider (merging happens in DB layer)
+        for (final provider in providers ?? <String>[]) {
+          await _db.cacheItem(
+            itemType: 'album',
+            itemId: album.itemId,
+            data: album.toJson(),
+            sourceProvider: provider,
+          );
+        }
+        // If no source providers, still cache the item
+        if (providers == null || providers.isEmpty) {
+          await _db.cacheItem(
+            itemType: 'album',
+            itemId: album.itemId,
+            data: album.toJson(),
+          );
+        }
      } catch (e) {
        _logger.log('⚠️ Failed to cache album ${album.name}: $e');
      }
@@ -224,15 +420,26 @@ class SyncService with ChangeNotifier {
    _logger.log('💾 Saved ${albums.length} albums to cache');
  }

-  /// Save artists to database cache
-  Future<void> _saveArtistsToCache(List<Artist> artists) async {
+  /// Save artists to database cache with source provider tracking
+  Future<void> _saveArtistsToCache(List<Artist> artists, Map<String, List<String>> sourceProviders) async {
    for (final artist in artists) {
      try {
-        await _db.cacheItem(
-          itemType: 'artist',
-          itemId: artist.itemId,
-          data: artist.toJson(),
-        );
+        final providers = sourceProviders[artist.itemId];
+        for (final provider in providers ?? <String>[]) {
+          await _db.cacheItem(
+            itemType: 'artist',
+            itemId: artist.itemId,
+            data: artist.toJson(),
+            sourceProvider: provider,
+          );
+        }
+        if (providers == null || providers.isEmpty) {
+          await _db.cacheItem(
+            itemType: 'artist',
+            itemId: artist.itemId,
+            data: artist.toJson(),
+          );
+        }
      } catch (e) {
        _logger.log('⚠️ Failed to cache artist ${artist.name}: $e');
      }
@@ -240,15 +447,26 @@ class SyncService with ChangeNotifier {
    _logger.log('💾 Saved ${artists.length} artists to cache');
  }

-  /// Save audiobooks to database cache
-  Future<void> _saveAudiobooksToCache(List<Audiobook> audiobooks) async {
+  /// Save audiobooks to database cache with source provider tracking
+  Future<void> _saveAudiobooksToCache(List<Audiobook> audiobooks, Map<String, List<String>> sourceProviders) async {
    for (final audiobook in audiobooks) {
      try {
-        await _db.cacheItem(
-          itemType: 'audiobook',
-          itemId: audiobook.itemId,
-          data: audiobook.toJson(),
-        );
+        final providers = sourceProviders[audiobook.itemId];
+        for (final provider in providers ?? <String>[]) {
+          await _db.cacheItem(
+            itemType: 'audiobook',
+            itemId: audiobook.itemId,
+            data: audiobook.toJson(),
+            sourceProvider: provider,
+          );
+        }
+        if (providers == null || providers.isEmpty) {
+          await _db.cacheItem(
+            itemType: 'audiobook',
+            itemId: audiobook.itemId,
+            data: audiobook.toJson(),
+          );
+        }
      } catch (e) {
        _logger.log('⚠️ Failed to cache audiobook ${audiobook.name}: $e');
      }
@@ -256,15 +474,26 @@ class SyncService with ChangeNotifier {
    _logger.log('💾 Saved ${audiobooks.length} audiobooks to cache');
  }

-  /// Save playlists to database cache
-  Future<void> _savePlaylistsToCache(List<Playlist> playlists) async {
+  /// Save playlists to database cache with source provider tracking
+  Future<void> _savePlaylistsToCache(List<Playlist> playlists, Map<String, List<String>> sourceProviders) async {
    for (final playlist in playlists) {
      try {
-        await _db.cacheItem(
-          itemType: 'playlist',
-          itemId: playlist.itemId,
-          data: playlist.toJson(),
-        );
+        final providers = sourceProviders[playlist.itemId];
+        for (final provider in providers ?? <String>[]) {
+          await _db.cacheItem(
+            itemType: 'playlist',
+            itemId: playlist.itemId,
+            data: playlist.toJson(),
+            sourceProvider: provider,
+          );
+        }
+        if (providers == null || providers.isEmpty) {
+          await _db.cacheItem(
+            itemType: 'playlist',
+            itemId: playlist.itemId,
+            data: playlist.toJson(),
+          );
+        }
      } catch (e) {
        _logger.log('⚠️ Failed to cache playlist ${playlist.name}: $e');
      }
@@ -273,8 +502,9 @@ class SyncService with ChangeNotifier {
  }

  /// Force a fresh sync (for pull-to-refresh)
-  Future<void> forceSync(MusicAssistantAPI api) async {
-    await syncFromApi(api, force: true);
+  /// [providerInstanceIds] - optional list of provider IDs to filter by (null = all providers)
+  Future<void> forceSync(MusicAssistantAPI api, {List<String>? providerInstanceIds}) async {
+    await syncFromApi(api, force: true, providerInstanceIds: providerInstanceIds);
  }

  /// Clear all cached data
@@ -286,12 +516,82 @@ class SyncService with ChangeNotifier {
    _cachedArtists = [];
    _cachedAudiobooks = [];
    _cachedPlaylists = [];
+    _albumSourceProviders = {};
+    _artistSourceProviders = {};
+    _audiobookSourceProviders = {};
+    _playlistSourceProviders = {};
    _lastSyncTime = null;
    _status = SyncStatus.idle;
    notifyListeners();
    _logger.log('🗑️ Library cache cleared');
  }

+  // ============================================
+  // Client-side filtering methods
+  // ============================================
+
+  /// Filter albums by source provider (instant, no network)
+  /// Empty enabledProviderIds = all providers enabled, show everything
+  /// Items without source tracking are HIDDEN (strict mode) to ensure accurate filtering
+  List<Album> getAlbumsFilteredByProviders(Set<String> enabledProviderIds) {
+    // Empty set = all providers enabled, show everything
+    if (enabledProviderIds.isEmpty) {
+      return _cachedAlbums;
+    }
+    return _cachedAlbums.where((album) {
+      final sources = _albumSourceProviders[album.itemId];
+      // STRICT MODE: Hide items without tracking to ensure accurate filtering
+      if (sources == null || sources.isEmpty) return false;
+      return sources.any((s) => enabledProviderIds.contains(s));
+    }).toList();
+  }
+
+  /// Filter artists by source provider (instant, no network)
+  List<Artist> getArtistsFilteredByProviders(Set<String> enabledProviderIds) {
+    if (enabledProviderIds.isEmpty) {
+      return _cachedArtists;
+    }
+    return _cachedArtists.where((artist) {
+      final sources = _artistSourceProviders[artist.itemId];
+      // STRICT MODE: Hide items without tracking
+      if (sources == null || sources.isEmpty) return false;
+      return sources.any((s) => enabledProviderIds.contains(s));
+    }).toList();
+  }
+
+  /// Filter audiobooks by source provider (instant, no network)
+  List<Audiobook> getAudiobooksFilteredByProviders(Set<String> enabledProviderIds) {
+    if (enabledProviderIds.isEmpty) {
+      return _cachedAudiobooks;
+    }
+    return _cachedAudiobooks.where((audiobook) {
+      final sources = _audiobookSourceProviders[audiobook.itemId];
+      // STRICT MODE: Hide items without tracking
+      if (sources == null || sources.isEmpty) return false;
+      return sources.any((s) => enabledProviderIds.contains(s));
+    }).toList();
+  }
+
+  /// Filter playlists by source provider (instant, no network)
+  List<Playlist> getPlaylistsFilteredByProviders(Set<String> enabledProviderIds) {
+    if (enabledProviderIds.isEmpty) {
+      return _cachedPlaylists;
+    }
+    return _cachedPlaylists.where((playlist) {
+      final sources = _playlistSourceProviders[playlist.itemId];
+      // STRICT MODE: Hide items without tracking
+      if (sources == null || sources.isEmpty) return false;
+      return sources.any((s) => enabledProviderIds.contains(s));
+    }).toList();
+  }
+
+  /// Check if we have source provider tracking data
+  bool get hasSourceTracking =>
+      _albumSourceProviders.isNotEmpty ||
+      _artistSourceProviders.isNotEmpty ||
+      _audiobookSourceProviders.isNotEmpty ||
+      _playlistSourceProviders.isNotEmpty;
+
  /// Get albums (from cache or empty if not loaded)
  List<Album> getAlbums() => _cachedAlbums;

@@ -124,3 +124,51 @@ class Durations {
  static const Duration normal = Duration(milliseconds: 300);
  static const Duration slow = Duration(milliseconds: 500);
 }
+
+/// Button size tokens
+class ButtonSizes {
+  ButtonSizes._();
+
+  // Touch target sizes (Material Design minimum: 48x48)
+  static const double sm = 32.0;
+  static const double md = 36.0;
+  static const double lg = 44.0;
+  static const double xl = 48.0;
+  static const double xxl = 56.0;
+
+  // Icon sizes within buttons
+  static const double iconSm = 16.0;
+  static const double iconMd = 18.0;
+  static const double iconLg = 20.0;
+  static const double iconXl = 24.0;
+}
+
+/// Semantic status colors for consistent feedback
+/// Use with Theme brightness for proper contrast
+class StatusColors {
+  StatusColors._();
+
+  // Success states
+  static const Color success = Color(0xFF4CAF50);
+  static const Color successLight = Color(0xFF81C784);
+  static const Color successDark = Color(0xFF388E3C);
+
+  // Error states
+  static const Color error = Color(0xFFF44336);
+  static const Color errorLight = Color(0xFFE57373);
+  static const Color errorDark = Color(0xFFD32F2F);
+
+  // Warning states
+  static const Color warning = Color(0xFFFF9800);
+  static const Color warningLight = Color(0xFFFFB74D);
+  static const Color warningDark = Color(0xFFF57C00);
+
+  // Info states
+  static const Color info = Color(0xFF2196F3);
+  static const Color infoLight = Color(0xFF64B5F6);
+  static const Color infoDark = Color(0xFF1976D2);
+
+  // Favorites (heart icon)
+  static const Color favorite = Color(0xFFF44336);
+  static const Color favoriteActive = Color(0xFFE53935);
+}
@@ -6,6 +6,7 @@ import '../models/media_item.dart';
 import '../providers/music_assistant_provider.dart';
 import '../screens/album_details_screen.dart';
 import '../constants/hero_tags.dart';
+import '../constants/timings.dart';
 import '../theme/theme_provider.dart';
 import '../utils/page_transitions.dart';
 import '../services/metadata_service.dart';
@@ -36,6 +37,7 @@ class _AlbumCardState extends State<AlbumCard> {
  bool _maImageFailed = false;
  String? _cachedMaImageUrl;
  Timer? _fallbackTimer;
+  bool _isNavigating = false;

  /// Delay before fetching fallback images to avoid requests during fast scroll
  static const _fallbackDelay = Duration(milliseconds: 200);
@@ -117,6 +119,10 @@ class _AlbumCardState extends State<AlbumCard> {
    return RepaintBoundary(
      child: GestureDetector(
        onTap: widget.onTap ?? () {
+          // Prevent double-tap navigation
+          if (_isNavigating) return;
+          _isNavigating = true;
+
          // Update adaptive colors immediately on tap
          updateAdaptiveColorsFromImage(context, imageUrl);
          Navigator.push(
@@ -128,7 +134,12 @@ class _AlbumCardState extends State<AlbumCard> {
                initialImageUrl: imageUrl,
              ),
            ),
-          );
+          ).then((_) {
+            // Reset after navigation debounce delay
+            Future.delayed(Timings.navigationDebounce, () {
+              if (mounted) _isNavigating = false;
+            });
+          });
        },
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
@@ -6,6 +6,7 @@ import '../models/media_item.dart';
 import '../providers/music_assistant_provider.dart';
 import '../screens/artist_details_screen.dart';
 import '../constants/hero_tags.dart';
+import '../constants/timings.dart';
 import '../theme/theme_provider.dart';
 import '../utils/page_transitions.dart';
 import '../services/metadata_service.dart';
@@ -38,6 +39,7 @@ class _ArtistCardState extends State<ArtistCard> {
  bool _maImageFailed = false;
  String? _cachedMaImageUrl;
  Timer? _fallbackTimer;
+  bool _isNavigating = false;

  /// Delay before fetching fallback images to avoid requests during fast scroll
  static const _fallbackDelay = Duration(milliseconds: 200);
@@ -110,6 +112,10 @@ class _ArtistCardState extends State<ArtistCard> {
    return RepaintBoundary(
      child: GestureDetector(
        onTap: widget.onTap ?? () {
+          // Prevent double-tap navigation
+          if (_isNavigating) return;
+          _isNavigating = true;
+
          // Update adaptive colors immediately on tap
          updateAdaptiveColorsFromImage(context, imageUrl);
          Navigator.push(
@@ -121,7 +127,12 @@ class _ArtistCardState extends State<ArtistCard> {
                initialImageUrl: imageUrl,
              ),
            ),
-          );
+          ).then((_) {
+            // Reset after navigation debounce delay
+            Future.delayed(Timings.navigationDebounce, () {
+              if (mounted) _isNavigating = false;
+            });
+          });
        },
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.center,
@@ -103,39 +103,48 @@ class EmptyState extends StatelessWidget {
  Widget build(BuildContext context) {
    final colorScheme = Theme.of(context).colorScheme;

-    return Center(
-      child: Padding(
-        padding: Spacing.paddingAll24,
-        child: Column(
-          mainAxisAlignment: MainAxisAlignment.center,
-          children: [
-            Icon(
-              icon,
-              size: iconSize,
-              color: colorScheme.onSurface.withOpacity(0.38),
-            ),
-            Spacing.vGap16,
-            Text(
-              message,
-              style: TextStyle(
-                color: colorScheme.onSurface.withOpacity(0.6),
-                fontSize: 16,
+    // Wrap in scrollable to allow PageView horizontal swipe detection
+    return LayoutBuilder(
+      builder: (context, constraints) => SingleChildScrollView(
+        physics: const AlwaysScrollableScrollPhysics(),
+        child: ConstrainedBox(
+          constraints: BoxConstraints(minHeight: constraints.maxHeight),
+          child: Center(
+            child: Padding(
+              padding: Spacing.paddingAll24,
+              child: Column(
+                mainAxisAlignment: MainAxisAlignment.center,
+                children: [
+                  Icon(
+                    icon,
+                    size: iconSize,
+                    color: colorScheme.onSurface.withOpacity(0.38),
+                  ),
+                  Spacing.vGap16,
+                  Text(
+                    message,
+                    style: TextStyle(
+                      color: colorScheme.onSurface.withOpacity(0.6),
+                      fontSize: 16,
+                    ),
+                    textAlign: TextAlign.center,
+                  ),
+                  if (actionLabel != null && onAction != null) ...[
+                    Spacing.vGap24,
+                    ElevatedButton.icon(
+                      onPressed: onAction,
+                      icon: const Icon(Icons.refresh_rounded),
+                      label: Text(actionLabel!),
+                      style: ElevatedButton.styleFrom(
+                        backgroundColor: colorScheme.surfaceVariant,
+                        foregroundColor: colorScheme.onSurfaceVariant,
+                      ),
+                    ),
+                  ],
+                ],
              ),
-              textAlign: TextAlign.center,
            ),
-            if (actionLabel != null && onAction != null) ...[
-              Spacing.vGap24,
-              ElevatedButton.icon(
-                onPressed: onAction,
-                icon: const Icon(Icons.refresh_rounded),
-                label: Text(actionLabel!),
-                style: ElevatedButton.styleFrom(
-                  backgroundColor: colorScheme.surfaceVariant,
-                  foregroundColor: colorScheme.onSurfaceVariant,
-                ),
-              ),
-            ],
-          ],
+          ),
        ),
      ),
    );
@@ -162,51 +171,60 @@ class _CustomEmptyState extends EmptyState {
    final colorScheme = Theme.of(context).colorScheme;
    final s = S.of(context)!;

-    return Center(
-      child: Padding(
-        padding: Spacing.paddingAll24,
-        child: Column(
-          mainAxisAlignment: MainAxisAlignment.center,
-          children: [
-            Icon(
-              icon,
-              size: iconSize,
-              color: colorScheme.onSurface.withOpacity(0.38),
+    // Wrap in scrollable to allow PageView horizontal swipe detection
+    return LayoutBuilder(
+      builder: (context, constraints) => SingleChildScrollView(
+        physics: const AlwaysScrollableScrollPhysics(),
+        child: ConstrainedBox(
+          constraints: BoxConstraints(minHeight: constraints.maxHeight),
+          child: Center(
+            child: Padding(
+              padding: Spacing.paddingAll24,
+              child: Column(
+                mainAxisAlignment: MainAxisAlignment.center,
+                children: [
+                  Icon(
+                    icon,
+                    size: iconSize,
+                    color: colorScheme.onSurface.withOpacity(0.38),
+                  ),
+                  Spacing.vGap16,
+                  Text(
+                    title,
+                    style: TextStyle(
+                      color: colorScheme.onSurface.withOpacity(0.6),
+                      fontSize: 16,
+                      fontWeight: FontWeight.w500,
+                    ),
+                    textAlign: TextAlign.center,
+                  ),
+                  if (subtitle != null) ...[
+                    Spacing.vGap8,
+                    Text(
+                      subtitle!,
+                      style: TextStyle(
+                        color: colorScheme.onSurface.withOpacity(0.4),
+                        fontSize: 14,
+                      ),
+                      textAlign: TextAlign.center,
+                    ),
+                  ],
+                  if (onRefresh != null) ...[
+                    Spacing.vGap24,
+                    ElevatedButton.icon(
+                      onPressed: onRefresh,
+                      icon: const Icon(Icons.refresh_rounded),
+                      label: Text(s.refresh),
+                      style: ElevatedButton.styleFrom(
+                        backgroundColor: colorScheme.surfaceVariant,
+                        foregroundColor: colorScheme.onSurfaceVariant,
+                      ),
+                    ),
+                  ],
+                ],
+              ),
            ),
-            Spacing.vGap16,
-            Text(
-              title,
-              style: TextStyle(
-                color: colorScheme.onSurface.withOpacity(0.6),
-                fontSize: 16,
-                fontWeight: FontWeight.w500,
-              ),
-              textAlign: TextAlign.center,
-            ),
-            if (subtitle != null) ...[
-              Spacing.vGap8,
-              Text(
-                subtitle!,
-                style: TextStyle(
-                  color: colorScheme.onSurface.withOpacity(0.4),
-                  fontSize: 14,
-                ),
-                textAlign: TextAlign.center,
-              ),
-            ],
-            if (onRefresh != null) ...[
-              Spacing.vGap24,
-              ElevatedButton.icon(
-                onPressed: onRefresh,
-                icon: const Icon(Icons.refresh_rounded),
-                label: Text(s.refresh),
-                style: ElevatedButton.styleFrom(
-                  backgroundColor: colorScheme.surfaceVariant,
-                  foregroundColor: colorScheme.onSurfaceVariant,
-                ),
-              ),
-            ],
-          ],
+          ),
        ),
      ),
    );
@@ -1,5 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
+import '../../l10n/app_localizations.dart';
 import '../../services/debug_logger.dart';
 import '../../theme/design_tokens.dart';

@@ -72,9 +73,9 @@ class DebugConsole extends StatelessWidget {
            padding: EdgeInsets.zero,
            minimumSize: const Size(40, 20),
          ),
-          child: const Text(
-            'Clear',
-            style: TextStyle(fontSize: 10, color: Colors.green),
+          child: Text(
+            S.of(context)!.clear,
+            style: const TextStyle(fontSize: 10, color: Colors.green),
          ),
        ),
      ],
@@ -86,17 +87,17 @@ class DebugConsole extends StatelessWidget {
    if (logs.isNotEmpty) {
      Clipboard.setData(ClipboardData(text: logs));
      ScaffoldMessenger.of(context).showSnackBar(
-        const SnackBar(
-          content: Text('Logs copied to clipboard'),
+        SnackBar(
+          content: Text(S.of(context)!.logsCopied),
          backgroundColor: Colors.green,
-          duration: Duration(seconds: 2),
+          duration: const Duration(seconds: 2),
        ),
      );
    } else {
      ScaffoldMessenger.of(context).showSnackBar(
-        const SnackBar(
-          content: Text('No logs to copy'),
-          duration: Duration(seconds: 2),
+        SnackBar(
+          content: Text(S.of(context)!.noLogsToCopy),
+          duration: const Duration(seconds: 2),
        ),
      );
    }
@@ -7,12 +7,17 @@ import 'package:provider/provider.dart';
 import 'package:cached_network_image/cached_network_image.dart';
 import '../constants/timings.dart';
 import '../providers/music_assistant_provider.dart';
+import '../providers/navigation_provider.dart';
 import '../models/player.dart';
+import '../models/media_item.dart';
 import '../services/animation_debugger.dart';
 import '../theme/palette_helper.dart';
 import '../theme/theme_provider.dart';
 import '../l10n/app_localizations.dart';
 import '../services/settings_service.dart';
+import '../screens/artist_details_screen.dart';
+import '../screens/album_details_screen.dart';
+import '../utils/page_transitions.dart';
 import 'animated_icon_button.dart';
 import 'global_player_overlay.dart';
 import 'volume_control.dart';
@@ -73,6 +78,7 @@ class ExpandablePlayerState extends State<ExpandablePlayer>

  // Queue state
  PlayerQueue? _queue;
+  String? _queuePlayerId; // Track which player the queue belongs to
  bool _isLoadingQueue = false;
  bool _isQueueDragging = false; // True while queue item is being dragged
  bool _queuePanelTargetOpen = false; // Target state for queue panel (separate from animation value)
@@ -380,6 +386,18 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
    });
  }

+  /// Force collapse player to mini state, instantly closing queue panel if open.
+  /// Used for queue transfer where we want to go directly to mini player.
+  void forceCollapse() {
+    if (_isVerticalDragging) return;
+    // Instantly close queue panel without animation
+    _queuePanelController.value = 0;
+    _queuePanelTargetOpen = false;
+    // Collapse player
+    _controller.duration = _collapseDuration;
+    _controller.reverse();
+  }
+
  /// Handle vertical drag start - begin gesture-driven expansion
  void _handleVerticalDragStart(DragStartDetails details) {
    _isVerticalDragging = true;
@@ -495,7 +513,6 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
      final selectedPlayer = maProvider.selectedPlayer;
      // Only refresh if the event is for our current player
      if (playerId != null && selectedPlayer != null && playerId == selectedPlayer.playerId) {
-        debugPrint('QueuePanel: Received queue_items_updated event, refreshing queue');
        _loadQueue();
      }
    });
@@ -512,9 +529,16 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
      return;
    }

+    // Clear queue if player changed (e.g., after queue transfer)
+    if (_queuePlayerId != null && _queuePlayerId != player.playerId) {
+      _queue = null;
+      _queuePlayerId = player.playerId;
+    }
+
    // 1. Show cached queue immediately (if available)
    // Only load from cache if we don't already have a queue (preserves optimistic updates)
    if (_queue == null) {
+      _queuePlayerId = player.playerId;
      final cachedQueue = await maProvider.getCachedQueue(player.playerId);
      if (cachedQueue != null && cachedQueue.items.isNotEmpty && mounted) {
        setState(() {
@@ -531,7 +555,6 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
      try {
        final freshQueue = await maProvider.getQueue(player.playerId);
        if (mounted && freshQueue != null) {
-          debugPrint('🔀 Queue loaded: shuffle=${freshQueue.shuffle}, shuffleEnabled=${freshQueue.shuffleEnabled}');
          // Check if queue items were reordered by comparing first few item IDs
          bool itemsReordered = false;
          if (_queue != null && _queue!.items.isNotEmpty && freshQueue.items.isNotEmpty) {
@@ -540,7 +563,6 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
            for (int i = 0; i < maxCheck; i++) {
              if (_queue!.items[i].queueItemId != freshQueue.items[i].queueItemId) {
                itemsReordered = true;
-                debugPrint('🔀 Queue items reordered detected at position $i');
                break;
              }
            }
@@ -552,9 +574,9 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
              _queue!.shuffle != freshQueue.shuffle ||
              itemsReordered;
          if (queueChanged) {
-            debugPrint('🔀 Queue changed, updating UI (reordered=$itemsReordered)');
            setState(() {
              _queue = freshQueue;
+              _queuePlayerId = player.playerId;
              _isLoadingQueue = false;
            });
          }
@@ -594,13 +616,8 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
  }

  Future<void> _toggleShuffle() async {
-    debugPrint('🔀 Shuffle button pressed');
-    if (_queue == null) {
-      debugPrint('🔀 Shuffle: _queue is null, returning');
-      return;
-    }
+    if (_queue == null) return;
    final newShuffleState = !_queue!.shuffle;
-    debugPrint('🔀 Shuffle: current=${_queue!.shuffle}, toggling to $newShuffleState');

    // Optimistically update local state for immediate visual feedback
    setState(() {
@@ -612,15 +629,12 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
        repeatMode: _queue!.repeatMode,
      );
    });
-    debugPrint('🔀 Shuffle: optimistic update applied, shuffleEnabled=$newShuffleState');

    final maProvider = context.read<MusicAssistantProvider>();
    // Toggle: if currently shuffled, disable; if not shuffled, enable
    await maProvider.toggleShuffle(_queue!.playerId, newShuffleState);
-    debugPrint('🔀 Shuffle: command sent, waiting for server to reorder queue');
    // Small delay to allow server to finish reordering queue items
    await Future.delayed(const Duration(milliseconds: 150));
-    debugPrint('🔀 Shuffle: reloading queue');
    await _loadQueue();
  }

@@ -872,6 +886,45 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
    }
  }

+  /// Navigate to artist details screen
+  void _navigateToArtist(MusicAssistantProvider maProvider, dynamic currentTrack) {
+    if (currentTrack == null) return;
+
+    // Skip for podcasts/audiobooks - they show author/podcast name but navigation isn't applicable
+    if (maProvider.isPlayingPodcast || maProvider.isPlayingAudiobook) return;
+
+    // For regular tracks, navigate to first artist
+    final artists = currentTrack.artists;
+    if (artists != null && artists is List && artists.isNotEmpty) {
+      final artist = artists.first;
+      if (artist is Artist) {
+        // Collapse player first, then navigate using global navigator key
+        collapse();
+        navigationProvider.navigatorKey.currentState?.push(
+          FadeSlidePageRoute(
+            child: ArtistDetailsScreen(artist: artist),
+          ),
+        );
+      }
+    }
+  }
+
+  /// Navigate to album details screen
+  void _navigateToAlbum(dynamic currentTrack) {
+    if (currentTrack == null) return;
+
+    final album = currentTrack.album;
+    if (album != null && album is Album) {
+      // Collapse player first, then navigate using global navigator key
+      collapse();
+      navigationProvider.navigatorKey.currentState?.push(
+        FadeSlidePageRoute(
+          child: AlbumDetailsScreen(album: album),
+        ),
+      );
+    }
+  }
+
  /// Show fullscreen album art overlay
  void _showFullscreenArt(BuildContext context, String? imageUrl) {
    if (imageUrl == null) return;
@@ -1229,7 +1282,10 @@ class ExpandablePlayerState extends State<ExpandablePlayer>

  @override
  Widget build(BuildContext context) {
-    final themeProvider = context.watch<ThemeProvider>();
+    // PERF: Use select() to only rebuild when adaptive theme setting changes
+    final adaptiveTheme = context.select<ThemeProvider, bool>((p) => p.adaptiveTheme);
+    // Get full themeProvider for methods that need adaptive color schemes
+    final themeProvider = context.read<ThemeProvider>();

    return Consumer<MusicAssistantProvider>(
      builder: (context, maProvider, child) {
@@ -1247,7 +1303,7 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
            : null;

        // Extract colors for adaptive theme
-        if (themeProvider.adaptiveTheme && imageUrl != null) {
+        if (adaptiveTheme && imageUrl != null) {
          _extractColors(imageUrl);
        }

@@ -2101,21 +2157,24 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
                        child: Align(
                          // PERF Phase 5: Use pre-computed alignment
                          alignment: textAlignment,
-                          child: Text(
-                            // Always show artist/author/podcast name (was showing "Now Playing" when device reveal visible)
-                            maProvider.isPlayingAudiobook
-                                ? (maProvider.currentAudiobook?.authorsString ?? S.of(context)!.unknownAuthor)
-                                : maProvider.isPlayingPodcast
-                                    ? (maProvider.currentPodcastName ?? S.of(context)!.podcasts)
-                                    : currentTrack.artistsString,
-                            style: TextStyle(
-                              // PERF Phase 4: Use Color.lerp between pre-computed colors
-                              color: Color.lerp(textColor60, textColor70, t),
-                              fontSize: artistFontSize,
+                          child: GestureDetector(
+                            onTap: t > 0.8 ? () => _navigateToArtist(maProvider, currentTrack) : null,
+                            child: Text(
+                              // Always show artist/author/podcast name (was showing "Now Playing" when device reveal visible)
+                              maProvider.isPlayingAudiobook
+                                  ? (maProvider.currentAudiobook?.authorsString ?? S.of(context)!.unknownAuthor)
+                                  : maProvider.isPlayingPodcast
+                                      ? (maProvider.currentPodcastName ?? S.of(context)!.podcasts)
+                                      : currentTrack.artistsString,
+                              style: TextStyle(
+                                // PERF Phase 4: Use Color.lerp between pre-computed colors
+                                color: Color.lerp(textColor60, textColor70, t),
+                                fontSize: artistFontSize,
+                              ),
+                              textAlign: TextAlign.left, // Keep static, Align handles centering
+                              maxLines: 1,
+                              overflow: TextOverflow.ellipsis,
                            ),
-                            textAlign: TextAlign.left, // Keep static, Align handles centering
-                            maxLines: 1,
-                            overflow: TextOverflow.ellipsis,
                          ),
                        ),
                      ),
@@ -2164,16 +2223,19 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
                    top: _lerpDouble(artistTop + 24, expandedAlbumTop, t),
                    child: maProvider.isPlayingAudiobook
                        ? _buildChapterInfo(maProvider, textColor, t)
-                        : Text(
-                            currentTrack.album!.name,
-                            style: TextStyle(
-                              color: textColor.withOpacity(0.45 * ((t - 0.3) / 0.7).clamp(0.0, 1.0)),
-                              fontSize: 15,
-                              fontWeight: FontWeight.w300,
+                        : GestureDetector(
+                            onTap: t > 0.8 ? () => _navigateToAlbum(currentTrack) : null,
+                            child: Text(
+                              currentTrack.album!.name,
+                              style: TextStyle(
+                                color: textColor.withOpacity(0.45 * ((t - 0.3) / 0.7).clamp(0.0, 1.0)),
+                                fontSize: 15,
+                                fontWeight: FontWeight.w300,
+                              ),
+                              textAlign: TextAlign.center,
+                              maxLines: 1,
+                              overflow: TextOverflow.ellipsis,
                            ),
-                            textAlign: TextAlign.center,
-                            maxLines: 1,
-                            overflow: TextOverflow.ellipsis,
                          ),
                  ),

@@ -97,6 +97,12 @@ class GlobalPlayerOverlay extends StatefulWidget {
    globalPlayerKey.currentState?.collapse();
  }

+  /// Force collapse player to mini state, instantly closing queue panel if open.
+  /// Used for queue transfer where we want to go directly to mini player.
+  static void forceCollapsePlayer() {
+    globalPlayerKey.currentState?.forceCollapse();
+  }
+
  /// Check if the player is currently expanded
  static bool get isPlayerExpanded =>
      globalPlayerKey.currentState?.isExpanded ?? false;
@@ -426,15 +432,17 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
    final theme = Theme.of(context);
    final colorScheme = theme.colorScheme;

-    // Watch provider to trigger rebuilds when connection state changes
-    final provider = context.watch<MusicAssistantProvider>();
+    // PERF: Use select() to only rebuild when connection state or player changes
+    final (isConnected, hasSelectedPlayer) = context.select<MusicAssistantProvider, (bool, bool)>(
+      (p) => (p.isConnected, p.selectedPlayer != null),
+    );

    // Compute whether this is a first-time user ready for welcome screen.
    // This is SYNCHRONOUS - no setState needed - so it works in the same frame.
    final isFirstTimeUserReady = _settingsLoaded &&
        !_hasCompletedOnboarding &&
-        provider.isConnected &&
-        provider.selectedPlayer != null;
+        isConnected &&
+        hasSelectedPlayer;

    // Show welcome backdrop if:
    // 1. Already in hint mode (_isHintModeActive), OR
@@ -480,7 +488,7 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
        // Hide when: not connected, no player selected, OR showing welcome screen
        // For first-time users, selectedPlayer becomes non-null at the same time
        // as shouldShowWelcomeBackdrop becomes true, preventing any gap.
-        if (provider.isConnected && provider.selectedPlayer != null && !shouldShowWelcomeBackdrop)
+        if (isConnected && hasSelectedPlayer && !shouldShowWelcomeBackdrop)
          Positioned(
            left: 0,
            right: 0,
@@ -2,6 +2,9 @@ import 'package:flutter/material.dart';

 /// A scrollbar that shows a letter popup when dragging, for fast navigation
 /// through alphabetically sorted lists.
+///
+/// Scrolls PROPORTIONALLY (like a normal scrollbar) and shows which letter
+/// section you're currently in via a popup indicator.
 class LetterScrollbar extends StatefulWidget {
  /// The scrollable child widget (ListView, GridView, etc.)
  final Widget child;
@@ -9,16 +12,34 @@ class LetterScrollbar extends StatefulWidget {
  /// The scroll controller for the child
  final ScrollController controller;

-  /// List of items to extract letters from (must be sorted alphabetically)
-  /// Each item's first character is used to determine the letter
+  /// List of strings to extract letters from (should match visual sort order).
+  /// Each item's first character is used to determine the letter shown in the popup.
  final List<String> items;

-  /// Callback when user taps/drags to a specific index
+  /// Callback when user taps/drags to a specific index.
  final void Function(int index)? onScrollToIndex;

  /// Callback when drag state changes (for disabling scroll-to-hide)
  final void Function(bool isDragging)? onDragStateChanged;

+  /// Fixed item height for lists. Enables precise scroll calculation.
+  final double? itemExtent;
+
+  /// Number of columns for grid layouts.
+  final int? crossAxisCount;
+
+  /// Aspect ratio of grid children (width / height).
+  final double? childAspectRatio;
+
+  /// Spacing between grid rows (mainAxisSpacing)
+  final double? mainAxisSpacing;
+
+  /// Horizontal padding of the scrollable area
+  final double? horizontalPadding;
+
+  /// Bottom padding to prevent scrollbar from going behind bottom nav/mini player
+  final double bottomPadding;
+
  const LetterScrollbar({
    super.key,
    required this.child,
@@ -26,6 +47,12 @@ class LetterScrollbar extends StatefulWidget {
    required this.items,
    this.onScrollToIndex,
    this.onDragStateChanged,
+    this.itemExtent,
+    this.crossAxisCount,
+    this.childAspectRatio,
+    this.mainAxisSpacing,
+    this.horizontalPadding,
+    this.bottomPadding = 0,
  });

  @override
@@ -55,87 +82,54 @@ class _LetterScrollbarState extends State<LetterScrollbar> {
      final position = widget.controller.position;
      if (position.maxScrollExtent > 0) {
        final newFraction = (position.pixels / position.maxScrollExtent).clamp(0.0, 1.0);
-        // PERF: Only rebuild if fraction changed by more than 1% to reduce rebuilds
        if ((newFraction - _scrollFraction).abs() > 0.01) {
          setState(() {
            _scrollFraction = newFraction;
+            _currentLetter = _getLetterAtFraction(newFraction);
          });
        }
      }
    }
  }

-  // Build a map of letter -> first index for that letter
-  Map<String, int> get _letterIndexMap {
-    final map = <String, int>{};
-    for (int i = 0; i < widget.items.length; i++) {
-      final item = widget.items[i];
-      if (item.isNotEmpty) {
-        final letter = item[0].toUpperCase();
-        if (!map.containsKey(letter)) {
-          map[letter] = i;
-        }
-      }
+  /// Normalizes a character to a letter for the scrollbar.
+  String _normalizeToLetter(String char) {
+    if (char.isEmpty) return '';
+    final upper = char[0].toUpperCase();
+    if (upper.codeUnitAt(0) >= 65 && upper.codeUnitAt(0) <= 90) {
+      return upper;
    }
-    return map;
+    return '#';
  }

-  String _getLetterAtPosition(double position, double maxHeight) {
-    if (widget.items.isEmpty || maxHeight <= 0) return '';
+  /// Get the letter at a given scroll fraction (0.0 to 1.0)
+  String _getLetterAtFraction(double fraction) {
+    if (widget.items.isEmpty) return '';

-    // Calculate which item index corresponds to this position
-    final fraction = (position / maxHeight).clamp(0.0, 1.0);
-    final index = (fraction * (widget.items.length - 1)).round();
-
-    if (index >= 0 && index < widget.items.length) {
+    final index = (fraction * (widget.items.length - 1)).round().clamp(0, widget.items.length - 1);
+    if (index < widget.items.length) {
      final item = widget.items[index];
      if (item.isNotEmpty) {
-        return item[0].toUpperCase();
+        return _normalizeToLetter(item[0]);
      }
    }
    return '';
  }

-  void _scrollToLetter(String letter) {
-    final letterMap = _letterIndexMap;
-    if (letterMap.containsKey(letter)) {
-      final index = letterMap[letter]!;
-      if (widget.onScrollToIndex != null) {
-        widget.onScrollToIndex!(index);
-      } else {
-        // Estimate scroll position based on index
-        // This is approximate - works better with fixed height items
-        final scrollController = widget.controller;
-        if (scrollController.hasClients) {
-          final maxScroll = scrollController.position.maxScrollExtent;
-          final fraction = index / widget.items.length;
-          final targetScroll = (fraction * maxScroll).clamp(0.0, maxScroll);
-
-          // Update scroll fraction immediately for smooth thumb tracking
-          setState(() {
-            _scrollFraction = fraction;
-          });
-
-          scrollController.jumpTo(targetScroll);
-        }
-      }
-    }
-  }
-
  void _handleDragStart(DragStartDetails details) {
    setState(() {
      _isDragging = true;
      _dragPosition = details.localPosition.dy;
    });
    widget.onDragStateChanged?.call(true);
-    _updateLetterAndScroll(details.localPosition.dy);
+    _scrollToPosition(details.localPosition.dy);
  }

  void _handleDragUpdate(DragUpdateDetails details) {
    setState(() {
      _dragPosition = details.localPosition.dy;
    });
-    _updateLetterAndScroll(details.localPosition.dy);
+    _scrollToPosition(details.localPosition.dy);
  }

  void _handleDragEnd(DragEndDetails details) {
@@ -145,18 +139,35 @@ class _LetterScrollbarState extends State<LetterScrollbar> {
    widget.onDragStateChanged?.call(false);
  }

-  void _updateLetterAndScroll(double position) {
+  /// Scroll proportionally based on drag position
+  void _scrollToPosition(double position) {
    final renderBox = context.findRenderObject() as RenderBox?;
-    if (renderBox != null) {
-      final height = renderBox.size.height;
-      final letter = _getLetterAtPosition(position, height);
-      if (letter.isNotEmpty && letter != _currentLetter) {
-        setState(() {
-          _currentLetter = letter;
-        });
-        _scrollToLetter(letter);
+    if (renderBox == null || !widget.controller.hasClients) return;
+
+    // Account for bottom padding in the effective track height
+    final totalHeight = renderBox.size.height;
+    final effectiveHeight = totalHeight - widget.bottomPadding;
+    if (effectiveHeight <= 0) return;
+
+    // Calculate scroll fraction from position (clamped to effective area)
+    final clampedPosition = position.clamp(0.0, effectiveHeight);
+    final fraction = clampedPosition / effectiveHeight;
+
+    // Get letter for display
+    final letter = _getLetterAtFraction(fraction);
+
+    // Scroll proportionally
+    final maxScroll = widget.controller.position.maxScrollExtent;
+    final targetScroll = (fraction * maxScroll).clamp(0.0, maxScroll);
+
+    setState(() {
+      _scrollFraction = fraction;
+      if (letter.isNotEmpty) {
+        _currentLetter = letter;
      }
-    }
+    });
+
+    widget.controller.jumpTo(targetScroll);
  }

  @override
@@ -168,12 +179,12 @@ class _LetterScrollbarState extends State<LetterScrollbar> {
        // The scrollable content
        widget.child,

-        // The draggable scrollbar area (right edge) - wider grab area
+        // The draggable scrollbar area (right edge)
        Positioned(
          right: 0,
          top: 0,
-          bottom: 0,
-          width: 32, // Wider grab area
+          bottom: widget.bottomPadding,
+          width: 32,
          child: GestureDetector(
            onVerticalDragStart: _handleDragStart,
            onVerticalDragUpdate: _handleDragUpdate,
@@ -196,11 +207,11 @@ class _LetterScrollbarState extends State<LetterScrollbar> {
                final trackHeight = constraints.maxHeight;
                final thumbHeight = _isDragging ? 60.0 : 40.0;
                final availableTrack = trackHeight - thumbHeight;
-                final thumbTop = availableTrack * _scrollFraction;
+                final thumbTop = (availableTrack * _scrollFraction).clamp(0.0, availableTrack);

                return Stack(
                  children: [
-                    // Thumb that tracks scroll position - use AnimatedPositioned for smooth motion
+                    // Thumb that tracks scroll position
                    AnimatedPositioned(
                      duration: const Duration(milliseconds: 50),
                      curve: Curves.linear,
@@ -229,7 +240,10 @@ class _LetterScrollbarState extends State<LetterScrollbar> {
        if (_isDragging && _currentLetter.isNotEmpty)
          Positioned(
            right: 48,
-            top: _dragPosition - 28,
+            top: (_dragPosition - 28).clamp(
+              0.0,
+              (context.findRenderObject() as RenderBox?)?.size.height ?? 500 - 56 - widget.bottomPadding,
+            ),
            child: Material(
              elevation: 4,
              color: colorScheme.primaryContainer,
@@ -6,7 +6,6 @@ import '../../l10n/app_localizations.dart';
 import '../../providers/music_assistant_provider.dart';
 import '../../services/settings_service.dart';
 import '../../theme/design_tokens.dart';
-import '../../theme/theme_provider.dart';
 import '../../theme/palette_helper.dart';
 import '../../constants/timings.dart';
 import '../global_player_overlay.dart';
@@ -41,9 +40,11 @@ class PlayerRevealOverlayState extends State<PlayerRevealOverlay>
  Timer? _refreshTimer;

  // Track vertical drag for dismissal
-  double _dragOffset = 0;
  bool _isDragging = false;

+  // Threshold for drag-to-dismiss (in animation value, 0.0-1.0)
+  static const double _dismissThreshold = 0.7;
+
  // Scroll controller for when player list overflows
  final ScrollController _scrollController = ScrollController();
  bool _isScrollable = false;
@@ -154,13 +155,24 @@ class PlayerRevealOverlayState extends State<PlayerRevealOverlay>
    // Trigger single bounce on mini player when cards are ~70% collapsed
    // This creates the effect of cards "landing" on the mini player
    bool bounceFired = false;
-    void checkBounce() {
-      if (!bounceFired && _revealController.value < 0.3) {
+    void fireBounce() {
+      if (!bounceFired) {
        bounceFired = true;
        GlobalPlayerOverlay.triggerBounce();
      }
    }

+    void checkBounce() {
+      if (_revealController.value < 0.3) {
+        fireBounce();
+      }
+    }
+
+    // If user already dragged past bounce threshold, fire immediately
+    if (_revealController.value < 0.3) {
+      fireBounce();
+    }
+
    _revealController.duration = const Duration(milliseconds: 150);
    _revealController.addListener(checkBounce);
    _revealController.reverse().then((_) {
@@ -201,11 +213,17 @@ class PlayerRevealOverlayState extends State<PlayerRevealOverlay>
    // Ignore swipe up when not scrollable - cards should stay fixed
    if (delta <= 0) return;

-    // Swiping down = dismiss gesture
-    setState(() {
-      _isDragging = true;
-      _dragOffset += delta;
-    });
+    // Swiping down = dismiss gesture - directly control animation controller
+    _isDragging = true;
+
+    // Convert drag delta to animation value change
+    // Use average card travel distance (~150px) as reference
+    const dragSensitivity = 150.0;
+    final valueDelta = delta / dragSensitivity;
+
+    // Decrease animation value (cards move down)
+    final newValue = (_revealController.value - valueDelta).clamp(0.0, 1.0);
+    _revealController.value = newValue;
  }

  void _handleVerticalDragEnd(DragEndDetails details) {
@@ -213,28 +231,21 @@ class PlayerRevealOverlayState extends State<PlayerRevealOverlay>

    // If not dragging (was scrolling), don't dismiss
    if (!_isDragging) return;
+    _isDragging = false;

-    // Dismiss if dragged down enough or with enough velocity
-    if (_dragOffset > 100 || velocity > 500) {
+    // Dismiss if dragged past threshold or with enough velocity
+    if (_revealController.value < _dismissThreshold || velocity > 500) {
      HapticFeedback.lightImpact();
-      // Reset drag offset before dismiss so animation starts from correct position
-      setState(() {
-        _isDragging = false;
-        _dragOffset = 0;
-      });
      dismiss();
    } else {
-      // Spring back
-      setState(() {
-        _isDragging = false;
-        _dragOffset = 0;
-      });
+      // Spring back to fully revealed
+      _revealController.duration = const Duration(milliseconds: 150);
+      _revealController.forward();
    }
  }

  @override
  Widget build(BuildContext context) {
-    final themeProvider = context.watch<ThemeProvider>();
    final colorScheme = Theme.of(context).colorScheme;
    final isDark = Theme.of(context).brightness == Brightness.dark;

@@ -322,7 +333,7 @@ class PlayerRevealOverlayState extends State<PlayerRevealOverlay>
                Positioned(
                  left: 12,
                  right: 12,
-                  bottom: widget.miniPlayerBottom + widget.miniPlayerHeight + 8 - _dragOffset,
+                  bottom: widget.miniPlayerBottom + widget.miniPlayerHeight + 8,
                  child: GestureDetector(
                    onVerticalDragUpdate: _handleVerticalDragUpdate,
                    onVerticalDragEnd: _handleVerticalDragEnd,
@@ -3,10 +3,12 @@ import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:cached_network_image/cached_network_image.dart';
+import '../../l10n/app_localizations.dart';
 import '../../providers/music_assistant_provider.dart';
 import '../../models/player.dart';
 import '../../theme/design_tokens.dart';
 import '../common/empty_state.dart';
+import '../global_player_overlay.dart';

 /// Panel that displays the current playback queue with drag-to-reorder
 /// and swipe-left-to-delete functionality.
@@ -49,10 +51,14 @@ class QueuePanel extends StatefulWidget {
  State<QueuePanel> createState() => _QueuePanelState();
 }

-class _QueuePanelState extends State<QueuePanel> {
+class _QueuePanelState extends State<QueuePanel> with SingleTickerProviderStateMixin {
  List<QueueItem> _items = [];
  final GlobalKey _stackKey = GlobalKey();

+  // Transfer dropdown animation
+  late AnimationController _dropdownController;
+  bool _showingTransferDropdown = false;
+
  // Drag state
  int? _dragIndex;
  int? _dragStartIndex;
@@ -90,6 +96,10 @@ class _QueuePanelState extends State<QueuePanel> {
  void initState() {
    super.initState();
    _items = List.from(widget.queue?.items ?? []);
+    _dropdownController = AnimationController(
+      vsync: this,
+      duration: const Duration(milliseconds: 300),
+    );
  }

  @override
@@ -125,6 +135,7 @@ class _QueuePanelState extends State<QueuePanel> {

  @override
  void dispose() {
+    _dropdownController.dispose();
    _pendingReorderTimer?.cancel();
    super.dispose();
  }
@@ -152,9 +163,7 @@ class _QueuePanelState extends State<QueuePanel> {
    if (playerId != null) {
      try {
        await widget.maProvider.api?.queueCommandDeleteItem(playerId, item.queueItemId);
-        debugPrint('QueuePanel: Delete successful for ${item.track.name}');
      } catch (e) {
-        debugPrint('QueuePanel: Error deleting queue item: $e');
        // Rollback: re-insert the item or refresh from server
        // Refresh is safer as queue may have changed
        widget.onRefresh();
@@ -175,12 +184,180 @@ class _QueuePanelState extends State<QueuePanel> {
    try {
      await widget.maProvider.api?.queueCommandClear(playerId);
    } catch (e) {
-      debugPrint('QueuePanel: Error clearing queue: $e');
      // Refresh to restore if failed
      widget.onRefresh();
    }
  }

+  void _openTransferDropdown() {
+    if (_showingTransferDropdown) return;
+    setState(() => _showingTransferDropdown = true);
+    _dropdownController.forward();
+  }
+
+  void _closeTransferDropdown() {
+    if (!_showingTransferDropdown) return;
+    _dropdownController.reverse().then((_) {
+      if (mounted) setState(() => _showingTransferDropdown = false);
+    });
+  }
+
+  void _handleTransferQueue(BuildContext context) {
+    if (_showingTransferDropdown) {
+      _closeTransferDropdown();
+    } else {
+      _openTransferDropdown();
+    }
+  }
+
+  List<Player> _getTargetPlayers() {
+    // Use selected player (current player) as source, not the queue's player ID
+    // This ensures correct filtering after queue transfer when player switches
+    final sourcePlayerId = widget.maProvider.selectedPlayer?.playerId;
+    if (sourcePlayerId == null) return [];
+    return widget.maProvider.availablePlayers
+        .where((p) => p.playerId != sourcePlayerId && p.available)
+        .toList();
+  }
+
+  Widget _buildTransferDropdown() {
+    final targetPlayers = _getTargetPlayers();
+    final colorScheme = Theme.of(context).colorScheme;
+
+    // Use a lighter shade of the queue panel background color
+    final hsl = HSLColor.fromColor(widget.backgroundColor);
+    final menuBackground = hsl.withLightness((hsl.lightness + 0.04).clamp(0.0, 1.0)).toColor();
+    // Use theme's onSurface for text (matches library dropdown styling)
+    final menuTextColor = colorScheme.onSurface;
+
+    return Container(
+      constraints: const BoxConstraints(maxHeight: 280, maxWidth: 220),
+      decoration: BoxDecoration(
+        color: menuBackground,
+        borderRadius: BorderRadius.circular(12),
+        boxShadow: [
+          BoxShadow(
+            color: Colors.black.withOpacity(0.3),
+            blurRadius: 12,
+            offset: const Offset(0, 6),
+          ),
+        ],
+      ),
+      child: Material(
+        color: Colors.transparent,
+        borderRadius: BorderRadius.circular(12),
+        clipBehavior: Clip.antiAlias,
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            // Title header (matches library dropdown section headers)
+            Padding(
+              padding: const EdgeInsets.fromLTRB(16, 12, 16, 4),
+              child: Text(
+                S.of(context)!.transferTo,
+                style: TextStyle(
+                  fontSize: 12,
+                  fontWeight: FontWeight.w600,
+                  color: menuTextColor.withOpacity(0.5),
+                ),
+              ),
+            ),
+
+            // Player list
+            if (targetPlayers.isEmpty)
+              Padding(
+                padding: const EdgeInsets.fromLTRB(16, 8, 16, 16),
+                child: Text(
+                  S.of(context)!.noOtherPlayersAvailable,
+                  style: TextStyle(color: menuTextColor.withOpacity(0.5), fontSize: 14),
+                ),
+              )
+            else
+              Flexible(
+                child: ListView.builder(
+                  shrinkWrap: true,
+                  padding: const EdgeInsets.only(bottom: 8),
+                  itemCount: targetPlayers.length,
+                  itemBuilder: (context, index) {
+                    final player = targetPlayers[index];
+
+                    // Status color
+                    Color statusColor;
+                    if (!player.powered) {
+                      statusColor = Colors.grey;
+                    } else if (player.state == 'playing') {
+                      statusColor = Colors.green;
+                    } else {
+                      statusColor = Colors.orange;
+                    }
+
+                    // Match library dropdown item styling
+                    return InkWell(
+                      onTap: () => _transferToPlayer(player),
+                      child: Padding(
+                        padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+                        child: Row(
+                          children: [
+                            Icon(Icons.speaker_rounded, color: menuTextColor, size: 18),
+                            const SizedBox(width: 12),
+                            Expanded(
+                              child: Text(
+                                player.name,
+                                style: TextStyle(color: menuTextColor),
+                                overflow: TextOverflow.ellipsis,
+                              ),
+                            ),
+                            const SizedBox(width: 8),
+                            Container(
+                              width: 8,
+                              height: 8,
+                              decoration: BoxDecoration(
+                                shape: BoxShape.circle,
+                                color: statusColor,
+                              ),
+                            ),
+                          ],
+                        ),
+                      ),
+                    );
+                  },
+                ),
+              ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Future<void> _transferToPlayer(Player targetPlayer) async {
+    final sourcePlayerId = widget.queue?.playerId;
+    if (sourcePlayerId == null) return;
+
+    // Close dropdown first
+    _closeTransferDropdown();
+
+    try {
+      await widget.maProvider.api?.transferQueue(
+        sourceQueueId: sourcePlayerId,
+        targetQueueId: targetPlayer.playerId,
+        autoPlay: true,
+      );
+
+
+      // Clear source player's track cache since its queue was transferred away
+      widget.maProvider.clearPlayerTrackCache(sourcePlayerId);
+
+      // Force collapse to mini player (closes queue instantly + collapses)
+      GlobalPlayerOverlay.forceCollapsePlayer();
+
+      // Switch to the target player - mini player will update to show new player
+      widget.maProvider.selectPlayer(targetPlayer);
+    } catch (e) {
+      // Error transferring queue - handled silently
+    }
+  }
+
  void _resetSwipeState() {
    _swipeStart = null;
    _swipeLast = null;
@@ -343,11 +520,9 @@ class _QueuePanelState extends State<QueuePanel> {
      final playerId = widget.queue?.playerId;
      // API uses relative shift: positive = down, negative = up
      final posShift = newIndex - originalIndex;
-      debugPrint('QueuePanel: Moving ${item.track.name} from $originalIndex to $newIndex (shift: $posShift, queueItemId: ${item.queueItemId})');
      if (playerId != null) {
        try {
          await widget.maProvider.api?.queueCommandMoveItem(playerId, item.queueItemId, posShift);
-          debugPrint('QueuePanel: Move API call completed successfully');
          // Allow updates again after a delay for server state to propagate
          _pendingReorderTimer = Timer(const Duration(milliseconds: 2000), () {
            if (mounted) {
@@ -357,7 +532,6 @@ class _QueuePanelState extends State<QueuePanel> {
            }
          });
        } catch (e) {
-          debugPrint('QueuePanel: Move API error: $e');
          // Clear pending state immediately on error
          if (mounted) {
            setState(() {
@@ -368,7 +542,6 @@ class _QueuePanelState extends State<QueuePanel> {
          widget.onRefresh();
        }
      } else {
-        debugPrint('QueuePanel: playerId is null, cannot move');
        // Clear pending state
        if (mounted) {
          setState(() {
@@ -415,7 +588,7 @@ class _QueuePanelState extends State<QueuePanel> {
    try {
      await widget.maProvider.api?.queueCommandPlayIndex(playerId, item.queueItemId);
    } catch (e) {
-      debugPrint('QueuePanel: Error playing index: $e');
+      // Error playing index - handled silently
    }

    // Clear optimistic state after delay - server state will take over
@@ -506,41 +679,55 @@ class _QueuePanelState extends State<QueuePanel> {
      },
      child: Container(
        color: widget.backgroundColor,
-        child: Column(
+        child: Stack(
          children: [
-            // Header
-            Container(
-              padding: EdgeInsets.only(top: widget.topPadding + 4, left: 4, right: 16),
-              child: Row(
-                children: [
-                  IconButton(
-                    icon: Icon(Icons.arrow_back_rounded, color: widget.textColor, size: IconSizes.md),
-                    onPressed: widget.onClose,
-                    padding: Spacing.paddingAll12,
+            // Main content column
+            Column(
+              children: [
+                // Header
+                Container(
+                  padding: EdgeInsets.only(top: widget.topPadding + 4, left: 4, right: 16),
+                  child: Row(
+                    children: [
+                      IconButton(
+                        icon: Icon(Icons.arrow_back_rounded, color: widget.textColor, size: IconSizes.md),
+                        onPressed: _showingTransferDropdown ? _closeTransferDropdown : widget.onClose,
+                        padding: Spacing.paddingAll12,
+                      ),
+                      const Spacer(),
+                      Text(
+                        'Queue',
+                        style: TextStyle(
+                          color: widget.textColor,
+                          fontSize: 18,
+                          fontWeight: FontWeight.w600,
+                        ),
+                      ),
+                      const Spacer(),
+                      // Transfer queue button
+                      IconButton(
+                        icon: Icon(
+                          _showingTransferDropdown ? Icons.close : Icons.swap_horiz_rounded,
+                          color: _showingTransferDropdown ? widget.primaryColor : widget.textColor.withOpacity(0.7),
+                          size: IconSizes.sm,
+                        ),
+                        onPressed: () => _handleTransferQueue(context),
+                        padding: Spacing.paddingAll12,
+                        tooltip: S.of(context)!.transferQueueToPlayer,
+                      ),
+                      // Clear queue button
+                      IconButton(
+                        icon: Icon(Icons.delete_sweep_rounded, color: widget.textColor.withOpacity(0.7), size: IconSizes.sm),
+                        onPressed: _handleClearQueue,
+                        padding: Spacing.paddingAll12,
+                        tooltip: S.of(context)!.clearQueue,
+                      ),
+                    ],
                  ),
-                  const Spacer(),
-                  Text(
-                    'Queue',
-                    style: TextStyle(
-                      color: widget.textColor,
-                      fontSize: 18,
-                      fontWeight: FontWeight.w600,
-                    ),
-                  ),
-                  const Spacer(),
-                  // Clear queue button
-                  IconButton(
-                    icon: Icon(Icons.delete_sweep_rounded, color: widget.textColor.withOpacity(0.7), size: IconSizes.sm),
-                    onPressed: _handleClearQueue,
-                    padding: Spacing.paddingAll12,
-                    tooltip: 'Clear queue',
-                  ),
-                ],
-              ),
-            ),
+                ),

-            // Queue content
-            Expanded(
+                // Queue content
+                Expanded(
              child: widget.isLoading
                  ? Center(child: CircularProgressIndicator(color: widget.primaryColor))
                  : widget.queue == null || _items.isEmpty
@@ -585,7 +772,49 @@ class _QueuePanelState extends State<QueuePanel> {
                            ],
                          ),
                        ),
+                ),
+              ],
            ),
+
+            // Floating dropdown overlay for transfer
+            if (_showingTransferDropdown) ...[
+              // Tap-to-dismiss backdrop
+              Positioned.fill(
+                child: GestureDetector(
+                  onTap: _closeTransferDropdown,
+                  behavior: HitTestBehavior.opaque,
+                  child: Container(color: Colors.transparent),
+                ),
+              ),
+              // Dropdown menu with open/close animation
+              Positioned(
+                top: widget.topPadding + 52, // Below header
+                right: 56, // Aligned with transfer button
+                child: AnimatedBuilder(
+                  animation: CurvedAnimation(
+                    parent: _dropdownController,
+                    curve: Curves.easeInOut,
+                  ),
+                  builder: (context, child) {
+                    final value = _dropdownController.value;
+                    final curvedValue = Curves.easeInOut.transform(value);
+
+                    return ClipRect(
+                      child: Align(
+                        alignment: Alignment.topCenter,
+                        widthFactor: 1.0,
+                        heightFactor: curvedValue,
+                        child: Opacity(
+                          opacity: curvedValue,
+                          child: child,
+                        ),
+                      ),
+                    );
+                  },
+                  child: _buildTransferDropdown(),
+                ),
+              ),
+            ],
          ],
        ),
      ),
@@ -775,3 +1004,4 @@ class _VelocitySample {

  _VelocitySample(this.position, this.timeMs);
 }
+
@@ -212,6 +212,7 @@ Future<void> showPlayerPickerSheet({
    context: context,
    backgroundColor: Colors.transparent,
    isScrollControlled: true,
+    useRootNavigator: true, // Required for overlays like QueuePanel
    builder: (context) => PlayerPickerSheet(
      title: title,
      players: players,
@@ -245,14 +245,12 @@ class _PlayerSelectorSheetState extends State<_PlayerSelectorSheet> {
                                    // Show snackbar for visual feedback
                                    ScaffoldMessenger.of(context).showSnackBar(
                                      SnackBar(
-                                        content: Text('Syncing ${player.name}...'),
+                                        content: Text(S.of(context)!.syncingPlayer(player.name)),
                                        duration: const Duration(seconds: 2),
                                      ),
                                    );

                                    // Long-press to sync/unsync player
-                                    debugPrint('🔗 Long-press on ${player.name} (${player.playerId})');
-                                    debugPrint('🔗 Player isGrouped: ${player.isGrouped}, groupMembers: ${player.groupMembers}');
                                    maProvider.togglePlayerSync(player.playerId);
                                  },
                                  borderRadius: BorderRadius.circular(16),
@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import 'package:cached_network_image/cached_network_image.dart';
@@ -5,10 +6,11 @@ import '../models/media_item.dart';
 import '../providers/music_assistant_provider.dart';
 import '../screens/playlist_details_screen.dart';
 import '../constants/hero_tags.dart';
+import '../constants/timings.dart';
 import '../theme/theme_provider.dart';
 import '../utils/page_transitions.dart';

-class PlaylistCard extends StatelessWidget {
+class PlaylistCard extends StatefulWidget {
  final Playlist playlist;
  final VoidCallback? onTap;
  final String? heroTagSuffix;
@@ -22,31 +24,47 @@ class PlaylistCard extends StatelessWidget {
    this.imageCacheSize,
  });

+  @override
+  State<PlaylistCard> createState() => _PlaylistCardState();
+}
+
+class _PlaylistCardState extends State<PlaylistCard> {
+  bool _isNavigating = false;
+
  @override
  Widget build(BuildContext context) {
    final maProvider = context.read<MusicAssistantProvider>();
-    final imageUrl = maProvider.api?.getImageUrl(playlist, size: 256);
+    final imageUrl = maProvider.api?.getImageUrl(widget.playlist, size: 256);
    final colorScheme = Theme.of(context).colorScheme;
    final textTheme = Theme.of(context).textTheme;

-    final suffix = heroTagSuffix != null ? '_$heroTagSuffix' : '';
-    final cacheSize = imageCacheSize ?? 256;
+    final suffix = widget.heroTagSuffix != null ? '_${widget.heroTagSuffix}' : '';
+    final cacheSize = widget.imageCacheSize ?? 256;

    return RepaintBoundary(
      child: GestureDetector(
-        onTap: onTap ?? () {
+        onTap: widget.onTap ?? () {
+          // Prevent double-tap navigation
+          if (_isNavigating) return;
+          _isNavigating = true;
+
          // Update adaptive colors immediately on tap
          updateAdaptiveColorsFromImage(context, imageUrl);
          Navigator.push(
            context,
            FadeSlidePageRoute(
              child: PlaylistDetailsScreen(
-                playlist: playlist,
-                heroTagSuffix: heroTagSuffix,
+                playlist: widget.playlist,
+                heroTagSuffix: widget.heroTagSuffix,
                initialImageUrl: imageUrl,
              ),
            ),
-          );
+          ).then((_) {
+            // Reset after navigation debounce delay
+            Future.delayed(Timings.navigationDebounce, () {
+              if (mounted) _isNavigating = false;
+            });
+          });
        },
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
@@ -55,7 +73,7 @@ class PlaylistCard extends StatelessWidget {
            AspectRatio(
              aspectRatio: 1.0,
              child: Hero(
-                tag: HeroTags.playlistCover + (playlist.uri ?? playlist.itemId) + suffix,
+                tag: HeroTags.playlistCover + (widget.playlist.uri ?? widget.playlist.itemId) + suffix,
                child: ClipRRect(
                  borderRadius: BorderRadius.circular(12.0),
                  child: Container(
@@ -91,11 +109,11 @@ class PlaylistCard extends StatelessWidget {
            const SizedBox(height: 8),
            // Playlist title
            Hero(
-              tag: HeroTags.playlistTitle + (playlist.uri ?? playlist.itemId) + suffix,
+              tag: HeroTags.playlistTitle + (widget.playlist.uri ?? widget.playlist.itemId) + suffix,
              child: Material(
                color: Colors.transparent,
                child: Text(
-                  playlist.name,
+                  widget.playlist.name,
                  maxLines: 1,
                  overflow: TextOverflow.ellipsis,
                  style: textTheme.titleSmall?.copyWith(
@@ -107,7 +125,7 @@ class PlaylistCard extends StatelessWidget {
            ),
            // Owner/track count
            Text(
-              playlist.owner ?? (playlist.trackCount != null ? '${playlist.trackCount} tracks' : ''),
+              widget.playlist.owner ?? (widget.playlist.trackCount != null ? '${widget.playlist.trackCount} tracks' : ''),
              maxLines: 1,
              overflow: TextOverflow.ellipsis,
              style: textTheme.bodySmall?.copyWith(
@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import 'package:cached_network_image/cached_network_image.dart';
@@ -6,10 +7,11 @@ import '../models/media_item.dart';
 import '../providers/music_assistant_provider.dart';
 import '../screens/podcast_detail_screen.dart';
 import '../constants/hero_tags.dart';
+import '../constants/timings.dart';
 import '../theme/theme_provider.dart';
 import '../utils/page_transitions.dart';

-class PodcastCard extends StatelessWidget {
+class PodcastCard extends StatefulWidget {
  final MediaItem podcast;
  final VoidCallback? onTap;
  final String? heroTagSuffix;
@@ -25,34 +27,50 @@ class PodcastCard extends StatelessWidget {
    this.imageCacheSize,
  });

+  @override
+  State<PodcastCard> createState() => _PodcastCardState();
+}
+
+class _PodcastCardState extends State<PodcastCard> {
+  bool _isNavigating = false;
+
  @override
  Widget build(BuildContext context) {
    final maProvider = context.read<MusicAssistantProvider>();
    // Use provider's getPodcastImageUrl which includes iTunes cache
-    final imageUrl = maProvider.getPodcastImageUrl(podcast, size: 256);
+    final imageUrl = maProvider.getPodcastImageUrl(widget.podcast, size: 256);
    final colorScheme = Theme.of(context).colorScheme;
    final textTheme = Theme.of(context).textTheme;

-    final suffix = heroTagSuffix != null ? '_$heroTagSuffix' : '';
+    final suffix = widget.heroTagSuffix != null ? '_${widget.heroTagSuffix}' : '';

    // PERF: Use appropriate cache size based on display size
-    final cacheSize = imageCacheSize ?? 256;
+    final cacheSize = widget.imageCacheSize ?? 256;

    return RepaintBoundary(
      child: GestureDetector(
-        onTap: onTap ?? () {
+        onTap: widget.onTap ?? () {
+          // Prevent double-tap navigation
+          if (_isNavigating) return;
+          _isNavigating = true;
+
          // Update adaptive colors immediately on tap
          updateAdaptiveColorsFromImage(context, imageUrl);
          Navigator.push(
            context,
            FadeSlidePageRoute(
              child: PodcastDetailScreen(
-                podcast: podcast,
-                heroTagSuffix: heroTagSuffix,
+                podcast: widget.podcast,
+                heroTagSuffix: widget.heroTagSuffix,
                initialImageUrl: imageUrl,
              ),
            ),
-          );
+          ).then((_) {
+            // Reset after navigation debounce delay
+            Future.delayed(Timings.navigationDebounce, () {
+              if (mounted) _isNavigating = false;
+            });
+          });
        },
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
@@ -61,7 +79,7 @@ class PodcastCard extends StatelessWidget {
            AspectRatio(
              aspectRatio: 1.0,
              child: Hero(
-                tag: HeroTags.podcastCover + (podcast.uri ?? podcast.itemId) + suffix,
+                tag: HeroTags.podcastCover + (widget.podcast.uri ?? widget.podcast.itemId) + suffix,
                child: ClipRRect(
                  borderRadius: BorderRadius.circular(12.0),
                  child: Container(
@@ -97,11 +115,11 @@ class PodcastCard extends StatelessWidget {
            const SizedBox(height: 8),
            // Podcast title
            Hero(
-              tag: HeroTags.podcastTitle + (podcast.uri ?? podcast.itemId) + suffix,
+              tag: HeroTags.podcastTitle + (widget.podcast.uri ?? widget.podcast.itemId) + suffix,
              child: Material(
                color: Colors.transparent,
                child: Text(
-                  podcast.name,
+                  widget.podcast.name,
                  maxLines: 1,
                  overflow: TextOverflow.ellipsis,
                  style: textTheme.titleSmall?.copyWith(
@@ -113,7 +131,7 @@ class PodcastCard extends StatelessWidget {
            ),
            // Podcast author (if available)
            Text(
-              _getAuthor(podcast),
+              _getAuthor(widget.podcast),
              maxLines: 1,
              overflow: TextOverflow.ellipsis,
              style: textTheme.bodySmall?.copyWith(
@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:provider/provider.dart';
@@ -5,8 +6,9 @@ import 'package:cached_network_image/cached_network_image.dart';
 import '../models/media_item.dart';
 import '../providers/music_assistant_provider.dart';
 import '../constants/hero_tags.dart';
+import '../constants/timings.dart';

-class RadioStationCard extends StatelessWidget {
+class RadioStationCard extends StatefulWidget {
  final MediaItem radioStation;
  final VoidCallback? onTap;
  final String? heroTagSuffix;
@@ -20,25 +22,41 @@ class RadioStationCard extends StatelessWidget {
    this.imageCacheSize,
  });

+  @override
+  State<RadioStationCard> createState() => _RadioStationCardState();
+}
+
+class _RadioStationCardState extends State<RadioStationCard> {
+  bool _isTapping = false;
+
  @override
  Widget build(BuildContext context) {
    final maProvider = context.read<MusicAssistantProvider>();
-    final imageUrl = maProvider.api?.getImageUrl(radioStation, size: 256);
+    final imageUrl = maProvider.api?.getImageUrl(widget.radioStation, size: 256);
    final colorScheme = Theme.of(context).colorScheme;
    final textTheme = Theme.of(context).textTheme;

-    final suffix = heroTagSuffix != null ? '_$heroTagSuffix' : '';
-    final cacheSize = imageCacheSize ?? 256;
+    final suffix = widget.heroTagSuffix != null ? '_${widget.heroTagSuffix}' : '';
+    final cacheSize = widget.imageCacheSize ?? 256;

    return RepaintBoundary(
      child: GestureDetector(
-        onTap: onTap ?? () {
+        onTap: widget.onTap ?? () {
+          // Prevent double-tap actions
+          if (_isTapping) return;
+          _isTapping = true;
+
          HapticFeedback.mediumImpact();
          // Play the radio station on selected player
          final selectedPlayer = maProvider.selectedPlayer;
          if (selectedPlayer != null) {
-            maProvider.api?.playRadioStation(selectedPlayer.playerId, radioStation);
+            maProvider.api?.playRadioStation(selectedPlayer.playerId, widget.radioStation);
          }
+
+          // Reset after debounce delay
+          Future.delayed(Timings.navigationDebounce, () {
+            if (mounted) _isTapping = false;
+          });
        },
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
@@ -47,7 +65,7 @@ class RadioStationCard extends StatelessWidget {
            AspectRatio(
              aspectRatio: 1.0,
              child: Hero(
-                tag: HeroTags.radioCover + (radioStation.uri ?? radioStation.itemId) + suffix,
+                tag: HeroTags.radioCover + (widget.radioStation.uri ?? widget.radioStation.itemId) + suffix,
                child: ClipOval(
                  child: Container(
                    color: colorScheme.surfaceContainerHighest,
@@ -84,11 +102,11 @@ class RadioStationCard extends StatelessWidget {
            SizedBox(
              height: 36, // Fixed height for 2 lines of text
              child: Hero(
-                tag: HeroTags.radioTitle + (radioStation.uri ?? radioStation.itemId) + suffix,
+                tag: HeroTags.radioTitle + (widget.radioStation.uri ?? widget.radioStation.itemId) + suffix,
                child: Material(
                  color: Colors.transparent,
                  child: Text(
-                    radioStation.name,
+                    widget.radioStation.name,
                    maxLines: 2,
                    overflow: TextOverflow.ellipsis,
                    textAlign: TextAlign.center,
@@ -1,7 +1,7 @@
 name: ensemble
 description: A minimalistic Music Assistant client built with Flutter
 publish_to: 'none'
-version: 2.8.7-beta+45
+version: 2.8.9-beta+47

 environment:
  sdk: '>=3.0.0 <4.0.0'