Bump version to 2.8.6-beta+44

Two issues fixed:

1. Podcast name now displays correctly (not episode name twice)
   - Added _currentPodcastName context field to provider
   - Set podcast name when playing from podcast detail screen
   - Clear context on media type change, external source, or playback stop
   - Removed fallback to album/artist (which contained episode name)

2. Text overlap in mini player for long podcast titles
   - Changed maxLines from 2 to conditional (1 when collapsed, 2 when expanded)
   - Fixed trackInfoBlockHeight to account for podcasts hiding album line

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.github/workflows/build-apk.yml

@@ -4,10 +4,13 @@ on:
   push:
     branches:
       - main
+      - master
       - 'claude/**'
+      - 'feature/**'
   pull_request:
     branches:
       - main
+      - master
   workflow_dispatch:
 
 jobs:
@@ -32,9 +35,25 @@ jobs:
           channel: 'stable'
           cache: true
 
+      - name: Cache Gradle dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: gradle-${{ runner.os }}-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            gradle-${{ runner.os }}-
+
       - name: Get dependencies
         run: flutter pub get
 
+      - name: Generate code (Drift database)
+        run: dart run build_runner build --delete-conflicting-outputs
+
+      - name: Generate localizations
+        run: flutter gen-l10n
+
       - name: Generate launcher icons
         run: flutter pub run flutter_launcher_icons
 
@@ -56,7 +75,12 @@ jobs:
           EOF
 
       - name: Build APK
-        run: flutter build apk --release
+        run: |
+          # Use init.gradle to force Maven mirrors (workaround for Maven Central 403)
+          mkdir -p ~/.gradle
+          cp android/init.gradle ~/.gradle/init.gradle
+
+          flutter build apk --release
 
       - name: Upload APK artifact
         uses: actions/upload-artifact@v4

.prompts/player-animation-audit.md

@@ -0,0 +1,182 @@
+# Player System Animation & Polish Audit
+
+## Context
+
+This is a Music Assistant client app (Ensemble) built with Flutter. The player system has undergone extensive development and now needs a comprehensive polish audit. The goal is buttery smooth 60fps animations and a premium user experience.
+
+## Architecture Overview
+
+The player system consists of three interconnected components:
+
+1. **Mini Player** (collapsed state) - Floating card at bottom, shows current track
+2. **Expanded Player** - Full-screen player with album art, controls, progress
+3. **Queue Panel** - Slides in from right of expanded player, shows playback queue
+
+Additionally:
+- **Player Selector** - Horizontal swipe between multiple players (collapsed mode)
+- **Device Reveal** - Swipe down from mini player to show available players
+
+## Key Files
+
+```
+lib/widgets/
+├── expandable_player.dart      # Main player widget (1800+ lines)
+├── global_player_overlay.dart  # Overlay wrapper, static accessors
+├── player/
+│   ├── queue_panel.dart        # Queue list with great_list_view
+│   ├── chapters_panel.dart     # Audiobook chapters
+│   └── mini_player_content.dart
+```
+
+## CRITICAL CONSTRAINTS
+
+1. **DO NOT MODIFY the queue list implementation** - It uses `great_list_view` package with `AutomaticAnimatedListView`. This was chosen specifically to avoid Flutter's grey screen overlay bug (#103804). The current implementation works correctly.
+
+2. **Preserve all existing functionality** - Focus on polish, not rewrites
+
+3. **Test changes incrementally** - This system is complex with many interdependencies
+
+## Audit Areas
+
+### 1. Animation Performance Audit
+
+Use sub-agents to analyze each animation system:
+
+**Agent 1: Expand/Collapse Animation**
+- Analyze `_controller` and `_expandAnimation`
+- Check for jank during morphing transition
+- Verify lerp functions are efficient
+- Look for unnecessary rebuilds during animation
+- Check `RepaintBoundary` placement
+
+**Agent 2: Queue Panel Animation**
+- Analyze `_queuePanelController` and `_queuePanelAnimation`
+- Verify slide-in/out is smooth
+- Check interaction with expanded player state
+- Verify the Listener-based swipe detection doesn't cause issues
+
+**Agent 3: Player Selector Animation**
+- Analyze horizontal swipe between players
+- Check `_slideOffset` and peek player animations
+- Verify finger-following feels natural
+- Look for edge cases with rapid swipes
+
+**Agent 4: Micro-interactions**
+- Play/pause button animations
+- Progress bar interactions
+- Volume swipe overlay
+- Favorite button feedback
+- Skip button responsiveness
+
+### 2. State Management Audit
+
+**Check for:**
+- Unnecessary `setState` calls during animations
+- ValueNotifier usage efficiency
+- Animation listener cleanup
+- Memory leaks from subscriptions
+- State synchronization between components
+
+### 3. Visual Polish Audit
+
+**Check for:**
+- Color transitions during expand/collapse
+- Text fade/scale animations
+- Image loading placeholders
+- Shadow/elevation consistency
+- Border radius morphing smoothness
+- Safe area handling
+
+### 4. Gesture Conflict Resolution
+
+**Verify:**
+- Vertical drag (expand/collapse) vs horizontal drag (player switch)
+- Queue panel swipe-right-to-close vs Dismissible swipe-left-to-delete
+- Edge dead zones for Android back gesture
+- Tap vs drag disambiguation
+
+### 5. Edge Cases
+
+**Test scenarios:**
+- Rapid expand/collapse
+- Swipe during animation
+- Back button during animations
+- Track change during queue scroll
+- Network image loading failures
+- Very long track/artist names
+
+## Execution Strategy
+
+```
+ultrathink: true
+```
+
+### Phase 1: Discovery (Read-Only)
+Launch parallel sub-agents to analyze each file:
+- Read and understand the animation architecture
+- Map all animation controllers and their relationships
+- Identify potential performance bottlenecks
+- Document current RepaintBoundary usage
+
+### Phase 2: Analysis Report
+Compile findings into categories:
+- **Critical**: Causes visible jank or bugs
+- **Important**: Noticeable but not breaking
+- **Nice-to-have**: Minor polish improvements
+
+### Phase 3: Implementation Plan
+For each finding:
+- Specific file and line numbers
+- Proposed change
+- Risk assessment
+- Testing approach
+
+### Phase 4: Incremental Fixes
+- One fix at a time
+- Build and test after each change
+- Verify no regressions
+
+## Output Format
+
+Provide a structured audit report:
+
+```markdown
+## Animation Audit Report
+
+### Executive Summary
+[2-3 sentences on overall state]
+
+### Critical Issues
+1. [Issue]: [File:Line] - [Description] - [Proposed Fix]
+
+### Important Issues
+1. [Issue]: [File:Line] - [Description] - [Proposed Fix]
+
+### Polish Opportunities
+1. [Issue]: [File:Line] - [Description] - [Proposed Fix]
+
+### Architecture Observations
+[Notes on overall structure, patterns noticed]
+
+### Recommended Priority Order
+1. [First fix]
+2. [Second fix]
+...
+```
+
+## Success Criteria
+
+After this audit and fixes:
+- All animations run at consistent 60fps
+- No jank during any transition
+- Gestures feel responsive and natural
+- State transitions are seamless
+- No visual glitches or flickers
+- Memory usage is stable during interactions
+
+## Notes
+
+- The app uses adaptive theming (colors extracted from album art)
+- There's an `AnimationDebugger` utility for profiling
+- Position tracking uses a shared `PositionTracker` singleton
+- The player supports both music and audiobooks (different UI modes)

AUDIT-PROMPT.md

@@ -0,0 +1,391 @@
+# Ensemble Codebase Intensive Audit Prompt
+
+## Overview
+
+You are tasked with conducting an intensive, comprehensive audit of the **Ensemble** Flutter application - a Music Assistant client for Android with multi-device synchronization, local playback, and Sendspin raw audio streaming capabilities.
+
+**Codebase Statistics:**
+- 90 Dart files, ~40,583 lines of code
+- 18 screens, 27 services, 6 providers
+- Architecture: Provider pattern with ChangeNotifier
+- Audio: just_audio + flutter_pcm_sound + audio_service
+- Networking: WebSocket (JSON-RPC) + HTTP + Sendspin binary protocol
+
+---
+
+## Audit Scope
+
+Perform a thorough audit covering ALL of the following areas. For each issue found, provide:
+1. **File path and line number(s)**
+2. **Severity**: CRITICAL / HIGH / MEDIUM / LOW
+3. **Description** of the issue
+4. **Impact** if left unfixed
+5. **Recommended fix** with code example where applicable
+
+---
+
+## SECTION 1: SECURITY AUDIT
+
+### 1.1 Credential Storage (CRITICAL PRIORITY)
+Audit `/lib/services/settings_service.dart` for:
+- [ ] Plaintext password storage in SharedPreferences (lines 209-222)
+- [ ] Auth tokens stored without encryption
+- [ ] Serialized credentials in JSON format (lines 169-190)
+
+**Expected Finding:** Credentials stored insecurely. Recommend flutter_secure_storage.
+
+### 1.2 Certificate Validation
+Audit `/lib/services/auth/auth_manager.dart` for:
+- [ ] HTTPS redirect handling for local IPs
+- [ ] Certificate validation disabled scenarios
+- [ ] MITM vulnerability exposure
+
+### 1.3 Authentication Strategies
+Audit all files in `/lib/services/auth/`:
+- [ ] `basic_auth_strategy.dart` - Base64 encoding (not encryption)
+- [ ] `authelia_strategy.dart` - Session cookie handling, timing attack (line 159)
+- [ ] `ma_auth_strategy.dart` - Token refresh mechanism
+- [ ] `no_auth_strategy.dart` - Public server exposure
+
+### 1.4 Input Validation
+Audit `/lib/services/music_assistant_api.dart`:
+- [ ] URI construction without validation (lines 1346-1360)
+- [ ] Provider/itemId injection risks
+- [ ] WebSocket message validation
+
+### 1.5 Information Disclosure
+- [ ] Debug logs exposing sensitive data (check all `_logger.log()` calls)
+- [ ] Server version exposure via `server_info`
+- [ ] Error messages leaking technical details
+
+---
+
+## SECTION 2: MEMORY MANAGEMENT AUDIT
+
+### 2.1 Static Memory Leaks
+Audit `/lib/models/player.dart`:
+- [ ] `_playerCreationTimes` static map (lines 96-144) - grows unbounded
+- [ ] Cleanup only removes 50 of 100+ entries
+
+### 2.2 Unbounded Caches
+Audit `/lib/services/cache_service.dart`:
+- [ ] `_albumTracksCache` - no size limit
+- [ ] `_artistAlbumsCache` - no TTL expiration
+- [ ] `_searchCache` - never evicted
+- [ ] `_playerTrackCache` - only cleared on disconnect
+
+### 2.3 Stream/Timer Cleanup
+Audit `/lib/providers/music_assistant_provider.dart`:
+- [ ] `_playerStateTimer` disposal (line 4435-4445)
+- [ ] `_notificationPositionTimer` multiple creation paths (lines 2925-2940)
+- [ ] `_localPlayerEventSubscription` cleanup
+- [ ] `_playerUpdatedEventSubscription` cleanup
+- [ ] `_playerAddedEventSubscription` cleanup
+
+Audit `/lib/services/hardware_volume_service.dart`:
+- [ ] `_volumeUpController` never closed (lines 74-85)
+- [ ] `_volumeDownController` never closed
+
+### 2.4 Stream Subscription Leaks
+Audit `/lib/providers/music_assistant_provider.dart`:
+- [ ] `_api!.connectionState.listen()` - subscription not stored
+- [ ] Old subscriptions not cancelled before new API instance
+
+---
+
+## SECTION 3: RACE CONDITION AUDIT
+
+### 3.1 Player State Dual Updates
+Audit `/lib/providers/music_assistant_provider.dart`:
+- [ ] Timer polling (every 5s) vs WebSocket events racing
+- [ ] `_updatePlayerState()` called from both paths
+- [ ] No mutex/lock protection
+
+### 3.2 Async Method Reentrancy
+Audit `selectPlayer()` method:
+- [ ] `async` method without guard against concurrent calls
+- [ ] `_selectedPlayer` modified before and after `await`
+- [ ] State could change during await
+
+### 3.3 Fire-and-Forget Operations
+Search for `unawaited(` and `() async {` patterns:
+- [ ] `_persistPlaybackState()` - database save not awaited
+- [ ] Pause operations fire-and-forget (lines 3876-3894)
+- [ ] Preload operations (line 2707)
+
+### 3.4 PCM Player State Machine
+Audit `/lib/services/pcm_audio_player.dart`:
+- [ ] 9-state machine with complex transitions (lines 32-37)
+- [ ] Auto-recovery race condition (lines 215-229)
+- [ ] Feed loop during pause transition (lines 174-179)
+
+---
+
+## SECTION 4: ERROR HANDLING AUDIT
+
+### 4.1 Silent Exception Handlers (CRITICAL)
+Find all instances of:
+```dart
+} catch (e) {}
+} catch (_) {}
+```
+
+Known locations:
+- [ ] `music_assistant_provider.dart` (multiple)
+- [ ] `player_provider.dart` (3 instances)
+- [ ] `recently_played_service.dart`
+
+### 4.2 Missing Error Recovery
+- [ ] No exponential backoff on connection retry
+- [ ] No retry logic for failed API calls
+- [ ] WebSocket timeout handling (30 seconds - too long?)
+
+### 4.3 Null Safety Violations
+Find all `!` (null assertion) operators:
+- [ ] `search_screen.dart` (20+ instances)
+- [ ] `models/media_item.dart`
+- [ ] `models/player.dart`
+- [ ] `item.mediaItem! as Artist` patterns
+
+---
+
+## SECTION 5: ARCHITECTURAL ISSUES
+
+### 5.1 God Class
+Audit `/lib/providers/music_assistant_provider.dart`:
+- [ ] 4,469 lines - violates Single Responsibility
+- [ ] 386 conditional branches
+- [ ] Mixing: connection, players, library, sync, audio, position tracking
+
+**Recommend splitting into:**
+- ConnectionProvider (~500 LOC)
+- PlayerManager (~800 LOC)
+- LibraryProvider (~1000 LOC)
+- LocalPlaybackManager (~600 LOC)
+
+### 5.2 Oversized Widget Files
+- [ ] `expandable_player.dart` - 2,485 lines (should be <500)
+- [ ] `global_player_overlay.dart` - 737 lines
+- [ ] `new_library_screen.dart` - 2,521 lines
+
+### 5.3 Global Key Anti-Pattern
+Audit `/lib/widgets/global_player_overlay.dart`:
+- [ ] `globalPlayerKey` for state access
+- [ ] `_overlayStateKey` for overlay state
+- [ ] Should use Provider/context instead
+
+### 5.4 Primitive Obsession
+- [ ] View modes as strings ('grid2', 'grid3', 'list')
+- [ ] Media types as strings ('track', 'album', 'artist')
+- [ ] Should be strongly-typed enums
+
+---
+
+## SECTION 6: CODE QUALITY ISSUES
+
+### 6.1 Testing (CRITICAL)
+- [ ] **ZERO test files exist** - confirm this
+- [ ] No unit tests, widget tests, or integration tests
+- [ ] flutter_test dependency exists but unused
+
+### 6.2 Hardcoded Values
+Find and document all:
+- [ ] Color hex codes (50+ instances of `Color(0xFF...`)
+- [ ] Duration values not using `Timings` constants
+- [ ] Magic numbers (16, 4, 5, 100, 50)
+- [ ] String literals for media types
+
+### 6.3 Mixed Async Patterns
+- [ ] `.then()` chains alongside async/await
+- [ ] `.whenComplete()` usage
+- [ ] Consolidate to async/await
+
+### 6.4 Dead Code
+- [ ] `@Deprecated` methods still implemented
+- [ ] `animation_debugger.dart` - dev-only?
+- [ ] Unused imports
+
+### 6.5 TODO Comments
+Document all actionable TODOs:
+- [ ] `queue_screen.dart:214` - queue item removal
+- [ ] `audiobook_detail_screen.dart:261,312` - progress sync
+- [ ] `music_assistant_provider.dart:793,799` - playlist modification
+
+---
+
+## SECTION 7: UI/UX AUDIT
+
+### 7.1 Accessibility (CRITICAL)
+Audit for missing:
+- [ ] `Semantics` widgets on interactive elements
+- [ ] `Tooltip` on icon buttons
+- [ ] Screen reader support
+- [ ] Touch target sizes (minimum 48dp)
+- [ ] Color contrast validation (WCAG AA)
+
+### 7.2 Performance Issues
+Audit `/lib/widgets/expandable_player.dart`:
+- [ ] No `RepaintBoundary` wrappers
+- [ ] 55+ `setState()` calls
+- [ ] 3 AnimationControllers with multiple listeners
+- [ ] Title height cache invalidation (lines 118+)
+
+### 7.3 Double Opacity Bug
+Audit `/lib/widgets/player/player_controls.dart`:
+```dart
+color: (shuffle == true ? primaryColor : textColor.withOpacity(0.5))
+    .withOpacity(expandedElementsOpacity),
+```
+- [ ] Double `.withOpacity()` application
+
+### 7.4 Missing Features
+- [ ] No landscape orientation support
+- [ ] No tablet layout optimization
+- [ ] No loading skeleton animations
+- [ ] No haptic feedback (except one location)
+
+---
+
+## SECTION 8: AUDIO PLAYBACK AUDIT
+
+### 8.1 Position Interpolation
+Audit `/lib/services/position_tracker.dart`:
+- [ ] No timeout on anchor updates - unbounded drift possible
+- [ ] Duration interpolation can exceed track duration
+- [ ] Stale timestamp handling (>30 seconds)
+
+### 8.2 Sendspin Protocol
+Audit `/lib/services/sendspin_service.dart`:
+- [ ] Proxy auth retry without deduplication (lines 188-209)
+- [ ] WebSocket binary frame parsing
+- [ ] Clock synchronization accuracy
+
+### 8.3 Audio Resource Cleanup
+Audit `/lib/services/audio/massiv_audio_handler.dart`:
+- [ ] Audio session interrupt listeners not disposed
+- [ ] Audio focus not explicitly released
+
+### 8.4 Mixed Playback Modes
+- [ ] just_audio initialized but unused during Sendspin
+- [ ] Resource allocation for unused player
+- [ ] Potential audio focus conflicts
+
+---
+
+## SECTION 9: NETWORKING AUDIT
+
+### 9.1 WebSocket Lifecycle
+Audit `/lib/services/music_assistant_api.dart`:
+- [ ] Heartbeat interval (30s) - appropriate?
+- [ ] Reconnection logic and timing
+- [ ] Pending request cleanup on disconnect
+
+### 9.2 Caching Strategy
+- [ ] No incremental/delta sync (full library every 5 minutes)
+- [ ] Cache staleness not communicated to UI
+- [ ] No query result pagination (fetches up to 5000 items)
+
+### 9.3 Rate Limiting
+- [ ] No client-side rate limiting
+- [ ] Search requests not throttled
+- [ ] Could overload server
+
+### 9.4 Offline Support
+Audit `/lib/services/offline_action_queue.dart`:
+- [ ] Queue execution not atomic (lines 118-130)
+- [ ] Action could execute twice on crash
+- [ ] Queue stored unencrypted
+
+---
+
+## SECTION 10: DATABASE AUDIT
+
+### 10.1 Schema Review
+Audit `/lib/database/database.dart`:
+- [ ] Table indexes for query performance
+- [ ] Foreign key constraints
+- [ ] Migration strategy
+
+### 10.2 Query Patterns
+- [ ] N+1 query prevention
+- [ ] Transaction usage for atomic operations
+- [ ] Connection pooling
+
+### 10.3 Data Consistency
+- [ ] Tier 1 (DB) vs Tier 2 (API sync) race conditions
+- [ ] User modifications during background sync
+- [ ] Conflict resolution strategy
+
+---
+
+## Deliverables
+
+After completing the audit, provide:
+
+### 1. Executive Summary
+- Overall code quality score (1-10)
+- Top 5 critical issues requiring immediate attention
+- Estimated technical debt in developer-hours
+
+### 2. Issue Tracker
+Create a prioritized list of all issues found:
+| ID | Severity | Category | File:Line | Description | Effort |
+|----|----------|----------|-----------|-------------|--------|
+
+### 3. Recommended Roadmap
+Sprint-based plan to address findings:
+- Sprint 1 (Immediate): Security fixes, silent exception handlers
+- Sprint 2-3: God class decomposition, test infrastructure
+- Sprint 4-6: Memory leak fixes, accessibility
+- Long-term: Performance optimization, monitoring
+
+### 4. Code Examples
+For each CRITICAL and HIGH severity issue, provide:
+- Current problematic code
+- Recommended refactored code
+- Migration steps
+
+---
+
+## Files to Prioritize
+
+Start your audit with these critical files:
+
+1. `/lib/providers/music_assistant_provider.dart` (4,469 LOC) - God class
+2. `/lib/services/settings_service.dart` - Credential storage
+3. `/lib/services/music_assistant_api.dart` (2,929 LOC) - Networking
+4. `/lib/widgets/expandable_player.dart` (2,485 LOC) - UI complexity
+5. `/lib/services/auth/` directory - Security
+6. `/lib/models/player.dart` - Memory leaks
+7. `/lib/services/cache_service.dart` - Unbounded caches
+8. `/lib/services/position_tracker.dart` - Audio sync issues
+
+---
+
+## Known Critical Issues (Pre-Identified)
+
+These issues have been identified and MUST be verified and documented:
+
+1. **CRITICAL: Plaintext credential storage** - SharedPreferences without encryption
+2. **CRITICAL: Zero test coverage** - No unit, widget, or integration tests
+3. **CRITICAL: 4,469 line god class** - MusicAssistantProvider violates SRP
+4. **CRITICAL: Silent exception handlers** - `catch (e) {}` patterns
+5. **HIGH: Static memory leak** - `_playerCreationTimes` unbounded growth
+6. **HIGH: Race conditions** - Player state polling vs events
+7. **HIGH: No accessibility** - Missing Semantics, screen reader support
+8. **HIGH: Certificate validation disabled** - MITM vulnerability for local IPs
+9. **MEDIUM: Double opacity bug** - `.withOpacity().withOpacity()` in player controls
+10. **MEDIUM: Position tracker drift** - No timeout on anchor updates
+
+---
+
+## Audit Execution Notes
+
+- Use `Grep` tool to search for patterns across the codebase
+- Use `Read` tool to examine specific file sections
+- Document line numbers for all findings
+- Provide code snippets for context
+- Cross-reference related issues across files
+- Verify pre-identified issues exist and document their exact locations
+
+**Total estimated audit time: 4-6 hours for thorough coverage**

AUDIT-REPORT.md

@@ -0,0 +1,419 @@
+# Ensemble Codebase - Comprehensive Audit Report
+
+**Audit Date:** 2026-01-01
+**Codebase:** Ensemble Flutter App (Music Assistant Client)
+**Version:** 2.7.3-beta+35
+**Total Lines of Code:** ~40,583 Dart
+**Files Analyzed:** 90 Dart files
+
+---
+
+## Executive Summary
+
+### Overall Code Quality Score: 5.5/10
+
+The Ensemble codebase demonstrates **strong architectural foundations** with a well-organized service layer, effective caching strategies, and sophisticated audio handling. However, the audit revealed **critical security vulnerabilities**, **zero test coverage**, and significant **technical debt** that must be addressed before production release.
+
+### Critical Statistics
+
+| Metric | Value | Status |
+|--------|-------|--------|
+| Test Coverage | 0% | CRITICAL |
+| God Class Size | 4,469 LOC | CRITICAL |
+| Silent Exception Handlers | 7 | CRITICAL |
+| Plaintext Credentials | 4 locations | CRITICAL |
+| Memory Leak Locations | 6 | HIGH |
+| Race Conditions | 4 | HIGH |
+| Accessibility (Semantics) | 0 widgets | CRITICAL |
+
+---
+
+## Issue Summary by Severity
+
+| Severity | Count | Categories |
+|----------|-------|------------|
+| **CRITICAL** | 12 | Security, Testing, Architecture, Accessibility |
+| **HIGH** | 18 | Memory, Race Conditions, Networking, Audio |
+| **MEDIUM** | 22 | Error Handling, UI, Caching, Code Quality |
+| **LOW** | 14 | Naming, Documentation, Minor Improvements |
+
+---
+
+## CRITICAL ISSUES (Immediate Action Required)
+
+### 1. Plaintext Credential Storage
+**File:** `/lib/services/settings_service.dart`
+**Lines:** 131-143, 147-159, 169-190, 209-222
+
+Passwords and auth tokens stored in SharedPreferences without encryption.
+
+```dart
+// VULNERABLE CODE
+static Future<void> setPassword(String? password) async {
+  final prefs = await SharedPreferences.getInstance();
+  await prefs.setString(_keyPassword, password);  // PLAINTEXT!
+}
+```
+
+**Fix:** Use `flutter_secure_storage` for all sensitive data.
+
+---
+
+### 2. Zero Test Coverage
+**Location:** Entire codebase
+
+No unit tests, widget tests, or integration tests exist. The `flutter_test` dependency is unused.
+
+**Impact:** Cannot safely refactor, high regression risk, no confidence in correctness.
+
+**Fix:** Establish test infrastructure immediately. Start with:
+- Unit tests for `MusicAssistantAPI`, `CacheService`, `ErrorHandler`
+- Widget tests for player controls
+- Integration tests for playback flows
+
+---
+
+### 3. God Class - MusicAssistantProvider
+**File:** `/lib/providers/music_assistant_provider.dart`
+**Size:** 4,469 lines, ~140 methods, 744 conditional branches
+
+Single class handles: connection, players, library, cache, audio, sync, offline queue.
+
+**Fix:** Split into:
+- `ConnectionManager` (~500 LOC)
+- `PlayerManager` (~800 LOC)
+- `LibraryCacheService` (~600 LOC)
+- `SendspinManager` (~400 LOC)
+- `MusicAssistantProvider` - Facade composing above (~800 LOC)
+
+---
+
+### 4. Zero Accessibility Support
+**Files:** `/lib/widgets/`, `/lib/screens/` (all)
+
+- **0** `Semantics` widgets
+- **0** `semanticLabel` properties
+- **1** `Tooltip` (entire app)
+- Screen readers cannot navigate the app
+
+**Fix:** Add Semantics to all interactive elements:
+```dart
+Semantics(
+  button: true,
+  label: isPlaying ? 'Pause playback' : 'Play',
+  child: IconButton(...)
+)
+```
+
+---
+
+### 5. Silent Exception Handlers
+**Locations:** 7 instances across codebase
+
+| File | Line | Code |
+|------|------|------|
+| player_provider.dart | 567, 575, 584 | `catch (e) {}` |
+| music_assistant_provider.dart | 2690 | `catch (e) {}` |
+| music_assistant_api.dart | 2542 | `catch (e) {}` |
+| recently_played_service.dart | 154, 206 | `catch (_) {}` |
+
+**Fix:** Add logging or use `firstWhereOrNull` instead of try/catch around `firstWhere`.
+
+---
+
+### 6. Audio Session Listeners Not Disposed
+**File:** `/lib/services/audio/massiv_audio_handler.dart`
+**Lines:** 45-73
+
+Stream subscriptions created but never cancelled - causes memory leaks and zombie listeners.
+
+**Fix:** Store subscriptions and cancel in dispose():
+```dart
+StreamSubscription? _interruptionSubscription;
+_interruptionSubscription = session.interruptionEventStream.listen(...);
+
+void dispose() {
+  _interruptionSubscription?.cancel();
+}
+```
+
+---
+
+## HIGH SEVERITY ISSUES
+
+### 7. Connection State Subscription Not Stored
+**File:** `/lib/providers/music_assistant_provider.dart:575-614`
+
+The `connectionState.listen()` return value is not stored - causes listener accumulation on reconnect.
+
+---
+
+### 8. Player State Race Condition
+**File:** `/lib/providers/music_assistant_provider.dart`
+
+Timer polling (every 5s) and WebSocket events can race to update `_selectedPlayer` and `_currentTrack` without mutex protection.
+
+---
+
+### 9. Async Method Reentrancy
+**File:** `/lib/providers/music_assistant_provider.dart:2713-2841`
+
+`selectPlayer()` is `void async` with no guard against concurrent calls. Multiple rapid player switches can interleave.
+
+---
+
+### 10. Unbounded Search Cache
+**File:** `/lib/services/cache_service.dart:31-32`
+
+`_searchCache` map has no size limit or proactive TTL eviction. Grows indefinitely with user searches.
+
+---
+
+### 11. Static Memory Leak
+**File:** `/lib/models/player.dart:96, 139-144`
+
+`_playerCreationTimes` static map cleanup only removes 50 of 100+ entries, allowing unbounded growth.
+
+---
+
+### 12. No Database Indexes
+**File:** `/lib/database/database.dart`
+
+No secondary indexes defined. Query performance degrades as database grows.
+
+---
+
+### 13. No Incremental Sync
+**File:** `/lib/services/sync_service.dart:150-165`
+
+Full library fetch (up to 4000 items) on every sync instead of delta updates.
+
+---
+
+### 14. Offline Queue Not Atomic
+**File:** `/lib/services/offline_action_queue.dart:80-108`
+
+Queue persistence happens after all processing - crash during processing loses successful actions.
+
+---
+
+### 15. Auth Retry Without Deduplication
+**File:** `/lib/services/sendspin_service.dart:189-209`
+
+Multiple auth messages can be sent during rapid reconnection attempts.
+
+---
+
+### 16. Pending Requests Not Completed on Disconnect
+**File:** `/lib/services/music_assistant_api.dart:2911`
+
+`_pendingRequests.clear()` abandons Completers without completing them with errors.
+
+---
+
+### 17. HTTP Fallback for Local IPs
+**File:** `/lib/services/auth/auth_manager.dart:51-58`
+
+HTTPS failures silently fall back to HTTP on local networks - MITM vulnerability.
+
+---
+
+### 18. Certificate Validation Bypassed
+**File:** `/lib/services/auth/auth_manager.dart:210-236`
+
+HTTPS redirects explicitly refused for local IPs due to expected certificate failures.
+
+---
+
+## MEDIUM SEVERITY ISSUES
+
+### 19. Double Opacity Bug
+**File:** `/lib/widgets/player/player_controls.dart:62-63, 99-100`
+
+```dart
+// BUG: .withOpacity(0.5).withOpacity(expandedElementsOpacity) compounds opacity
+color: (shuffle == true ? primaryColor : textColor.withOpacity(0.5))
+    .withOpacity(expandedElementsOpacity),
+```
+
+---
+
+### 20. Mixed Async Patterns
+**Locations:** 13 instances
+
+`.then()` chains mixed with `async/await` throughout the codebase.
+
+---
+
+### 21. Hardcoded Colors
+**Locations:** 55 instances
+
+`Color(0xFF604CEC)`, `Color(0xFF1a1a1a)` scattered across theme files and widgets.
+
+---
+
+### 22. View Modes as Strings
+**Locations:** 80+ instances
+
+`'grid2'`, `'grid3'`, `'list'` should be enums.
+
+---
+
+### 23. Fire-and-Forget Pause Commands
+**File:** `/lib/providers/music_assistant_provider.dart:3875-3894`
+
+Server pause command uses `unawaited()` - errors are silently lost.
+
+---
+
+### 24. Position Tracker Anchor Timeout Missing
+**File:** `/lib/services/position_tracker.dart:24-26`
+
+No timeout on stale anchor - interpolation can drift indefinitely.
+
+---
+
+### 25. PCM Buffer No Overflow Protection
+**File:** `/lib/services/pcm_audio_player.dart:68, 236-247`
+
+Audio buffer grows unbounded if data arrives faster than consumption.
+
+---
+
+### 26. No Client-Side Rate Limiting
+**Location:** App-wide
+
+No throttling on API requests during rapid user interactions.
+
+---
+
+### 27. Portrait-Only Lock
+**File:** `/lib/main.dart:64-68`
+
+No landscape orientation support.
+
+---
+
+### 28. Touch Targets Below 48dp
+**Files:** player_controls.dart, queue_panel.dart, player_card.dart
+
+Multiple buttons at 28x28 and 44x44 instead of minimum 48x48.
+
+---
+
+### 29. WCAG Contrast Not Validated
+**File:** `/lib/theme/palette_helper.dart`
+
+Uses 0.4 threshold instead of proper WCAG 4.5:1 contrast ratio calculation.
+
+---
+
+### 30. StreamControllers Not Closed
+**File:** `/lib/services/hardware_volume_service.dart:18-19, 74-85`
+
+`_volumeUpController` and `_volumeDownController` never closed in dispose().
+
+---
+
+## LOW SEVERITY ISSUES
+
+### 31-34. Naming Inconsistencies
+Mixed patterns: `_isLoading` vs `_isLoadingPlaylists`, various cache variable names.
+
+### 35-38. Missing TODO Implementations
+6 actionable TODOs identified (queue removal, audiobook progress sync, playlist modification).
+
+### 39-42. Dead/Unused Code
+- `@Deprecated` methods still implemented
+- `library_stats.dart` appears unused
+- `animation_debugger.dart` disabled by default
+
+### 43-44. Minor Documentation Gaps
+Missing method documentation, no architecture diagram.
+
+---
+
+## Recommended Remediation Roadmap
+
+### Sprint 1 (Week 1-2): Security & Critical Fixes
+1. Migrate credentials to `flutter_secure_storage`
+2. Add logging to all silent catch blocks
+3. Store connection state subscription
+4. Fix audio session listener disposal
+5. Add basic test infrastructure (10% coverage target)
+
+### Sprint 2 (Week 3-4): Memory & Race Conditions
+6. Add mutex to player state updates
+7. Add reentrancy guard to `selectPlayer()`
+8. Implement bounded caches with LRU eviction
+9. Fix static memory leak in Player model
+10. Store and cancel all stream subscriptions
+
+### Sprint 3 (Week 5-6): Architecture Refactoring
+11. Split `MusicAssistantProvider` into 5 smaller classes
+12. Split `expandable_player.dart` into component widgets
+13. Replace GlobalKey anti-patterns with Provider
+14. Convert string constants to enums
+15. Extract hardcoded colors to constants file
+
+### Sprint 4 (Week 7-8): Accessibility & UI
+16. Add Semantics to all interactive elements
+17. Increase touch targets to 48dp minimum
+18. Implement WCAG contrast validation
+19. Fix double opacity bug
+20. Add landscape orientation support
+
+### Sprint 5 (Week 9-10): Performance & Polish
+21. Add database indexes
+22. Implement incremental sync
+23. Add client-side rate limiting
+24. Fix atomic offline queue processing
+25. Achieve 30% test coverage target
+
+---
+
+## Files Requiring Most Attention
+
+| File | LOC | Issues | Priority |
+|------|-----|--------|----------|
+| `music_assistant_provider.dart` | 4,469 | 12 | CRITICAL |
+| `settings_service.dart` | 811 | 4 | CRITICAL |
+| `expandable_player.dart` | 2,485 | 6 | HIGH |
+| `music_assistant_api.dart` | 2,929 | 5 | HIGH |
+| `cache_service.dart` | 370 | 4 | HIGH |
+| `massiv_audio_handler.dart` | 296 | 2 | CRITICAL |
+| `player.dart` | 422 | 2 | HIGH |
+| `auth_manager.dart` | 300 | 3 | HIGH |
+
+---
+
+## Estimated Technical Debt
+
+| Category | Effort (Dev-Days) |
+|----------|-------------------|
+| Security Fixes | 3-5 |
+| Test Infrastructure | 10-15 |
+| Architecture Refactoring | 15-20 |
+| Memory Leak Fixes | 3-5 |
+| Accessibility | 5-8 |
+| UI/UX Polish | 3-5 |
+| Performance | 5-8 |
+| **Total** | **44-66 dev-days** |
+
+---
+
+## Conclusion
+
+The Ensemble app has a solid foundation with well-designed patterns for caching, audio handling, and multi-device synchronization. However, **critical security vulnerabilities** (plaintext credentials), **zero test coverage**, and a **4,469-line god class** represent significant risks that must be addressed before any production deployment.
+
+The most urgent priorities are:
+1. **Secure credential storage** - immediate security risk
+2. **Add test infrastructure** - enables safe refactoring
+3. **Split the god class** - enables maintainability
+4. **Add accessibility** - legal/compliance requirement
+
+With focused effort over 8-10 weeks, the codebase can be brought to production-quality standards.
+
+---
+
+*Audit conducted using 6 parallel specialized sub-agents analyzing security, memory management, race conditions, architecture, UI/UX, and audio/networking.*

AUDIT_PROMPT.md

@@ -0,0 +1,119 @@
+# Ensemble Codebase Audit Prompt
+
+Run this prompt with Claude Code to perform a comprehensive audit of the Ensemble Flutter app.
+
+---
+
+## Prompt
+
+You are performing a comprehensive code audit on the Ensemble Flutter app. This is a music/audiobook/podcast player app with 93+ Dart files.
+
+**CRITICAL RULES:**
+1. DO NOT remove or break any existing functionality
+2. All changes must be on the current branch: `audit/code-quality-review`
+3. Run `flutter analyze` after each set of changes to verify no regressions
+4. Commit changes in logical, reviewable chunks
+
+**AUDIT PHASES:**
+
+### Phase 1: Code Quality Analysis (Read-Only)
+First, analyze the codebase without making changes. Create a report covering:
+
+1. **Large File Analysis** - Review these files for refactoring opportunities:
+   - `lib/screens/new_library_screen.dart` (122KB)
+   - `lib/screens/search_screen.dart` (129KB)
+   - `lib/widgets/expandable_player.dart` (107KB)
+   - `lib/screens/album_details_screen.dart` (48KB)
+   - `lib/screens/artist_details_screen.dart` (45KB)
+
+2. **Pattern Inconsistencies** - Look for:
+   - Inconsistent naming conventions (camelCase vs snake_case)
+   - Mixed widget composition patterns
+   - Inconsistent error handling approaches
+   - Duplicate code across screens/widgets
+
+3. **Performance Red Flags** - Identify:
+   - Unnecessary rebuilds (missing const constructors)
+   - Heavy computations in build methods
+   - Missing list item caching (ListView.builder vs ListView)
+   - Inefficient state management patterns
+
+4. **Scroll Performance Issues** - Specifically audit:
+   - ScrollController usage and disposal
+   - Sliver implementations
+   - AnimatedBuilder/AnimatedWidget usage
+   - Image loading in scrollable lists
+   - Any jank-inducing patterns
+
+### Phase 2: Quick Wins (Low Risk, High Impact)
+Apply these fixes first:
+
+1. Add missing `const` constructors throughout
+2. Fix any `flutter analyze` warnings
+3. Remove dead code and unused imports
+4. Standardize formatting with `dart format`
+
+### Phase 3: Scroll Animation Optimization
+Focus on smoother scrolling:
+
+1. **Image Optimization**
+   - Ensure CachedNetworkImage is used consistently
+   - Add appropriate cacheWidth/cacheHeight
+   - Implement proper placeholder/error widgets
+
+2. **List Performance**
+   - Convert any ListView to ListView.builder where appropriate
+   - Add itemExtent where possible for fixed-height items
+   - Implement AutomaticKeepAliveClientMixin where needed
+   - Consider RepaintBoundary for complex list items
+
+3. **Animation Smoothing**
+   - Use `Curves.easeOutCubic` or similar for scroll-linked animations
+   - Ensure animations run at 60fps (avoid heavy computations during animation)
+   - Review CustomScrollView/Sliver implementations
+
+### Phase 4: Code Consistency Improvements
+
+1. **Widget Extraction**
+   - Extract repeated UI patterns into reusable widgets
+   - Ensure extracted widgets follow existing naming patterns
+
+2. **State Management**
+   - Verify Provider usage is consistent
+   - Check for proper disposal of controllers/streams
+
+3. **Error Handling**
+   - Standardize try/catch patterns
+   - Ensure consistent loading/error state UI
+
+### Phase 5: Verification
+
+After all changes:
+1. Run `flutter analyze` - must pass with 0 issues
+2. Run `flutter test` if tests exist
+3. Create a summary of all changes made
+4. List any recommendations that were NOT implemented (too risky)
+
+---
+
+## Execution Instructions
+
+```bash
+# Start the audit
+cd /home/home-server/Ensemble
+git checkout audit/code-quality-review
+
+# After each phase, commit your changes
+git add -A && git commit -m "Audit Phase X: [description]"
+
+# Verify no regressions
+flutter analyze
+```
+
+---
+
+## Expected Deliverables
+
+1. `AUDIT_REPORT.md` - Findings from Phase 1
+2. Multiple commits with clear messages for each phase
+3. `AUDIT_SUMMARY.md` - Final summary of all changes and remaining recommendations

AUDIT_REPORT.md

@@ -0,0 +1,136 @@
+# Ensemble Flutter App - Code Audit Report
+
+**Date:** January 4, 2026
+**Branch:** `audit/code-quality-review`
+**Files Audited:** 93 Dart files
+
+---
+
+## Executive Summary
+
+The codebase is generally well-maintained with good existing performance optimizations (RepaintBoundary, ListView.builder, cacheExtent settings). Key improvement areas identified:
+
+| 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 |
+
+---
+
+## 1. CRITICAL: Deprecated API Usage
+
+### `colorScheme.background` (20 instances)
+Flutter Material 3 deprecates `ColorScheme.background`. Replace with `colorScheme.surface`.
+
+**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. HIGH: Missing const Constructors
+
+### EdgeInsets.zero (64 instances)
+High-impact optimization - used extensively in button padding.
+
+**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)
+
+### BorderRadius.circular (40+ instances)
+Cannot use `const BorderRadius.circular()` directly. Alternative: `const BorderRadius.all(Radius.circular(X))`.
+
+---
+
+## 3. MEDIUM: Scroll Performance - Missing Image Cache Parameters
+
+### CachedNetworkImage without memCacheWidth/Height
+
+**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
+
+**Note:** DecorationImage with CachedNetworkImageProvider cannot have cache size specified (structural Flutter limitation).
+
+---
+
+## 4. LOW: Code Duplication
+
+### 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
+
+---
+
+## 5. POSITIVE FINDINGS (Already Optimized)
+
+- **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
+
+---
+
+## Recommended Action Plan
+
+### Phase 1: Quick Wins (Low Risk)
+1. Replace `colorScheme.background` with `colorScheme.surface` (20 locations)
+2. Add `const` to EdgeInsets.zero instances
+
+### 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
+
+---
+
+## Files by Complexity
+
+| 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 |

AUDIT_SUMMARY.md

@@ -0,0 +1,57 @@
+# Audit Summary
+
+**Branch:** `audit/code-quality-review`
+**Date:** January 4, 2026
+
+## Changes Applied
+
+### Phase 1: Analysis Complete
+- Created `AUDIT_REPORT.md` with comprehensive findings
+- 4 parallel subagents analyzed const constructors, scroll performance, code duplication, and dead code
+
+### Phase 2: Deprecated API Fixes (18 files)
+- Replaced all `colorScheme.background` with `colorScheme.surface` (Material 3 compliance)
+
+**Files modified:**
+- lib/screens/library_artists_screen.dart
+- lib/screens/library_albums_screen.dart
+- lib/screens/library_playlists_screen.dart
+- lib/screens/library_tracks_screen.dart
+- lib/screens/artist_details_screen.dart
+- lib/screens/new_home_screen.dart
+- lib/screens/login_screen.dart
+- lib/screens/settings_screen.dart
+- lib/screens/album_details_screen.dart
+- lib/screens/search_screen.dart
+- lib/screens/new_library_screen.dart
+
+### Phase 3: Scroll Performance Optimization
+- Added `memCacheWidth` and `memCacheHeight` to CachedNetworkImage instances
+
+**lib/screens/new_library_screen.dart:**
+- Line 1400-1401: Author list tile image (128x128 cache)
+- Line 1487-1488: Author grid card image (256x256 cache)
+- Line 1577-1578: Audiobook list tile cover (256x256 cache)
+- Line 1749-1750: Audiobook grid cover (512x512 cache)
+- Line 1970-1971: Series list tile cover (256x256 cache)
+- Line 2986-2987: Album list tile cover (256x256 cache)
+
+## Recommendations NOT Implemented (Low Priority)
+
+These were identified but NOT changed to preserve functionality:
+
+1. **View mode cycling refactor** - 8 similar functions could be consolidated
+2. **Color constant extraction** - Duplicated colors in 3 files
+3. **EdgeInsets.zero const** - 64 instances (build-time only, minimal impact)
+4. **BorderRadius.circular const** - 40+ instances
+
+## Verification
+
+Changes should be verified by:
+1. GitHub Actions build (triggered automatically)
+2. Manual UI testing of scroll smoothness
+3. Verify no visual regressions in dark/light themes
+
+## Build Trigger
+
+GitHub Actions workflow triggered on branch `audit/code-quality-review`

README.md

@@ -20,34 +20,63 @@ This application was built with AI-assisted development using **Claude Code** an
 ## Features
 
 ### Local Playback
-- **Stream to Your Phone** - Play music from your Music Assistant library directly on your mobile device
+- **Stream to Your Phone** - Play music from your Music Assistant library directly on your mobile device via Sendspin protocol
 - **Background Playback** - Music continues playing when the app is minimized
 - **Media Notifications** - Control playback from your notification shade with album art display
+- **Instant Response** - Pause/resume in ~300ms
 
 ### Remote Control
 - **Multi-Player Support** - Control any speaker or device connected to Music Assistant
-- **Device Selector** - Quickly switch between your phone and other players
+- **Device Selector** - Swipe down on mini player to reveal all your devices
+- **Multi-Room Grouping** - Long-press any player to sync it with the current player
 - **Full Playback Controls** - Play, pause, skip, seek, and adjust volume
-- **Queue Management** - View and manage the playback queue
+- **Volume Precision Mode** - Hold the volume slider for fine-grained control with haptic feedback
+- **Power Control** - Turn players on/off directly from the mini player
+
+### Queue Management
+- **View & Manage Queue** - See upcoming tracks in the playback queue
+- **Drag to Reorder** - Instant drag handles for reordering tracks
+- **Swipe to Delete** - Remove tracks with a simple swipe gesture
 
 ### Home Screen
-- **Customizable Rows** - Toggle Recently Played, Discover Artists, and Discover Albums
-- **Favorites Rows** - Optional rows for Favorite Albums, Artists, and Tracks
+- **Customizable Rows** - Toggle and reorder: Recently Played, Discover Artists, Discover Albums
+- **Favorites Rows** - Optional rows for Favorite Albums, Artists, Tracks, Playlists, and Radio Stations
 - **Adaptive Layout** - Rows scale properly for different screen sizes and aspect ratios
 - **Pull to Refresh** - Refresh content with a simple pull gesture
 
-### Library Browsing
-- **Browse Your Collection** - Artists, albums, playlists, and tracks from all your music sources
+### Library
+- **Music** - Browse artists, albums, playlists, and tracks from all your music sources
+- **Radio Stations** - Browse and play radio stations with list or grid view
+- **Podcasts** - Browse podcasts, view episodes with descriptions and publish dates
+- **Audiobooks** - Browse by title, series, or author with progress tracking
 - **Favorites Filter** - Toggle to show only your favorite items
-- **Album Details** - View track listings with artwork
-- **Artist Details** - View artist albums and top tracks
-- **Playlist Support** - Browse and play your playlists
-- **Search** - Find music across your entire library
+- **Letter Scrollbar** - Fast navigation through long lists
+
+### Search
+- **Universal Search** - Find music, podcasts, radio stations, playlists, and audiobooks
+- **Fuzzy Matching** - Typo-tolerant search (e.g., "beetles" finds "Beatles")
+- **Smart Scoring** - Results ranked by relevance with colored type indicators
+- **Search History** - Quickly access your recent searches
+- **Quick Actions** - Long-press any result to add to queue or play next
+
+### Audiobooks
+- **Chapter Navigation** - Jump between chapters with timestamp display
+- **Progress Tracking** - Track your listening progress across sessions
+- **Continue Listening** - Pick up where you left off
+- **Mark as Finished/Unplayed** - Manage your reading progress
+- **Series Support** - View audiobooks organized by series with collage cover art
+
+### Podcasts
+- **Episode Browser** - View full episode list with artwork and descriptions
+- **Skip Controls** - Skip forward/backward during playback
+- **High-Resolution Artwork** - Fetched via iTunes for best quality
 
 ### Smart Features
+- **Instant App Restore** - App loads instantly with cached library data while syncing in background
 - **Auto-Reconnect** - Automatically reconnects when connection is lost
-- **Caching** - Fast navigation with cached content
+- **Offline Browsing** - Browse your cached library even when disconnected
 - **Hero Animations** - Smooth transitions between screens
+- **Welcome Screen** - Guided onboarding for first-time users
 
 ### Theming
 - **Material You** - Dynamic theming based on your device's wallpaper
@@ -57,15 +86,16 @@ This application was built with AI-assisted development using **Claude Code** an
 ## Screenshots
 
 <div align="center">
-  <img src="assets/screenshots/1.png" alt="Connection Screen" width="250">
-  <img src="assets/screenshots/2.png" alt="Home Screen" width="250">
-  <img src="assets/screenshots/3.png" alt="Album Details" width="250">
-</div>
-
-<div align="center">
-  <img src="assets/screenshots/4.png" alt="Now Playing" width="250">
-  <img src="assets/screenshots/5.png" alt="Device Selection" width="250">
-  <img src="assets/screenshots/6.png" alt="Settings" width="250">
+  <img src="assets/screenshots/1.png?v=3" alt="Screenshot 1" width="150">
+  <img src="assets/screenshots/2.png?v=3" alt="Screenshot 2" width="150">
+  <img src="assets/screenshots/3.png?v=3" alt="Screenshot 3" width="150">
+  <img src="assets/screenshots/4.png?v=3" alt="Screenshot 4" width="150">
+  <img src="assets/screenshots/5.png?v=3" alt="Screenshot 5" width="150">
+  <img src="assets/screenshots/6.png?v=3" alt="Screenshot 6" width="150">
+  <img src="assets/screenshots/7.png?v=3" alt="Screenshot 7" width="150">
+  <img src="assets/screenshots/8.png?v=3" alt="Screenshot 8" width="150">
+  <img src="assets/screenshots/9.png?v=3" alt="Screenshot 9" width="150">
+  <img src="assets/screenshots/10.png?v=3" alt="Screenshot 10" width="150">
 </div>
 
 ## Download
@@ -75,9 +105,29 @@ Download the latest release from the [Releases page](https://github.com/CollotsS
 ## Setup
 
 1. Launch the app
-2. Enter your Music Assistant server URL (e.g., `music.example.com` or `192.168.1.100`)
+2. Enter your Music Assistant server URL
 3. Connect to your server
-4. Start playing! Music plays on your phone by default, or tap the device icon to choose a different player.
+4. Start playing! Music plays on your phone by default, or swipe down on the mini player to choose a different player.
+
+### Finding Your Server URL
+
+**Important:** You need the **Music Assistant** URL, not your Home Assistant URL.
+
+To find the correct URL:
+1. Open Music Assistant web UI
+2. Go to **Settings** > **About**
+3. Look for **Base URL** (e.g., `http://192.168.1.100:8095`)
+
+### Home Assistant Add-on Users
+
+If you run Music Assistant as a Home Assistant add-on:
+- Use the IP address of your Home Assistant server
+- Enter `8095` in the port field
+- Do **not** use your Home Assistant URL or ingress URL
+
+### Remote Access
+
+For access outside your home network, you'll need to expose Music Assistant through a reverse proxy (e.g., Nginx Proxy Manager, Cloudflare Tunnel).
 
 ## Authentication
 
@@ -94,11 +144,10 @@ Ensemble supports multiple authentication methods:
 
 ## Requirements
 
-- Music Assistant server (v2.7.0 or later recommended)
+- Music Assistant server (v2.7.0 beta 20 or later recommended)
 - Network connectivity to your Music Assistant server
 - Android device (Android 5.0+)
-
-> **Note:** Local device playback (streaming to your phone) is not currently supported on Music Assistant beta 20+. This is due to MA replacing the built-in player with Sendspin. Support will be added once Sendspin is more stable. Remote control of other players works fine.
+- Audiobookshelf provider configured in Music Assistant (for audiobook features)
 
 ## License
 

SEARCH-IMPROVEMENTS.md

@@ -0,0 +1,52 @@
+# Search Improvements
+
+Branch: `feature/search-improvements`
+
+## Completed
+
+- [x] Add playlists and audiobooks to search results
+  - Parse from MA API response
+  - Filter chips for each type
+  - Tile builders with navigation to detail screens
+
+- [x] Unified Relevance-Based "All" Results
+  - Scoring algorithm implemented:
+    - Exact match: 100 points
+    - Starts with query: 80 points
+    - Contains query (word boundary): 60 points
+    - Contains query (anywhere): 40 points
+    - Fuzzy match: 20 points
+    - Bonus for library items (albums): +10 points
+    - Bonus for favorites: +5 points
+    - Secondary field matching (artist name in albums/tracks)
+  - Merged all results into single sorted list
+  - Type indicators in subtitle (e.g., "Artist • Album")
+
+- [x] Smart Cross-Referencing
+  - Extracts unique artists from matched tracks/albums
+  - Filters to artists whose name contains query words (min 3 chars)
+  - Adds cross-referenced artists with lower relevance score (25)
+  - Avoids duplicates with direct search results
+
+- [x] Past Searches Row
+  - Added SearchHistory table to database (schema v4)
+  - Saves successful searches (deduplicated, max 10)
+  - Displays as ActionChips in empty state
+  - Clicking chip performs that search
+
+## Remaining Ideas (Lower Priority)
+
+- **Library-only toggle:** Add switch to filter search to library items only (MA API supports this)
+- **Voice search:** Add microphone button if platform supports speech recognition
+- **Search suggestions:** Typeahead from library as user types
+- **Quick actions:** Long-press result for play/queue options without navigating
+- **Clear history in settings:** Add option to clear search history
+
+## Files Modified
+
+| File | Changes |
+|------|---------|
+| `lib/database/database.dart` | Added SearchHistory table, schema v4 |
+| `lib/services/database_service.dart` | Added search history methods |
+| `lib/screens/search_screen.dart` | Relevance scoring, cross-refs, history UI |
+| `lib/l10n/app_en.arb` | Added localization strings |

android/build.gradle

@@ -2,6 +2,9 @@ buildscript {
     ext.kotlin_version = '1.9.10'
     repositories {
         google()
+        // Use Maven Central mirrors as fallback for 403 errors
+        maven { url 'https://maven.aliyun.com/repository/central' }
+        maven { url 'https://maven.aliyun.com/repository/google' }
         mavenCentral()
     }
 
@@ -14,6 +17,9 @@ buildscript {
 allprojects {
     repositories {
         google()
+        // Use Maven Central mirrors as fallback for 403 errors
+        maven { url 'https://maven.aliyun.com/repository/central' }
+        maven { url 'https://maven.aliyun.com/repository/google' }
         mavenCentral()
     }
 }

android/init.gradle

@@ -0,0 +1,37 @@
+// Force all repositories to use mirrors first
+allprojects {
+    repositories {
+        all { ArtifactRepository repo ->
+            if (repo instanceof MavenArtifactRepository) {
+                def url = repo.url.toString()
+                if (url.contains('repo.maven.apache.org') || url.contains('repo1.maven.org')) {
+                    remove repo
+                }
+            }
+        }
+        // Add mirrors before Maven Central
+        maven { url 'https://maven.aliyun.com/repository/central' }
+        maven { url 'https://maven.aliyun.com/repository/google' }
+        maven { url 'https://maven.aliyun.com/repository/gradle-plugin' }
+        maven { url 'https://maven.aliyun.com/repository/public' }
+    }
+}
+
+settingsEvaluated { settings ->
+    settings.pluginManagement {
+        repositories {
+            all { ArtifactRepository repo ->
+                if (repo instanceof MavenArtifactRepository) {
+                    def url = repo.url.toString()
+                    if (url.contains('repo.maven.apache.org') || url.contains('repo1.maven.org')) {
+                        remove repo
+                    }
+                }
+            }
+            maven { url 'https://maven.aliyun.com/repository/central' }
+            maven { url 'https://maven.aliyun.com/repository/google' }
+            maven { url 'https://maven.aliyun.com/repository/gradle-plugin' }
+            maven { url 'https://maven.aliyun.com/repository/public' }
+        }
+    }
+}

docs/AUDIOBOOKS_IMPLEMENTATION_PLAN.md

@@ -0,0 +1,255 @@
+# Audiobooks Integration - Implementation Plan
+
+## Overview
+
+Add audiobook support to Ensemble with automatic user profile separation based on Music Assistant authentication. Includes local database for performance caching and per-user data isolation.
+
+---
+
+## Phase 1: Database Foundation
+
+**Goal:** Add persistent local storage layer using Drift (SQLite)
+
+### Tasks
+- [ ] Add Drift package dependencies (`drift`, `drift_flutter`, `path_provider`)
+- [ ] Create database class with schema version management
+- [ ] Create `profiles` table:
+  ```dart
+  class Profiles extends Table {
+    TextColumn get username => text()();  // MA username (primary key)
+    TextColumn get displayName => text().nullable()();
+    TextColumn get source => text()();  // 'ma_auth' or 'manual'
+    DateTimeColumn get createdAt => dateTime()();
+    BoolColumn get isActive => boolean().withDefault(const Constant(false))();
+  }
+  ```
+- [ ] Create `recently_played` table:
+  ```dart
+  class RecentlyPlayed extends Table {
+    IntColumn get id => integer().autoIncrement()();
+    TextColumn get profileUsername => text().references(Profiles, #username)();
+    TextColumn get mediaId => text()();
+    TextColumn get mediaType => text()();  // 'track', 'album', 'artist', 'audiobook'
+    TextColumn get name => text()();
+    TextColumn get artist => text().nullable()();
+    TextColumn get imageUrl => text().nullable()();
+    DateTimeColumn get playedAt => dateTime()();
+  }
+  ```
+- [ ] Create `library_cache` table for albums/artists/audiobooks
+- [ ] Generate Drift code (`dart run build_runner build`)
+- [ ] Create `DatabaseService` singleton with initialization
+
+### Acceptance Criteria
+- Database initializes on app startup
+- Schema migrations work correctly
+- CRUD operations functional for all tables
+
+---
+
+## Phase 2: Profile System
+
+**Goal:** Auto-create and manage user profiles based on MA authentication
+
+### Tasks
+- [ ] Create `ProfileService` class
+- [ ] On MA login success: check if profile exists for username
+  - If not, create new profile with `displayName` from MA user info
+  - Set as active profile
+- [ ] On manual name entry (no-auth): create/select profile by entered name
+- [ ] Add `getCurrentProfile()` method
+- [ ] Migrate existing `ownerName` to profile on first launch post-update
+- [ ] Add profile indicator to settings screen (show current profile name)
+
+### Acceptance Criteria
+- Profile auto-created on first login
+- Correct profile selected on subsequent logins
+- Existing users migrated seamlessly
+
+---
+
+## Phase 3: Recently Played Migration
+
+**Goal:** Move recently played from memory cache to database, scoped by profile
+
+### Tasks
+- [ ] Update `CacheService` to use database for recently played
+- [ ] Scope all recently played queries by `profileUsername`
+- [ ] Update home screen to load recently played from database
+- [ ] Add `addRecentlyPlayed()` method that records profile + media info
+- [ ] Limit recently played to last 50 items per profile
+- [ ] Remove old memory-based recently played logic
+
+### Acceptance Criteria
+- Recently played persists across app restarts
+- Each profile sees only their own recently played
+- No cross-contamination between profiles
+
+---
+
+## Phase 4: Library Caching
+
+**Goal:** Cache library data locally for instant UI and reduced API calls
+
+### Tasks
+- [ ] Create `SyncService` for background library synchronization
+- [ ] On app launch: load from cache immediately, sync in background
+- [ ] Store albums, artists in `library_cache` table
+- [ ] Add `lastSynced` timestamp to track freshness
+- [ ] Implement delta sync (only fetch changed items if MA supports it)
+- [ ] Add pull-to-refresh that forces full sync
+- [ ] Show subtle sync indicator when background sync in progress
+
+### Acceptance Criteria
+- Home screen loads instantly from cache
+- Library tabs load instantly
+- Background sync updates data without blocking UI
+- Stale data refreshed within reasonable timeframe
+
+---
+
+## Phase 5: Scrollable Library Tabs
+
+**Goal:** Make library tab row scrollable to accommodate more tabs
+
+### Tasks
+- [ ] Convert `TabBar` to scrollable variant (`isScrollable: true`)
+- [ ] Adjust tab styling for scrollable layout
+- [ ] Ensure indicator line spans correctly
+- [ ] Test with varying number of tabs
+- [ ] Add "Books" tab placeholder (disabled until Phase 6)
+
+### Acceptance Criteria
+- Tabs scroll horizontally when they exceed screen width
+- Current tab indicator works correctly
+- Smooth scrolling experience
+
+---
+
+## Phase 6: Audiobooks Tab - Browse by Author
+
+**Goal:** Add Books tab with author → books hierarchy
+
+### Tasks
+- [ ] Add MA API method to fetch audiobooks: `getAudiobooks()`
+- [ ] Add MA API method to fetch audiobook authors
+- [ ] Create `AudiobookAuthor` model
+- [ ] Create `Audiobook` model with fields:
+  - `id`, `name`, `authors`, `narrators`, `description`
+  - `duration`, `imageUrl`, `chapters`, `resumePosition`, `fullyPlayed`
+- [ ] Create `BooksScreen` with author list view
+- [ ] Tapping author expands to show their books
+- [ ] Add to library tab bar
+- [ ] Cache audiobooks in local database
+
+### Acceptance Criteria
+- Books tab shows list of authors
+- Authors expandable to show their audiobooks
+- Audiobook covers and titles display correctly
+- Data cached locally for fast subsequent loads
+
+---
+
+## Phase 7: Audiobook Detail Screen
+
+**Goal:** Full audiobook detail view with metadata and chapters
+
+### Tasks
+- [ ] Create `AudiobookDetailScreen`
+- [ ] Display: cover art, title, author(s), narrator(s)
+- [ ] Display: description (expandable if long)
+- [ ] Display: total duration, progress indicator
+- [ ] Chapter list with:
+  - Chapter title
+  - Duration
+  - Played indicator (based on resume position)
+- [ ] Tapping chapter starts playback from that chapter
+- [ ] "Resume" button that continues from `resume_position_ms`
+- [ ] "Start Over" option
+
+### Acceptance Criteria
+- All metadata displays correctly
+- Chapters show with accurate durations
+- Resume position reflected in UI
+- Can start playback from any chapter
+
+---
+
+## Phase 8: Audiobook Playback Integration
+
+**Goal:** Proper audiobook playback with seek and resume
+
+### Tasks
+- [ ] Implement `playAudiobook(bookId, startPosition?)` method
+- [ ] Use `queueCommandSeek()` to resume at correct position
+- [ ] Update now playing UI to show:
+  - Book title instead of track
+  - Current chapter name
+  - Chapter progress (not just total progress)
+- [ ] Add skip forward/back buttons (30 sec for audiobooks?)
+- [ ] Add chapter skip buttons (next/previous chapter)
+- [ ] Record to recently played when audiobook starts (with 'audiobook' type)
+
+### Acceptance Criteria
+- Audiobooks resume from correct position
+- Chapter information shows in now playing
+- Skip controls work correctly
+- Recently played records audiobook plays
+
+---
+
+## Phase 9: Polish & Edge Cases
+
+**Goal:** Handle edge cases and improve UX
+
+### Tasks
+- [ ] Handle audiobooks with no chapters gracefully
+- [ ] Handle very long audiobooks (20+ hours)
+- [ ] Add "Mark as Finished" option
+- [ ] Add "Mark as Unplayed" option
+- [ ] Ensure offline browsing works for cached audiobooks
+- [ ] Test with various audiobook lengths and chapter counts
+- [ ] Performance testing with large audiobook libraries
+
+### Acceptance Criteria
+- No crashes on edge cases
+- Smooth performance
+- All user actions have appropriate feedback
+
+---
+
+## Future Enhancements (Out of Scope)
+
+- Sleep timer
+- Playback speed control
+- Series support (requires MA provider update)
+- Bookmarks
+- Listening statistics
+- Download for offline playback
+
+---
+
+## Technical Notes
+
+### Database Choice: Drift
+- SQLite wrapper with type-safe queries
+- Good for relational data (profiles → recently_played)
+- Mature, well-documented
+- Supports migrations
+
+### MA API Endpoints Used
+- `music/audiobooks` - List audiobooks
+- `music/audiobook/{id}` - Get audiobook details
+- `player_queues/play_media` - Start playback
+- `player_queues/seek` - Seek to position
+- `music/in_progress_items` - Get items with resume positions
+
+### Profile Data Flow
+```
+MA Login → Get user_info → Check/Create Profile → Set Active → Load Profile Data
+```
+
+### Recently Played Flow
+```
+Play Media → Check Active Profile → Insert RecentlyPlayed Row → Update UI
+```

l10n.yaml

@@ -0,0 +1,5 @@
+arb-dir: lib/l10n
+template-arb-file: app_en.arb
+output-localization-file: app_localizations.dart
+synthetic-package: false
+output-class: S

lib/constants/hero_tags.dart

@@ -13,4 +13,31 @@ class HeroTags {
 
   /// Artist image hero tag prefix
   static const String artistImage = 'artist_image_';
+
+  /// Audiobook cover hero tag prefix
+  static const String audiobookCover = 'audiobook_cover_';
+
+  /// Audiobook title hero tag prefix
+  static const String audiobookTitle = 'audiobook_title_';
+
+  /// Audiobook author name hero tag prefix (for navigating to author screen)
+  static const String audiobookAuthorName = 'audiobook_author_name_';
+
+  /// Audiobook author image hero tag prefix
+  static const String authorImage = 'author_image_';
+
+  /// Podcast cover hero tag prefix
+  static const String podcastCover = 'podcast_cover_';
+
+  /// Playlist cover hero tag prefix
+  static const String playlistCover = 'playlist_cover_';
+
+  /// Playlist title hero tag prefix
+  static const String playlistTitle = 'playlist_title_';
+
+  /// Radio station cover hero tag prefix
+  static const String radioCover = 'radio_cover_';
+
+  /// Radio station title hero tag prefix
+  static const String radioTitle = 'radio_title_';
 }

lib/database/database.dart

@@ -0,0 +1,653 @@
+import 'package:drift/drift.dart';
+import 'package:drift_flutter/drift_flutter.dart';
+
+part 'database.g.dart';
+
+/// User profiles - auto-created from MA login or manual entry
+class Profiles extends Table {
+  /// MA username or manually entered name (primary key)
+  TextColumn get username => text()();
+
+  /// Display name from MA or same as username
+  TextColumn get displayName => text().nullable()();
+
+  /// How the profile was created: 'ma_auth' or 'manual'
+  TextColumn get source => text().withDefault(const Constant('ma_auth'))();
+
+  /// When the profile was created
+  DateTimeColumn get createdAt => dateTime().withDefault(currentDateAndTime)();
+
+  /// Whether this is the currently active profile
+  BoolColumn get isActive => boolean().withDefault(const Constant(false))();
+
+  @override
+  Set<Column> get primaryKey => {username};
+}
+
+/// Recently played items - scoped by profile
+@TableIndex(name: 'idx_recently_played_profile', columns: {#profileUsername})
+@TableIndex(name: 'idx_recently_played_profile_played', columns: {#profileUsername, #playedAt})
+class RecentlyPlayed extends Table {
+  /// Auto-incrementing ID
+  IntColumn get id => integer().autoIncrement()();
+
+  /// Profile this belongs to
+  TextColumn get profileUsername => text().references(Profiles, #username)();
+
+  /// Media item ID from Music Assistant
+  TextColumn get mediaId => text()();
+
+  /// Type: 'track', 'album', 'artist', 'playlist', 'audiobook'
+  TextColumn get mediaType => text()();
+
+  /// Display name of the item
+  TextColumn get name => text()();
+
+  /// Artist/author name (for display)
+  TextColumn get artistName => text().nullable()();
+
+  /// Image URL for the item
+  TextColumn get imageUrl => text().nullable()();
+
+  /// Additional metadata as JSON (e.g., album name for tracks)
+  TextColumn get metadata => text().nullable()();
+
+  /// When this was played
+  DateTimeColumn get playedAt => dateTime()();
+}
+
+/// Cached library items for fast startup
+@TableIndex(name: 'idx_library_cache_type', columns: {#itemType})
+@TableIndex(name: 'idx_library_cache_type_deleted', columns: {#itemType, #isDeleted})
+class LibraryCache extends Table {
+  /// Composite key: provider + item_id
+  TextColumn get cacheKey => text()();
+
+  /// Type: 'album', 'artist', 'track', 'playlist', 'audiobook', 'audiobook_author'
+  TextColumn get itemType => text()();
+
+  /// The item ID from Music Assistant
+  TextColumn get itemId => text()();
+
+  /// Serialized item data as JSON
+  TextColumn get data => text()();
+
+  /// When this was last synced from MA
+  DateTimeColumn get lastSynced => dateTime()();
+
+  /// Whether this item was deleted on the server
+  BoolColumn get isDeleted => boolean().withDefault(const Constant(false))();
+
+  @override
+  Set<Column> get primaryKey => {cacheKey};
+}
+
+/// Sync metadata - tracks last sync times per data type
+class SyncMetadata extends Table {
+  /// What was synced: 'albums', 'artists', 'audiobooks', etc.
+  TextColumn get syncType => text()();
+
+  /// When the last successful sync completed
+  DateTimeColumn get lastSyncedAt => dateTime()();
+
+  /// Number of items synced
+  IntColumn get itemCount => integer().withDefault(const Constant(0))();
+
+  @override
+  Set<Column> get primaryKey => {syncType};
+}
+
+/// Persisted playback state - survives app restarts and disconnects
+class PlaybackState extends Table {
+  /// Always 'current' - single row table
+  TextColumn get id => text().withDefault(const Constant('current'))();
+
+  /// Selected player ID
+  TextColumn get playerId => text().nullable()();
+
+  /// Selected player name (for display if player unavailable)
+  TextColumn get playerName => text().nullable()();
+
+  /// Current track as JSON
+  TextColumn get currentTrackJson => text().nullable()();
+
+  /// Current position in seconds
+  RealColumn get positionSeconds => real().withDefault(const Constant(0.0))();
+
+  /// Whether playback was active
+  BoolColumn get isPlaying => boolean().withDefault(const Constant(false))();
+
+  /// When this state was saved
+  DateTimeColumn get savedAt => dateTime()();
+
+  @override
+  Set<Column> get primaryKey => {id};
+}
+
+/// Cached player list - for instant display on app resume
+class CachedPlayers extends Table {
+  /// Player ID from Music Assistant
+  TextColumn get playerId => text()();
+
+  /// Player data as JSON
+  TextColumn get playerJson => text()();
+
+  /// Current track for this player as JSON (for mini player display)
+  TextColumn get currentTrackJson => text().nullable()();
+
+  /// When this was last updated
+  DateTimeColumn get lastUpdated => dateTime()();
+
+  @override
+  Set<Column> get primaryKey => {playerId};
+}
+
+/// Cached queue items for selected player
+@TableIndex(name: 'idx_cached_queue_player', columns: {#playerId})
+@TableIndex(name: 'idx_cached_queue_player_position', columns: {#playerId, #position})
+class CachedQueue extends Table {
+  /// Auto-incrementing ID for ordering
+  IntColumn get id => integer().autoIncrement()();
+
+  /// Player ID this queue belongs to
+  TextColumn get playerId => text()();
+
+  /// Queue item as JSON
+  TextColumn get itemJson => text()();
+
+  /// Position in queue
+  IntColumn get position => integer()();
+}
+
+/// Cached home row data for instant display on startup
+class HomeRowCache extends Table {
+  /// Row type: 'recent_albums', 'discover_artists', 'discover_albums'
+  TextColumn get rowType => text()();
+
+  /// Serialized list of items as JSON array
+  TextColumn get itemsJson => text()();
+
+  /// When this was last updated
+  DateTimeColumn get lastUpdated => dateTime()();
+
+  @override
+  Set<Column> get primaryKey => {rowType};
+}
+
+/// Search history for quick access to recent searches
+class SearchHistory extends Table {
+  /// Auto-incrementing ID
+  IntColumn get id => integer().autoIncrement()();
+
+  /// The search query
+  TextColumn get query => text()();
+
+  /// When the search was performed
+  DateTimeColumn get searchedAt => dateTime()();
+}
+
+@DriftDatabase(tables: [Profiles, RecentlyPlayed, LibraryCache, SyncMetadata, PlaybackState, CachedPlayers, CachedQueue, HomeRowCache, SearchHistory])
+class AppDatabase extends _$AppDatabase {
+  AppDatabase([QueryExecutor? executor]) : super(executor ?? _openConnection());
+
+  @override
+  int get schemaVersion => 5;
+
+  @override
+  MigrationStrategy get migration {
+    return MigrationStrategy(
+      onCreate: (Migrator m) async {
+        await m.createAll();
+      },
+      onUpgrade: (Migrator m, int from, int to) async {
+        // Migration from v1 to v2: Add playback state, cached players, cached queue tables
+        if (from < 2) {
+          await m.createTable(playbackState);
+          await m.createTable(cachedPlayers);
+          await m.createTable(cachedQueue);
+        }
+        // Migration from v2 to v3: Add home row cache table
+        if (from < 3) {
+          await m.createTable(homeRowCache);
+        }
+        // Migration from v3 to v4: Add search history table
+        if (from < 4) {
+          await m.createTable(searchHistory);
+        }
+        // Migration from v4 to v5: Add indexes for query performance
+        if (from < 5) {
+          // RecentlyPlayed indexes
+          await customStatement('CREATE INDEX IF NOT EXISTS idx_recently_played_profile ON recently_played (profile_username)');
+          await customStatement('CREATE INDEX IF NOT EXISTS idx_recently_played_profile_played ON recently_played (profile_username, played_at)');
+          // LibraryCache indexes
+          await customStatement('CREATE INDEX IF NOT EXISTS idx_library_cache_type ON library_cache (item_type)');
+          await customStatement('CREATE INDEX IF NOT EXISTS idx_library_cache_type_deleted ON library_cache (item_type, is_deleted)');
+          // CachedQueue indexes
+          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)');
+        }
+      },
+    );
+  }
+
+  static QueryExecutor _openConnection() {
+    return driftDatabase(name: 'ensemble_db');
+  }
+
+  // ============================================
+  // Profile Operations
+  // ============================================
+
+  /// Get the currently active profile
+  Future<Profile?> getActiveProfile() async {
+    return (select(profiles)..where((p) => p.isActive.equals(true)))
+        .getSingleOrNull();
+  }
+
+  /// Get a profile by username
+  Future<Profile?> getProfile(String username) async {
+    return (select(profiles)..where((p) => p.username.equals(username)))
+        .getSingleOrNull();
+  }
+
+  /// Create or update a profile and set it as active
+  Future<Profile> setActiveProfile({
+    required String username,
+    String? displayName,
+    required String source,
+  }) async {
+    return transaction(() async {
+      // Deactivate all profiles
+      await (update(profiles)..where((p) => p.isActive.equals(true)))
+          .write(const ProfilesCompanion(isActive: Value(false)));
+
+      // Check if profile exists
+      final existing = await getProfile(username);
+
+      if (existing != null) {
+        // Update and activate existing profile
+        await (update(profiles)..where((p) => p.username.equals(username)))
+            .write(ProfilesCompanion(
+              displayName: Value(displayName ?? existing.displayName),
+              isActive: const Value(true),
+            ));
+      } else {
+        // Create new profile
+        await into(profiles).insert(ProfilesCompanion.insert(
+          username: username,
+          displayName: Value(displayName),
+          source: Value(source),
+          isActive: const Value(true),
+        ));
+      }
+
+      return (await getProfile(username))!;
+    });
+  }
+
+  /// Get all profiles
+  Future<List<Profile>> getAllProfiles() async {
+    return select(profiles).get();
+  }
+
+  // ============================================
+  // Recently Played Operations
+  // ============================================
+
+  /// Add an item to recently played for the active profile
+  Future<void> addRecentlyPlayed({
+    required String mediaId,
+    required String mediaType,
+    required String name,
+    String? artistName,
+    String? imageUrl,
+    String? metadata,
+  }) async {
+    final profile = await getActiveProfile();
+    if (profile == null) return;
+
+    await transaction(() async {
+      // Remove existing entry for this item (to move it to top)
+      await (delete(recentlyPlayed)
+        ..where((r) => r.profileUsername.equals(profile.username))
+        ..where((r) => r.mediaId.equals(mediaId))
+        ..where((r) => r.mediaType.equals(mediaType)))
+        .go();
+
+      // Add new entry
+      await into(recentlyPlayed).insert(RecentlyPlayedCompanion.insert(
+        profileUsername: profile.username,
+        mediaId: mediaId,
+        mediaType: mediaType,
+        name: name,
+        artistName: Value(artistName),
+        imageUrl: Value(imageUrl),
+        metadata: Value(metadata),
+        playedAt: DateTime.now(),
+      ));
+
+      // Keep only last 50 items per profile
+      final allItems = await (select(recentlyPlayed)
+        ..where((r) => r.profileUsername.equals(profile.username))
+        ..orderBy([(r) => OrderingTerm.desc(r.playedAt)]))
+        .get();
+
+      if (allItems.length > 50) {
+        final toDelete = allItems.sublist(50);
+        for (final item in toDelete) {
+          await (delete(recentlyPlayed)..where((r) => r.id.equals(item.id))).go();
+        }
+      }
+    });
+  }
+
+  /// Get recently played items for the active profile
+  Future<List<RecentlyPlayedData>> getRecentlyPlayed({int limit = 20}) async {
+    final profile = await getActiveProfile();
+    if (profile == null) return [];
+
+    return (select(recentlyPlayed)
+      ..where((r) => r.profileUsername.equals(profile.username))
+      ..orderBy([(r) => OrderingTerm.desc(r.playedAt)])
+      ..limit(limit))
+      .get();
+  }
+
+  /// Clear recently played for the active profile
+  Future<void> clearRecentlyPlayed() async {
+    final profile = await getActiveProfile();
+    if (profile == null) return;
+
+    await (delete(recentlyPlayed)
+      ..where((r) => r.profileUsername.equals(profile.username)))
+      .go();
+  }
+
+  // ============================================
+  // Library Cache Operations
+  // ============================================
+
+  /// Cache a library item
+  Future<void> cacheItem({
+    required String itemType,
+    required String itemId,
+    required String data,
+  }) async {
+    final cacheKey = '${itemType}_$itemId';
+
+    await into(libraryCache).insertOnConflictUpdate(LibraryCacheCompanion.insert(
+      cacheKey: cacheKey,
+      itemType: itemType,
+      itemId: itemId,
+      data: data,
+      lastSynced: DateTime.now(),
+    ));
+  }
+
+  /// Get cached items by type
+  Future<List<LibraryCacheData>> getCachedItems(String itemType) async {
+    return (select(libraryCache)
+      ..where((c) => c.itemType.equals(itemType))
+      ..where((c) => c.isDeleted.equals(false)))
+      .get();
+  }
+
+  /// Get a single cached item
+  Future<LibraryCacheData?> getCachedItem(String itemType, String itemId) async {
+    final cacheKey = '${itemType}_$itemId';
+    return (select(libraryCache)..where((c) => c.cacheKey.equals(cacheKey)))
+        .getSingleOrNull();
+  }
+
+  /// Mark items as deleted (soft delete)
+  Future<void> markItemsDeleted(String itemType, List<String> itemIds) async {
+    for (final itemId in itemIds) {
+      final cacheKey = '${itemType}_$itemId';
+      await (update(libraryCache)..where((c) => c.cacheKey.equals(cacheKey)))
+          .write(const LibraryCacheCompanion(isDeleted: Value(true)));
+    }
+  }
+
+  /// Clear all cached items of a type
+  Future<void> clearCache(String itemType) async {
+    await (delete(libraryCache)..where((c) => c.itemType.equals(itemType))).go();
+  }
+
+  /// Clear entire cache
+  Future<void> clearAllCache() async {
+    await delete(libraryCache).go();
+  }
+
+  // ============================================
+  // Sync Metadata Operations
+  // ============================================
+
+  /// Update sync metadata for a type
+  Future<void> updateSyncMetadata(String syncType, int itemCount) async {
+    await into(syncMetadata).insertOnConflictUpdate(SyncMetadataCompanion.insert(
+      syncType: syncType,
+      lastSyncedAt: DateTime.now(),
+      itemCount: Value(itemCount),
+    ));
+  }
+
+  /// Get last sync time for a type
+  Future<DateTime?> getLastSyncTime(String syncType) async {
+    final meta = await (select(syncMetadata)
+      ..where((s) => s.syncType.equals(syncType)))
+      .getSingleOrNull();
+    return meta?.lastSyncedAt;
+  }
+
+  /// Check if sync is needed (older than duration)
+  Future<bool> needsSync(String syncType, Duration maxAge) async {
+    final lastSync = await getLastSyncTime(syncType);
+    if (lastSync == null) return true;
+    return DateTime.now().difference(lastSync) > maxAge;
+  }
+
+  // ============================================
+  // Playback State Operations
+  // ============================================
+
+  /// Save current playback state
+  Future<void> savePlaybackState({
+    String? playerId,
+    String? playerName,
+    String? currentTrackJson,
+    double positionSeconds = 0.0,
+    bool isPlaying = false,
+  }) async {
+    await into(playbackState).insertOnConflictUpdate(PlaybackStateCompanion.insert(
+      id: const Value('current'),
+      playerId: Value(playerId),
+      playerName: Value(playerName),
+      currentTrackJson: Value(currentTrackJson),
+      positionSeconds: Value(positionSeconds),
+      isPlaying: Value(isPlaying),
+      savedAt: DateTime.now(),
+    ));
+  }
+
+  /// Get saved playback state
+  Future<PlaybackStateData?> getPlaybackState() async {
+    return (select(playbackState)..where((p) => p.id.equals('current')))
+        .getSingleOrNull();
+  }
+
+  /// Clear playback state
+  Future<void> clearPlaybackState() async {
+    await delete(playbackState).go();
+  }
+
+  // ============================================
+  // Cached Players Operations
+  // ============================================
+
+  /// Cache a player with its current track
+  Future<void> cachePlayer({
+    required String playerId,
+    required String playerJson,
+    String? currentTrackJson,
+  }) async {
+    await into(cachedPlayers).insertOnConflictUpdate(CachedPlayersCompanion.insert(
+      playerId: playerId,
+      playerJson: playerJson,
+      currentTrackJson: Value(currentTrackJson),
+      lastUpdated: DateTime.now(),
+    ));
+  }
+
+  /// Cache multiple players at once
+  Future<void> cachePlayers(List<Map<String, dynamic>> players) async {
+    await transaction(() async {
+      for (final player in players) {
+        await into(cachedPlayers).insertOnConflictUpdate(CachedPlayersCompanion.insert(
+          playerId: player['playerId'] as String,
+          playerJson: player['playerJson'] as String,
+          currentTrackJson: Value(player['currentTrackJson'] as String?),
+          lastUpdated: DateTime.now(),
+        ));
+      }
+    });
+  }
+
+  /// Get all cached players
+  Future<List<CachedPlayer>> getCachedPlayers() async {
+    return (select(cachedPlayers)
+      ..orderBy([(p) => OrderingTerm.desc(p.lastUpdated)]))
+      .get();
+  }
+
+  /// Get a specific cached player
+  Future<CachedPlayer?> getCachedPlayer(String playerId) async {
+    return (select(cachedPlayers)..where((p) => p.playerId.equals(playerId)))
+        .getSingleOrNull();
+  }
+
+  /// Update cached track for a player
+  Future<void> updateCachedPlayerTrack(String playerId, String? trackJson) async {
+    await (update(cachedPlayers)..where((p) => p.playerId.equals(playerId)))
+        .write(CachedPlayersCompanion(
+          currentTrackJson: Value(trackJson),
+          lastUpdated: Value(DateTime.now()),
+        ));
+  }
+
+  /// Clear all cached players
+  Future<void> clearCachedPlayers() async {
+    await delete(cachedPlayers).go();
+  }
+
+  // ============================================
+  // Cached Queue Operations
+  // ============================================
+
+  /// Save queue for a player
+  Future<void> saveQueue(String playerId, List<String> itemJsonList) async {
+    await transaction(() async {
+      // Clear existing queue for this player
+      await (delete(cachedQueue)..where((q) => q.playerId.equals(playerId))).go();
+
+      // Insert new queue items
+      for (var i = 0; i < itemJsonList.length; i++) {
+        await into(cachedQueue).insert(CachedQueueCompanion.insert(
+          playerId: playerId,
+          itemJson: itemJsonList[i],
+          position: i,
+        ));
+      }
+    });
+  }
+
+  /// Get cached queue for a player
+  Future<List<CachedQueueData>> getCachedQueue(String playerId) async {
+    return (select(cachedQueue)
+      ..where((q) => q.playerId.equals(playerId))
+      ..orderBy([(q) => OrderingTerm.asc(q.position)]))
+      .get();
+  }
+
+  /// Clear queue for a player
+  Future<void> clearCachedQueue(String playerId) async {
+    await (delete(cachedQueue)..where((q) => q.playerId.equals(playerId))).go();
+  }
+
+  /// Clear all cached queues
+  Future<void> clearAllCachedQueues() async {
+    await delete(cachedQueue).go();
+  }
+
+  // ============================================
+  // Home Row Cache Operations
+  // ============================================
+
+  /// Save home row data
+  Future<void> saveHomeRowCache(String rowType, String itemsJson) async {
+    await into(homeRowCache).insertOnConflictUpdate(
+      HomeRowCacheCompanion(
+        rowType: Value(rowType),
+        itemsJson: Value(itemsJson),
+        lastUpdated: Value(DateTime.now()),
+      ),
+    );
+  }
+
+  /// Get cached home row data
+  Future<HomeRowCacheData?> getHomeRowCache(String rowType) async {
+    return (select(homeRowCache)..where((h) => h.rowType.equals(rowType)))
+        .getSingleOrNull();
+  }
+
+  /// Clear all home row cache
+  Future<void> clearHomeRowCache() async {
+    await delete(homeRowCache).go();
+  }
+
+  // ============================================
+  // Search History Operations
+  // ============================================
+
+  /// Save a search query to history (deduplicates and limits to 10)
+  Future<void> saveSearchQuery(String query) async {
+    final trimmedQuery = query.trim();
+    if (trimmedQuery.isEmpty) return;
+
+    await transaction(() async {
+      // Delete existing entry with same query (case-insensitive)
+      await (delete(searchHistory)
+            ..where((s) => s.query.lower().equals(trimmedQuery.toLowerCase())))
+          .go();
+
+      // Insert the new search
+      await into(searchHistory).insert(SearchHistoryCompanion.insert(
+        query: trimmedQuery,
+        searchedAt: DateTime.now(),
+      ));
+
+      // Keep only the 10 most recent searches
+      final allSearches = await (select(searchHistory)
+            ..orderBy([(s) => OrderingTerm.desc(s.searchedAt)]))
+          .get();
+
+      if (allSearches.length > 10) {
+        final toDelete = allSearches.skip(10).map((s) => s.id).toList();
+        await (delete(searchHistory)..where((s) => s.id.isIn(toDelete))).go();
+      }
+    });
+  }
+
+  /// Get recent search queries (up to 10, most recent first)
+  Future<List<String>> getRecentSearches() async {
+    final searches = await (select(searchHistory)
+          ..orderBy([(s) => OrderingTerm.desc(s.searchedAt)])
+          ..limit(10))
+        .get();
+    return searches.map((s) => s.query).toList();
+  }
+
+  /// Clear all search history
+  Future<void> clearSearchHistory() async {
+    await delete(searchHistory).go();
+  }
+}

lib/l10n/app_de.arb

@@ -0,0 +1,298 @@
+{
+  "@@locale": "de",
+
+  "appTitle": "Ensemble",
+  "connecting": "Verbinde...",
+  "connected": "Verbunden",
+  "disconnected": "Getrennt",
+
+  "serverAddress": "Serveradresse",
+  "serverAddressHint": "z.B. music.example.com oder 192.168.1.100",
+  "yourName": "Dein Name",
+  "yourFirstName": "Dein Vorname",
+  "portOptional": "Port (Optional)",
+  "portHint": "z.B. 8095 oder leer lassen",
+  "portDescription": "Leer lassen bei Reverse Proxy oder Standardports. 8095 eingeben bei Direktverbindung.",
+
+  "username": "Benutzername",
+  "password": "Passwort",
+  "detectAndConnect": "Erkennen & Verbinden",
+  "connect": "Verbinden",
+  "disconnect": "Trennen",
+
+  "authServerUrlOptional": "Auth-Server URL (Optional)",
+  "authServerUrlHint": "z.B. auth.example.com (wenn abweichend vom Server)",
+  "authServerUrlDescription": "Leer lassen, wenn Authentifizierung auf demselben Server",
+  "detectedAuthType": "Erkannt: {authType}",
+  "serverRequiresAuth": "Dieser Server erfordert Authentifizierung",
+
+  "tailscaleVpnConnection": "Tailscale VPN-Verbindung",
+  "unencryptedConnection": "Unverschlusselte Verbindung",
+  "usingHttpOverTailscale": "HTTP uber Tailscale (verschlusselter Tunnel)",
+  "httpsFailedUsingHttp": "HTTPS fehlgeschlagen, verwende HTTP",
+  "httpNotEncrypted": "HTTP-Verbindung - Daten sind nicht verschlusselt",
+
+  "pleaseEnterServerAddress": "Bitte gib deine Music Assistant Serveradresse ein",
+  "pleaseEnterName": "Bitte gib deinen Namen ein",
+  "pleaseEnterValidPort": "Bitte gib eine gultige Portnummer ein (1-65535)",
+  "pleaseEnterCredentials": "Bitte gib Benutzername und Passwort ein",
+  "authFailed": "Authentifizierung fehlgeschlagen. Bitte uberprufe deine Anmeldedaten.",
+  "maLoginFailed": "Music Assistant Anmeldung fehlgeschlagen. Bitte uberprufe deine Anmeldedaten.",
+  "connectionFailed": "Verbindung zum Server fehlgeschlagen. Bitte uberprufe die Adresse und versuche es erneut.",
+  "detectingAuth": "Erkenne Authentifizierung...",
+  "cannotDetermineAuth": "Authentifizierungsanforderungen konnten nicht ermittelt werden. Bitte uberprufe die Server-URL.",
+
+  "noAuthentication": "Keine Authentifizierung",
+  "httpBasicAuth": "HTTP Basic Auth",
+  "authelia": "Authelia",
+  "musicAssistantLogin": "Music Assistant Anmeldung",
+
+  "pressBackToMinimize": "Erneut drucken zum Minimieren",
+
+  "recentlyPlayed": "Zuletzt gespielt",
+  "discoverArtists": "Kunstler entdecken",
+  "discoverAlbums": "Alben entdecken",
+  "continueListening": "Weiterhoren",
+  "discoverAudiobooks": "Horbücher entdecken",
+  "discoverSeries": "Serien entdecken",
+  "favoriteAlbums": "Lieblingsalben",
+  "favoriteArtists": "Lieblingskünstler",
+  "favoriteTracks": "Lieblingssongs",
+
+  "searchMusic": "Musik suchen...",
+  "searchForContent": "Nach Künstlern, Alben oder Songs suchen",
+  "retry": "Wiederholen",
+  "all": "Alle",
+  "artists": "Künstler",
+  "albums": "Alben",
+  "tracks": "Songs",
+  "playlists": "Wiedergabelisten",
+  "audiobooks": "Hörbücher",
+  "music": "Musik",
+  "radio": "Radio",
+  "stations": "Sender",
+  "selectLibrary": "Bibliothek auswählen",
+  "noRadioStations": "Keine Radiosender",
+  "addRadioStationsHint": "Füge Radiosender in Music Assistant hinzu",
+  "searchFailed": "Suche fehlgeschlagen. Bitte überprüfe deine Verbindung.",
+
+  "queue": "Warteschlange",
+  "playerQueue": "{playerName} Warteschlange",
+  "noPlayerSelected": "Kein Player ausgewählt",
+  "undo": "Rückgängig",
+  "removedItem": "{itemName} entfernt",
+
+  "settings": "Einstellungen",
+  "debugLogs": "Debug-Protokolle",
+  "themeMode": "Design",
+  "light": "Hell",
+  "dark": "Dunkel",
+  "system": "System",
+  "pullToRefresh": "Ziehe zum Aktualisieren der Bibliothek",
+  "viewDebugLogs": "Debug-Protokolle anzeigen",
+
+  "viewAllPlayers": "Alle Player anzeigen",
+  "copyLogs": "Protokolle kopieren",
+  "clearLogs": "Protokolle löschen",
+  "copyList": "Liste kopieren",
+  "close": "Schließen",
+  "allPlayersCount": "Alle Player ({count})",
+  "errorLoadingPlayers": "Fehler beim Laden der Player: {error}",
+  "logsCopied": "Protokolle in Zwischenablage kopiert",
+  "logsCleared": "Protokolle gelöscht",
+  "playerListCopied": "Playerliste in Zwischenablage kopiert!",
+  "noLogsYet": "Noch keine Protokolle",
+  "infoPlus": "Info+",
+  "warnings": "Warnungen",
+  "errors": "Fehler",
+  "showingEntries": "Zeige {filtered} von {total} Einträgen",
+  "thisDevice": "Dieses Gerät",
+  "ghostPlayer": "Geist-Player (Duplikat)",
+  "unavailableCorrupt": "Nicht verfügbar/Beschädigt",
+  "playerId": "ID: {id}",
+  "playerInfo": "Verfügbar: {available} | Anbieter: {provider}",
+  "shareBugReport": "Fehlerbericht teilen",
+  "moreOptions": "Weitere Optionen",
+
+  "failedToUpdateFavorite": "Favorit konnte nicht aktualisiert werden: {error}",
+  "noPlayersAvailable": "Keine Player verfügbar",
+  "albumAddedToQueue": "Album zur Warteschlange hinzugefügt",
+  "tracksAddedToQueue": "Songs zur Warteschlange hinzugefügt",
+  "play": "Abspielen",
+  "noPlayersFound": "Keine Player gefunden",
+
+  "startingRadio": "Starte {name} Radio",
+  "failedToStartRadio": "Radio konnte nicht gestartet werden: {error}",
+  "startingRadioOnPlayer": "Starte {name} Radio auf {playerName}",
+  "addedRadioToQueue": "{name} Radio zur Warteschlange hinzugefügt",
+  "failedToAddToQueue": "Konnte nicht zur Warteschlange hinzufügen: {error}",
+  "radio": "Radio",
+  "inLibrary": "In Bibliothek",
+  "noAlbumsFound": "Keine Alben gefunden",
+
+  "playing": "Spiele {name}",
+  "playingTrack": "Spiele Song",
+  "nowPlaying": "Wird gespielt",
+
+  "markedAsFinished": "{name} als beendet markiert",
+  "failedToMarkFinished": "Konnte nicht als beendet markieren: {error}",
+  "markedAsUnplayed": "{name} als ungespielt markiert",
+  "failedToMarkUnplayed": "Konnte nicht als ungespielt markieren: {error}",
+  "failedToPlay": "Abspielen fehlgeschlagen: {error}",
+  "markAsFinished": "Als beendet markieren",
+  "markAsUnplayed": "Als ungespielt markieren",
+  "byAuthor": "Von {author}",
+
+  "audiobookCount": "{count} Hörbuch/Hörbücher",
+  "loading": "Laden...",
+  "bookCount": "{count} Buch/Bücher",
+  "books": "Bücher",
+
+  "noFavoriteAudiobooks": "Keine Lieblingshörbücher",
+  "tapHeartAudiobook": "Tippe auf das Herz bei einem Hörbuch, um es zu Favoriten hinzuzufügen",
+  "noAudiobooks": "Keine Hörbücher",
+  "addAudiobooksHint": "Füge Hörbücher zu deiner Bibliothek hinzu, um sie hier zu sehen",
+
+  "noFavoriteArtists": "Keine Lieblingskünstler",
+  "tapHeartArtist": "Tippe auf das Herz bei einem Künstler, um ihn zu Favoriten hinzuzufügen",
+  "noFavoriteAlbums": "Keine Lieblingsalben",
+  "tapHeartAlbum": "Tippe auf das Herz bei einem Album, um es zu Favoriten hinzuzufügen",
+  "noFavoritePlaylists": "Keine Lieblings-Wiedergabelisten",
+  "tapHeartPlaylist": "Tippe auf das Herz bei einer Wiedergabeliste, um sie zu Favoriten hinzuzufügen",
+  "noFavoriteTracks": "Keine Lieblingssongs",
+  "longPressTrackHint": "Halte einen Song gedrückt und tippe auf das Herz, um ihn zu Favoriten hinzuzufügen",
+  "loadSeries": "Serien laden",
+
+  "notConnected": "Nicht mit Music Assistant verbunden",
+  "notConnectedTitle": "Nicht verbunden",
+  "connectHint": "Verbinde dich mit deinem Music Assistant Server, um Musik zu hören",
+  "configureServer": "Server konfigurieren",
+
+  "noArtistsFound": "Keine Künstler gefunden",
+  "noTracksFound": "Keine Songs gefunden",
+  "noPlaylistsFound": "Keine Wiedergabelisten gefunden",
+  "queueIsEmpty": "Warteschlange ist leer",
+  "noResultsFound": "Keine Ergebnisse gefunden",
+  "refresh": "Aktualisieren",
+
+  "debugConsole": "Debug-Konsole",
+  "copy": "Kopieren",
+  "clear": "Löschen",
+  "noLogsToCopy": "Keine Protokolle zum Kopieren",
+  "noDebugLogsYet": "Noch keine Debug-Protokolle. Versuche Authentifizierung zu erkennen.",
+  "showDebug": "Debug anzeigen",
+  "hideDebug": "Debug ausblenden",
+
+  "chapters": "Kapitel",
+  "noChapters": "Keine Kapitel",
+  "noChapterInfo": "Dieses Hörbuch hat keine Kapitelinformationen",
+
+  "errorSeeking": "Fehler beim Spulen: {error}",
+  "error": "Fehler: {error}",
+
+  "home": "Start",
+  "library": "Bibliothek",
+
+  "homeScreen": "Startbildschirm",
+  "metadataApis": "Metadaten-APIs",
+  "theme": "Design",
+  "materialYou": "Material You",
+  "adaptiveTheme": "Adaptives Design",
+
+  "language": "Sprache",
+  "english": "Englisch",
+  "german": "Deutsch",
+  "spanish": "Spanisch",
+
+  "noTracksInPlaylist": "Keine Songs in Wiedergabeliste",
+  "sortAlphabetically": "Alphabetisch sortieren",
+  "sortByYear": "Nach Jahr sortieren",
+  "sortBySeriesOrder": "Nach Serienreihenfolge sortieren",
+  "listView": "Listenansicht",
+  "gridView": "Rasteransicht",
+  "noBooksInSeries": "Keine Bücher in dieser Serie gefunden",
+  "artist": "Künstler",
+  "showRecentlyPlayedAlbums": "Kürzlich gespielte Alben anzeigen",
+  "showRandomArtists": "Zufällige Künstler zum Entdecken anzeigen",
+  "showRandomAlbums": "Zufällige Alben zum Entdecken anzeigen",
+  "showAudiobooksInProgress": "Hörbücher in Bearbeitung anzeigen",
+  "showRandomAudiobooks": "Zufällige Hörbücher zum Entdecken anzeigen",
+  "showRandomSeries": "Zufällige Hörbuchserien zum Entdecken anzeigen",
+  "showFavoriteAlbums": "Lieblingsalben anzeigen",
+  "showFavoriteArtists": "Lieblingskünstler anzeigen",
+  "showFavoriteTracks": "Lieblingssongs anzeigen",
+  "extractColorsFromArtwork": "Farben aus Album- und Künstlercover extrahieren",
+  "chooseHomeScreenRows": "Wähle welche Zeilen auf dem Startbildschirm angezeigt werden",
+  "addedToFavorites": "Zu Favoriten hinzugefügt",
+  "removedFromFavorites": "Aus Favoriten entfernt",
+  "unknown": "Unbekannt",
+  "noUpcomingTracks": "Keine weiteren Songs",
+  "showAll": "Alle anzeigen",
+  "showFavoritesOnly": "Nur Favoriten anzeigen",
+  "changeView": "Ansicht ändern",
+  "authors": "Autoren",
+  "series": "Serien",
+  "shows": "Sendungen",
+  "podcasts": "Podcasts",
+  "podcastSupportComingSoon": "Podcast-Unterstützung kommt bald",
+  "playlist": "Wiedergabeliste",
+  "connectionError": "Verbindungsfehler",
+  "twoColumnGrid": "2-Spalten-Raster",
+  "threeColumnGrid": "3-Spalten-Raster",
+  "fromProviders": "Von Anbietern",
+
+  "resume": "Fortsetzen",
+  "about": "Über",
+  "inProgress": "In Bearbeitung",
+  "narratedBy": "Gesprochen von {narrators}",
+  "unknownNarrator": "Unbekannter Sprecher",
+  "unknownAuthor": "Unbekannter Autor",
+  "loadingChapters": "Lade Kapitel...",
+  "noChapterInfoAvailable": "Keine Kapitelinformationen verfügbar",
+  "percentComplete": "{percent}% abgeschlossen",
+  "theAudioDbApiKey": "TheAudioDB API-Schlüssel",
+  "theAudioDbApiKeyHint": "\"2\" für kostenlosen Zugang oder Premium-Schlüssel",
+  "audiobookLibraries": "Hörbuch-Bibliotheken",
+  "chooseAudiobookLibraries": "Wähle welche Audiobookshelf-Bibliotheken einbezogen werden",
+  "unknownLibrary": "Unbekannte Bibliothek",
+  "noSeriesFound": "Keine Serien gefunden",
+  "ensembleBugReport": "Ensemble Fehlerbericht",
+  "byOwner": "Von {owner}",
+  "noSeriesAvailable": "Keine Serien in deiner Hörbuch-Bibliothek verfügbar.\nZiehe zum Aktualisieren.",
+  "pullToLoadSeries": "Ziehe nach unten um Serien\nvon Music Assistant zu laden",
+
+  "search": "Suche",
+  "metadataApisDescription": "Künstlerbilder werden automatisch von Deezer abgerufen. Füge unten API-Schlüssel für Künstlerbiografien und Albenbeschreibungen hinzu.",
+  "lastFmApiKey": "Last.fm API-Schlüssel",
+  "lastFmApiKeyHint": "Kostenlosen Schlüssel auf last.fm/api holen",
+  "swipeToSwitchDevice": "Wischen um Gerät zu wechseln",
+  "chapterNumber": "Kapitel {number}",
+  "pcmAudio": "PCM-Audio",
+  "playOn": "Abspielen auf...",
+  "addAlbumToQueueOn": "Album zur Warteschlange hinzufügen auf...",
+  "addToQueueOn": "Zur Warteschlange hinzufügen auf...",
+  "startRadioOn": "{name} Radio starten auf...",
+  "book": "Buch",
+  "audiobookSingular": "Hörbuch",
+  "trackCount": "{count} {count, plural, =1{Song} other{Songs}}",
+  "materialYouDescription": "Systemfarben verwenden (Android 12+)",
+  "accentColor": "Akzentfarbe",
+  "players": "Geräte",
+  "preferLocalPlayer": "Lokales Gerät bevorzugen",
+  "preferLocalPlayerDescription": "Dieses Gerät immer zuerst auswählen, wenn verfügbar",
+  "smartSortPlayers": "Intelligente Sortierung",
+  "smartSortPlayersDescription": "Nach Status sortieren (spielt, an, aus) statt alphabetisch",
+  "playerStateUnavailable": "Nicht verfügbar",
+  "playerStateOff": "Aus",
+  "playerStateIdle": "Inaktiv",
+  "playerStateExternalSource": "Externe Quelle",
+  "playerSelected": "Ausgewählt",
+  "actionQueuedForSync": "Wird synchronisiert wenn online",
+  "pendingOfflineActions": "{count} ausstehende Synchronisierung",
+  "hintsAndTips": "Tipps & Hinweise",
+  "showHints": "Hinweise anzeigen",
+  "showHintsDescription": "Hilfreiche Tipps zum Entdecken von Funktionen anzeigen",
+  "pullToSelectPlayers": "Ziehen um Geräte auszuwählen",
+  "holdToSync": "Gedrückt halten zum Sync",
+  "swipeToAdjustVolume": "Wischen für Lautstärke"
+}

lib/l10n/app_es.arb

@@ -0,0 +1,494 @@
+{
+  "@@locale": "es",
+
+  "appTitle": "Ensemble",
+  "connecting": "Conectando...",
+  "connected": "Conectado",
+  "disconnected": "Desconectado",
+  "serverAddress": "Dirección del servidor",
+  "serverAddressHint": "ej., music.example.com o 192.168.1.100",
+  "yourName": "Tu nombre",
+  "yourFirstName": "Tu nombre de pila",
+  "portOptional": "Puerto (Opcional)",
+  "portHint": "ej., 8095 o dejar en blanco",
+  "portDescription": "Dejar en blanco para proxy inverso o puertos estándar. Introduce 8095 para conexión directa.",
+  "username": "Usuario",
+  "password": "Contraseña",
+  "detectAndConnect": "Detectar y conectar",
+  "connect": "Conectar",
+  "disconnect": "Desconectar",
+  "authServerUrlOptional": "URL del servidor de autenticación (Opcional)",
+  "authServerUrlHint": "ej., auth.example.com (si es diferente del servidor)",
+  "authServerUrlDescription": "Dejar vacío si la autenticación está en el mismo servidor",
+  "detectedAuthType": "Detectado: {authType}",
+  "@detectedAuthType": {
+    "placeholders": {
+      "authType": {
+        "type": "String"
+      }
+    }
+  },
+  "serverRequiresAuth": "Este servidor requiere autenticación",
+  "tailscaleVpnConnection": "Conexión VPN Tailscale",
+  "unencryptedConnection": "Conexión sin cifrar",
+  "usingHttpOverTailscale": "Usando HTTP sobre Tailscale (túnel cifrado)",
+  "httpsFailedUsingHttp": "HTTPS falló, usando HTTP como alternativa",
+  "httpNotEncrypted": "Conexión HTTP - los datos no están cifrados",
+  "pleaseEnterServerAddress": "Por favor, introduce la dirección de tu servidor Music Assistant",
+  "pleaseEnterName": "Por favor, introduce tu nombre",
+  "pleaseEnterValidPort": "Por favor, introduce un número de puerto válido (1-65535)",
+  "pleaseEnterCredentials": "Por favor, introduce usuario y contraseña",
+  "authFailed": "Autenticación fallida. Por favor, verifica tus credenciales.",
+  "maLoginFailed": "Inicio de sesión en Music Assistant fallido. Por favor, verifica tus credenciales.",
+  "connectionFailed": "No se pudo conectar al servidor. Por favor, verifica la dirección e inténtalo de nuevo.",
+  "detectingAuth": "Detectando autenticación...",
+  "cannotDetermineAuth": "No se pueden determinar los requisitos de autenticación. Por favor, verifica la URL del servidor.",
+  "noAuthentication": "Sin autenticación",
+  "httpBasicAuth": "Autenticación HTTP Basic",
+  "authelia": "Authelia",
+  "musicAssistantLogin": "Inicio de sesión de Music Assistant",
+  "pressBackToMinimize": "Presiona atrás de nuevo para minimizar",
+  "recentlyPlayed": "Reproducido recientemente",
+  "discoverArtists": "Descubrir artistas",
+  "discoverAlbums": "Descubrir álbumes",
+  "continueListening": "Continuar escuchando",
+  "discoverAudiobooks": "Descubrir audiolibros",
+  "discoverSeries": "Descubrir series",
+  "favoriteAlbums": "Álbumes favoritos",
+  "favoriteArtists": "Artistas favoritos",
+  "favoriteTracks": "Canciones favoritas",
+  "searchMusic": "Buscar música...",
+  "searchForContent": "Buscar artistas, álbumes o canciones",
+  "retry": "Reintentar",
+  "all": "Todo",
+  "artists": "Artistas",
+  "albums": "Álbumes",
+  "tracks": "Canciones",
+  "playlists": "Listas de reproducción",
+  "audiobooks": "Audiolibros",
+  "music": "Música",
+  "radio": "Radio",
+  "stations": "Emisoras",
+  "selectLibrary": "Seleccionar Biblioteca",
+  "noRadioStations": "No hay emisoras de radio",
+  "addRadioStationsHint": "Añade emisoras de radio en Music Assistant",
+  "searchFailed": "Búsqueda fallida. Por favor, verifica tu conexión.",
+  "queue": "Cola",
+  "playerQueue": "Cola de {playerName}",
+  "@playerQueue": {
+    "placeholders": {
+      "playerName": {
+        "type": "String"
+      }
+    }
+  },
+  "noPlayerSelected": "Ningún reproductor seleccionado",
+  "undo": "Deshacer",
+  "removedItem": "Eliminado {itemName}",
+  "@removedItem": {
+    "placeholders": {
+      "itemName": {
+        "type": "String"
+      }
+    }
+  },
+  "settings": "Ajustes",
+  "debugLogs": "Registros de depuración",
+  "themeMode": "Modo de tema",
+  "light": "Claro",
+  "dark": "Oscuro",
+  "system": "Sistema",
+  "pullToRefresh": "Desliza hacia abajo para actualizar la biblioteca y aplicar los cambios",
+  "viewDebugLogs": "Ver registros de depuración",
+  "viewAllPlayers": "Ver todos los reproductores",
+  "copyLogs": "Copiar registros",
+  "clearLogs": "Borrar registros",
+  "copyList": "Copiar lista",
+  "close": "Cerrar",
+  "allPlayersCount": "Todos los reproductores ({count})",
+  "@allPlayersCount": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "errorLoadingPlayers": "Error al cargar reproductores: {error}",
+  "@errorLoadingPlayers": {
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+  "logsCopied": "Registros copiados al portapapeles",
+  "logsCleared": "Registros borrados",
+  "playerListCopied": "Lista de reproductores copiada al portapapeles",
+  "noLogsYet": "Aún no hay registros",
+  "infoPlus": "Info+",
+  "warnings": "Advertencias",
+  "errors": "Errores",
+  "showingEntries": "Mostrando {filtered} de {total} entradas",
+  "@showingEntries": {
+    "placeholders": {
+      "filtered": {
+        "type": "int"
+      },
+      "total": {
+        "type": "int"
+      }
+    }
+  },
+  "thisDevice": "Este dispositivo",
+  "ghostPlayer": "Reproductor fantasma (duplicado)",
+  "unavailableCorrupt": "No disponible/Corrupto",
+  "playerId": "ID: {id}",
+  "@playerId": {
+    "placeholders": {
+      "id": {
+        "type": "String"
+      }
+    }
+  },
+  "playerInfo": "Disponible: {available} | Proveedor: {provider}",
+  "@playerInfo": {
+    "placeholders": {
+      "available": {
+        "type": "String"
+      },
+      "provider": {
+        "type": "String"
+      }
+    }
+  },
+  "shareBugReport": "Compartir informe de errores",
+  "moreOptions": "Más opciones",
+  "failedToUpdateFavorite": "Error al actualizar favorito: {error}",
+  "@failedToUpdateFavorite": {
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+  "noPlayersAvailable": "No hay reproductores disponibles",
+  "albumAddedToQueue": "Álbum añadido a la cola",
+  "tracksAddedToQueue": "Canciones añadidas a la cola",
+  "play": "Reproducir",
+  "noPlayersFound": "No se encontraron reproductores",
+  "startingRadio": "Iniciando radio de {name}",
+  "@startingRadio": {
+    "placeholders": {
+      "name": {
+        "type": "String"
+      }
+    }
+  },
+  "failedToStartRadio": "Error al iniciar radio: {error}",
+  "@failedToStartRadio": {
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+  "startingRadioOnPlayer": "Iniciando radio de {name} en {playerName}",
+  "@startingRadioOnPlayer": {
+    "placeholders": {
+      "name": {
+        "type": "String"
+      },
+      "playerName": {
+        "type": "String"
+      }
+    }
+  },
+  "addedRadioToQueue": "Radio de {name} añadida a la cola",
+  "@addedRadioToQueue": {
+    "placeholders": {
+      "name": {
+        "type": "String"
+      }
+    }
+  },
+  "failedToAddToQueue": "Error al añadir a la cola: {error}",
+  "@failedToAddToQueue": {
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+  "radio": "Radio",
+  "inLibrary": "En la biblioteca",
+  "noAlbumsFound": "No se encontraron álbumes",
+  "playing": "Reproduciendo {name}",
+  "@playing": {
+    "placeholders": {
+      "name": {
+        "type": "String"
+      }
+    }
+  },
+  "playingTrack": "Reproduciendo canción",
+  "nowPlaying": "Reproduciendo ahora",
+  "markedAsFinished": "{name} marcado como terminado",
+  "@markedAsFinished": {
+    "placeholders": {
+      "name": {
+        "type": "String"
+      }
+    }
+  },
+  "failedToMarkFinished": "Error al marcar como terminado: {error}",
+  "@failedToMarkFinished": {
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+  "markedAsUnplayed": "{name} marcado como no reproducido",
+  "@markedAsUnplayed": {
+    "placeholders": {
+      "name": {
+        "type": "String"
+      }
+    }
+  },
+  "failedToMarkUnplayed": "Error al marcar como no reproducido: {error}",
+  "@failedToMarkUnplayed": {
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+  "failedToPlay": "Error al reproducir: {error}",
+  "@failedToPlay": {
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+  "markAsFinished": "Marcar como terminado",
+  "markAsUnplayed": "Marcar como no reproducido",
+  "byAuthor": "Por {author}",
+  "@byAuthor": {
+    "placeholders": {
+      "author": {
+        "type": "String"
+      }
+    }
+  },
+  "audiobookCount": "{count} audiolibro(s)",
+  "@audiobookCount": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "loading": "Cargando...",
+  "bookCount": "{count} libro(s)",
+  "@bookCount": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "books": "Libros",
+  "noFavoriteAudiobooks": "No hay audiolibros favoritos",
+  "tapHeartAudiobook": "Toca el corazón en un audiolibro para añadirlo a favoritos",
+  "noAudiobooks": "No hay audiolibros",
+  "addAudiobooksHint": "Añade audiolibros a tu biblioteca para verlos aquí",
+  "noFavoriteArtists": "No hay artistas favoritos",
+  "tapHeartArtist": "Toca el corazón en un artista para añadirlo a favoritos",
+  "noFavoriteAlbums": "No hay álbumes favoritos",
+  "tapHeartAlbum": "Toca el corazón en un álbum para añadirlo a favoritos",
+  "noFavoritePlaylists": "No hay listas de reproducción favoritas",
+  "tapHeartPlaylist": "Toca el corazón en una lista para añadirla a favoritos",
+  "noFavoriteTracks": "No hay canciones favoritas",
+  "longPressTrackHint": "Mantén presionada una canción y toca el corazón para añadirla a favoritos",
+  "loadSeries": "Cargar series",
+  "notConnected": "No conectado a Music Assistant",
+  "notConnectedTitle": "No conectado",
+  "connectHint": "Conéctate a tu servidor Music Assistant para empezar a escuchar",
+  "configureServer": "Configurar servidor",
+  "noArtistsFound": "No se encontraron artistas",
+  "noTracksFound": "No se encontraron canciones",
+  "noPlaylistsFound": "No se encontraron listas de reproducción",
+  "queueIsEmpty": "La cola está vacía",
+  "noResultsFound": "No se encontraron resultados",
+  "refresh": "Actualizar",
+  "debugConsole": "Consola de depuración",
+  "copy": "Copiar",
+  "clear": "Borrar",
+  "noLogsToCopy": "No hay registros para copiar",
+  "noDebugLogsYet": "Aún no hay registros de depuración. Intenta detectar autenticación.",
+  "showDebug": "Mostrar depuración",
+  "hideDebug": "Ocultar depuración",
+  "chapters": "Capítulos",
+  "noChapters": "Sin capítulos",
+  "noChapterInfo": "Este audiolibro no tiene información de capítulos",
+  "errorSeeking": "Error al buscar: {error}",
+  "@errorSeeking": {
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+  "error": "Error: {error}",
+  "@error": {
+    "placeholders": {
+      "error": {
+        "type": "String"
+      }
+    }
+  },
+  "home": "Inicio",
+  "library": "Biblioteca",
+  "homeScreen": "Pantalla de inicio",
+  "metadataApis": "APIs de metadatos",
+  "theme": "Tema",
+  "materialYou": "Material You",
+  "adaptiveTheme": "Tema adaptativo",
+  "language": "Idioma",
+  "english": "Inglés",
+  "german": "Alemán",
+  "spanish": "Español",
+  "noTracksInPlaylist": "No hay canciones en la lista",
+  "sortAlphabetically": "Ordenar alfabéticamente",
+  "sortByYear": "Ordenar por año",
+  "sortBySeriesOrder": "Ordenar por orden de serie",
+  "listView": "Vista de lista",
+  "gridView": "Vista de cuadrícula",
+  "noBooksInSeries": "No se encontraron libros en esta serie",
+  "artist": "Artista",
+  "showRecentlyPlayedAlbums": "Mostrar álbumes reproducidos recientemente",
+  "showRandomArtists": "Mostrar artistas aleatorios para descubrir",
+  "showRandomAlbums": "Mostrar álbumes aleatorios para descubrir",
+  "showAudiobooksInProgress": "Mostrar audiolibros en progreso",
+  "showRandomAudiobooks": "Mostrar audiolibros aleatorios para descubrir",
+  "showRandomSeries": "Mostrar series de audiolibros aleatorias para descubrir",
+  "showFavoriteAlbums": "Mostrar una fila de tus álbumes favoritos",
+  "showFavoriteArtists": "Mostrar una fila de tus artistas favoritos",
+  "showFavoriteTracks": "Mostrar una fila de tus canciones favoritas",
+  "extractColorsFromArtwork": "Extraer colores de las portadas de álbumes y artistas",
+  "chooseHomeScreenRows": "Elige qué filas mostrar en la pantalla de inicio",
+  "addedToFavorites": "Añadido a favoritos",
+  "removedFromFavorites": "Eliminado de favoritos",
+  "unknown": "Desconocido",
+  "noUpcomingTracks": "No hay canciones próximas",
+  "showAll": "Mostrar todo",
+  "showFavoritesOnly": "Mostrar solo favoritos",
+  "changeView": "Cambiar vista",
+  "authors": "Autores",
+  "series": "Series",
+  "shows": "Programas",
+  "podcasts": "Podcasts",
+  "podcastSupportComingSoon": "Soporte de podcasts próximamente",
+  "playlist": "Lista de reproducción",
+  "connectionError": "Error de conexión",
+  "twoColumnGrid": "Cuadrícula de 2 columnas",
+  "threeColumnGrid": "Cuadrícula de 3 columnas",
+  "fromProviders": "De proveedores",
+  "resume": "Continuar",
+  "about": "Acerca de",
+  "inProgress": "En progreso",
+  "narratedBy": "Narrado por {narrators}",
+  "@narratedBy": {
+    "placeholders": {
+      "narrators": {
+        "type": "String"
+      }
+    }
+  },
+  "unknownNarrator": "Narrador desconocido",
+  "unknownAuthor": "Autor desconocido",
+  "loadingChapters": "Cargando capítulos...",
+  "noChapterInfoAvailable": "No hay información de capítulos disponible",
+  "percentComplete": "{percent}% completado",
+  "@percentComplete": {
+    "placeholders": {
+      "percent": {
+        "type": "int"
+      }
+    }
+  },
+  "theAudioDbApiKey": "Clave API de TheAudioDB",
+  "theAudioDbApiKeyHint": "Usa \"2\" para nivel gratuito o clave premium",
+  "audiobookLibraries": "Bibliotecas de audiolibros",
+  "chooseAudiobookLibraries": "Elige qué bibliotecas de Audiobookshelf incluir",
+  "unknownLibrary": "Biblioteca desconocida",
+  "noSeriesFound": "No se encontraron series",
+  "ensembleBugReport": "Informe de errores de Ensemble",
+  "byOwner": "Por {owner}",
+  "@byOwner": {
+    "placeholders": {
+      "owner": {
+        "type": "String"
+      }
+    }
+  },
+  "noSeriesAvailable": "No hay series disponibles en tu biblioteca de audiolibros.\nDesliza para actualizar.",
+  "pullToLoadSeries": "Desliza hacia abajo para cargar series\ndesde Music Assistant",
+  "search": "Buscar",
+  "metadataApisDescription": "Las imágenes de artistas se obtienen automáticamente de Deezer. Añade claves API a continuación para biografías de artistas y descripciones de álbumes.",
+  "lastFmApiKey": "Clave API de Last.fm",
+  "lastFmApiKeyHint": "Obtén una clave gratuita en last.fm/api",
+  "swipeToSwitchDevice": "Desliza para cambiar dispositivo",
+  "chapterNumber": "Capítulo {number}",
+  "@chapterNumber": {
+    "placeholders": {
+      "number": {
+        "type": "int"
+      }
+    }
+  },
+  "pcmAudio": "Audio PCM",
+  "playOn": "Reproducir en...",
+  "addAlbumToQueueOn": "Añadir álbum a la cola en...",
+  "addToQueueOn": "Añadir a la cola en...",
+  "startRadioOn": "Iniciar radio de {name} en...",
+  "@startRadioOn": {
+    "placeholders": {
+      "name": {
+        "type": "String"
+      }
+    }
+  },
+  "book": "libro",
+  "audiobookSingular": "audiolibro",
+  "trackCount": "{count} {count, plural, =1{canción} other{canciones}}",
+  "@trackCount": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "materialYouDescription": "Usar colores del sistema (Android 12+)",
+  "accentColor": "Color de acento",
+  "players": "Dispositivos",
+  "preferLocalPlayer": "Preferir dispositivo local",
+  "preferLocalPlayerDescription": "Seleccionar siempre este dispositivo primero cuando esté disponible",
+  "smartSortPlayers": "Orden inteligente",
+  "smartSortPlayersDescription": "Ordenar por estado (reproduciendo, encendido, apagado) en lugar de alfabéticamente",
+  "playerStateUnavailable": "No disponible",
+  "playerStateOff": "Apagado",
+  "playerStateIdle": "Inactivo",
+  "playerStateExternalSource": "Fuente Externa",
+  "playerSelected": "Seleccionado",
+  "actionQueuedForSync": "Se sincronizará cuando esté en línea",
+  "pendingOfflineActions": "{count} sincronización pendiente",
+  "hintsAndTips": "Consejos y Sugerencias",
+  "showHints": "Mostrar Sugerencias",
+  "showHintsDescription": "Mostrar consejos útiles para descubrir funciones",
+  "pullToSelectPlayers": "Desliza para seleccionar dispositivos",
+  "holdToSync": "Mantén presionado para sync",
+  "swipeToAdjustVolume": "Desliza para ajustar volumen"
+}

lib/main.dart

@@ -3,11 +3,17 @@ import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:provider/provider.dart';
 import 'package:audio_service/audio_service.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'l10n/app_localizations.dart';
+import 'providers/locale_provider.dart';
 import 'providers/music_assistant_provider.dart';
 import 'providers/navigation_provider.dart';
 import 'screens/home_screen.dart';
 import 'screens/login_screen.dart';
 import 'services/settings_service.dart';
+import 'services/database_service.dart';
+import 'services/profile_service.dart';
+import 'services/sync_service.dart';
 import 'services/audio/massiv_audio_handler.dart';
 import 'services/auth/auth_manager.dart';
 import 'services/debug_logger.dart';
@@ -27,6 +33,21 @@ final _logger = DebugLogger();
 Future<void> main() async {
   WidgetsFlutterBinding.ensureInitialized();
 
+  // Initialize local database
+  await DatabaseService.instance.initialize();
+  _logger.log('💾 Database initialized');
+
+  // Migrate existing ownerName to profile (one-time for existing users)
+  await ProfileService.instance.migrateFromOwnerName();
+
+  // Migrate credentials to secure storage (one-time for existing users)
+  await SettingsService.migrateToSecureStorage();
+  _logger.log('🔐 Secure storage migration complete');
+
+  // Load library from cache for instant startup
+  await SyncService.instance.loadFromCache();
+  _logger.log('📦 Library cache loaded');
+
   // Create auth manager for streaming headers
   final authManager = AuthManager();
 
@@ -50,13 +71,16 @@ Future<void> main() async {
     DeviceOrientation.portraitDown,
   ]);
 
-  // Set system UI overlay style
+  // Set initial system UI overlay style based on platform brightness
+  // SystemUIWrapper will update this dynamically when theme changes
+  final platformBrightness = WidgetsBinding.instance.platformDispatcher.platformBrightness;
+  final isDark = platformBrightness == Brightness.dark;
   SystemChrome.setSystemUIOverlayStyle(
-    const SystemUiOverlayStyle(
+    SystemUiOverlayStyle(
       statusBarColor: Colors.transparent,
-      statusBarIconBrightness: Brightness.light,
-      systemNavigationBarColor: Color(0xFF1a1a1a),
-      systemNavigationBarIconBrightness: Brightness.light,
+      statusBarIconBrightness: isDark ? Brightness.light : Brightness.dark,
+      systemNavigationBarColor: isDark ? const Color(0xFF1a1a1a) : const Color(0xFFF5F5F5),
+      systemNavigationBarIconBrightness: isDark ? Brightness.light : Brightness.dark,
     ),
   );
 
@@ -73,6 +97,7 @@ class MusicAssistantApp extends StatefulWidget {
 class _MusicAssistantAppState extends State<MusicAssistantApp> with WidgetsBindingObserver {
   late MusicAssistantProvider _musicProvider;
   late ThemeProvider _themeProvider;
+  late LocaleProvider _localeProvider;
   final _hardwareVolumeService = HardwareVolumeService();
   StreamSubscription? _volumeUpSub;
   StreamSubscription? _volumeDownSub;
@@ -87,6 +112,7 @@ class _MusicAssistantAppState extends State<MusicAssistantApp> with WidgetsBindi
     super.initState();
     _musicProvider = MusicAssistantProvider();
     _themeProvider = ThemeProvider();
+    _localeProvider = LocaleProvider();
     WidgetsBinding.instance.addObserver(this);
     _initHardwareVolumeControl();
     // Listen to player selection changes to toggle volume interception
@@ -153,11 +179,28 @@ class _MusicAssistantAppState extends State<MusicAssistantApp> with WidgetsBindi
   @override
   Future<bool> didPopRoute() async {
     // Intercept back button at app level - runs BEFORE Navigator processes it
-    // If player is expanded, collapse it and consume the back gesture
+    // Priority order: device list > queue panel > expanded player > normal navigation
+
+    // Device list has highest priority - dismiss it first
+    if (GlobalPlayerOverlay.isPlayerRevealVisible) {
+      GlobalPlayerOverlay.dismissPlayerReveal();
+      return true; // We handled it, don't let Navigator process it
+    }
+
+    // Queue panel second - close it before collapsing player
+    // Use target state (not animation value) to handle rapid open-close timing
+    // Use withHaptic: false because Android back gesture provides system haptic
+    if (GlobalPlayerOverlay.isQueuePanelTargetOpen) {
+      GlobalPlayerOverlay.closeQueuePanel(withHaptic: false);
+      return true; // We handled it, don't let Navigator process it
+    }
+
+    // Then check expanded player
     if (GlobalPlayerOverlay.isPlayerExpanded) {
       GlobalPlayerOverlay.collapsePlayer();
       return true; // We handled it, don't let Navigator process it
     }
+
     // Let Navigator handle the back gesture normally
     return super.didPopRoute();
   }
@@ -183,9 +226,10 @@ class _MusicAssistantAppState extends State<MusicAssistantApp> with WidgetsBindi
       providers: [
         ChangeNotifierProvider.value(value: _musicProvider),
         ChangeNotifierProvider.value(value: _themeProvider),
+        ChangeNotifierProvider.value(value: _localeProvider),
       ],
-      child: Consumer<ThemeProvider>(
-        builder: (context, themeProvider, _) {
+      child: Consumer2<ThemeProvider, LocaleProvider>(
+        builder: (context, themeProvider, localeProvider, _) {
           return FutureBuilder<(ColorScheme, ColorScheme)?>(
             future: themeProvider.useMaterialTheme
                 ? SystemThemeHelper.getSystemColorSchemes()
@@ -196,14 +240,21 @@ class _MusicAssistantAppState extends State<MusicAssistantApp> with WidgetsBindi
               ColorScheme? darkColorScheme;
 
               if (themeProvider.useMaterialTheme && snapshot.hasData && snapshot.data != null) {
-                // Use system color schemes
+                // Use system color schemes, but override background to match app design
+                // Material You doesn't set background consistently, causing black screen issues
                 final (light, dark) = snapshot.data!;
-                lightColorScheme = light;
-                darkColorScheme = dark;
+                lightColorScheme = light.copyWith(
+                  surface: light.surface,
+                  background: const Color(0xFFFAFAFA), // App's preferred light background
+                );
+                darkColorScheme = dark.copyWith(
+                  surface: const Color(0xFF2a2a2a), // App's preferred dark surface
+                  background: const Color(0xFF1a1a1a), // App's preferred dark background
+                );
               } else {
-                // Use brand color schemes
-                lightColorScheme = brandLightColorScheme;
-                darkColorScheme = brandDarkColorScheme;
+                // Use custom color from theme provider
+                lightColorScheme = generateLightColorScheme(themeProvider.customColor);
+                darkColorScheme = generateDarkColorScheme(themeProvider.customColor);
               }
 
               return SystemUIWrapper(
@@ -214,6 +265,15 @@ class _MusicAssistantAppState extends State<MusicAssistantApp> with WidgetsBindi
                   navigatorKey: navigationProvider.navigatorKey,
                   title: 'Ensemble',
                   debugShowCheckedModeBanner: false,
+                  // Localization
+                  localizationsDelegates: const [
+                    S.delegate,
+                    GlobalMaterialLocalizations.delegate,
+                    GlobalWidgetsLocalizations.delegate,
+                    GlobalCupertinoLocalizations.delegate,
+                  ],
+                  supportedLocales: S.supportedLocales,
+                  locale: localeProvider.locale,
                   themeMode: themeProvider.themeMode,
                   theme: AppTheme.lightTheme(colorScheme: lightColorScheme),
                   darkTheme: AppTheme.darkTheme(colorScheme: darkColorScheme),
@@ -290,8 +350,8 @@ class _SystemUIWrapperState extends State<SystemUIWrapper> {
           statusBarColor: Colors.transparent,
           statusBarIconBrightness: isDark ? Brightness.light : Brightness.dark,
           systemNavigationBarColor: isDark
-              ? widget.darkColorScheme.background
-              : widget.lightColorScheme.background,
+              ? widget.darkColorScheme.surface
+              : widget.lightColorScheme.surface,
           systemNavigationBarIconBrightness: isDark ? Brightness.light : Brightness.dark,
         ),
       );
@@ -310,7 +370,16 @@ class _SystemUIWrapperState extends State<SystemUIWrapper> {
   }
 }
 
-/// Startup widget that checks if user is logged in and auto-connects
+/// Startup widget that checks if user is logged in and auto-connects.
+///
+/// CRITICAL: This widget is the single source of truth for the startup transition.
+/// It loads settings FIRST (before connection), then waits for the appropriate
+/// conditions before showing HomeScreen. This eliminates the race condition between
+/// AppStartup and GlobalPlayerOverlay that caused the home screen flash.
+///
+/// For first-time users: Holds dark screen until connected + player selected,
+/// so the welcome overlay can appear seamlessly.
+/// For returning users: Transitions as soon as connection is established.
 class AppStartup extends StatefulWidget {
   const AppStartup({super.key});
 
@@ -323,9 +392,32 @@ class _AppStartupState extends State<AppStartup> {
   String? _savedServerUrl;
   bool _connectionAttempted = false;
 
+  // Welcome system state - loaded FIRST before connection check
+  bool _settingsLoaded = false;
+  bool _hasCompletedOnboarding = true; // Default to true (no welcome needed)
+
   @override
   void initState() {
     super.initState();
+    _loadSettingsFirst();
+  }
+
+  /// Load settings BEFORE checking connection.
+  /// This ensures we know if this is a first-time user before transitioning.
+  Future<void> _loadSettingsFirst() async {
+    // Load onboarding state first - this is critical for determining
+    // when to transition to HomeScreen
+    _hasCompletedOnboarding = await SettingsService.getHasCompletedOnboarding();
+
+    if (!mounted) return;
+
+    setState(() {
+      _settingsLoaded = true;
+    });
+
+    _logger.log('🚀 AppStartup: Settings loaded, hasCompletedOnboarding=$_hasCompletedOnboarding');
+
+    // Now check connection
     _checkAndConnect();
   }
 
@@ -350,14 +442,30 @@ class _AppStartupState extends State<AppStartup> {
       // Just wait for it to complete or timeout
       _logger.log('🚀 AppStartup: Waiting for provider auto-connection to $serverUrl');
 
+      // For first-time users, we need to wait for both connection AND player selection
+      // so the welcome overlay can appear immediately without home screen flash.
+      // For returning users, just wait for connection.
+      final needsWelcome = !_hasCompletedOnboarding;
+
       // Give the provider time to connect (it restores credentials and connects in _initialize)
       // Check connection state periodically
       for (var i = 0; i < 20; i++) {
         await Future.delayed(const Duration(milliseconds: 250));
-        if (provider.isConnected) {
-          _logger.log('🚀 AppStartup: Connection established');
-          break;
+
+        if (needsWelcome) {
+          // First-time user: wait for connection + player selection
+          if (provider.isConnected && provider.selectedPlayer != null) {
+            _logger.log('🚀 AppStartup: First-time user ready (connected + player selected)');
+            break;
+          }
+        } else {
+          // Returning user: just wait for connection
+          if (provider.isConnected) {
+            _logger.log('🚀 AppStartup: Connection established');
+            break;
+          }
         }
+
         if (provider.connectionState == MAConnectionState.error) {
           _logger.log('🚀 AppStartup: Connection failed with error');
           break;
@@ -384,7 +492,8 @@ class _AppStartupState extends State<AppStartup> {
   @override
   Widget build(BuildContext context) {
     // Show loading while checking settings or connecting
-    if (!_connectionAttempted || _isConnecting) {
+    // CRITICAL: Don't transition until settings are loaded - this prevents the race
+    if (!_settingsLoaded || !_connectionAttempted || _isConnecting) {
       return Scaffold(
         backgroundColor: const Color(0xFF1a1a1a),
         body: Center(

lib/models/media_item.dart

@@ -4,6 +4,10 @@ enum MediaType {
   track,
   playlist,
   radio,
+  audiobook,
+  chapter,
+  podcast,
+  podcastEpisode,
 }
 
 class ProviderMapping {
@@ -106,7 +110,8 @@ class MediaItem {
       'media_type': mediaType.name,
       if (sortName != null) 'sort_name': sortName,
       if (uri != null) 'uri': uri,
-      if (providerMappings != null) 'provider_mappings': providerMappings,
+      if (providerMappings != null)
+        'provider_mappings': providerMappings!.map((m) => m.toJson()).toList(),
       if (metadata != null) 'metadata': metadata,
       if (favorite != null) 'favorite': favorite,
       if (position != null) 'position': position,
@@ -140,11 +145,15 @@ class Artist extends MediaItem {
       favorite: item.favorite,
     );
   }
+
+  @override
+  Map<String, dynamic> toJson() => super.toJson();
 }
 
 class Album extends MediaItem {
   final List<Artist>? artists;
   final String? albumType;
+  final int? year;
 
   Album({
     required super.itemId,
@@ -152,6 +161,7 @@ class Album extends MediaItem {
     required super.name,
     this.artists,
     this.albumType,
+    this.year,
     super.sortName,
     super.uri,
     super.providerMappings,
@@ -161,6 +171,15 @@ class Album extends MediaItem {
 
   factory Album.fromJson(Map<String, dynamic> json) {
     final item = MediaItem.fromJson(json);
+    // Parse year - can be int or null
+    int? year;
+    final yearValue = json['year'];
+    if (yearValue is int) {
+      year = yearValue;
+    } else if (yearValue is String) {
+      year = int.tryParse(yearValue);
+    }
+
     return Album(
       itemId: item.itemId,
       provider: item.provider,
@@ -169,6 +188,7 @@ class Album extends MediaItem {
           ?.map((e) => Artist.fromJson(e as Map<String, dynamic>))
           .toList(),
       albumType: json['album_type'] as String?,
+      year: year,
       sortName: item.sortName,
       uri: item.uri,
       providerMappings: item.providerMappings,
@@ -179,6 +199,28 @@ class Album extends MediaItem {
 
   String get artistsString =>
       artists?.map((a) => a.name).join(', ') ?? 'Unknown Artist';
+
+  /// Get album name with year appended (e.g., "Album Name (2023)")
+  String get nameWithYear {
+    return year != null ? '$name ($year)' : name;
+  }
+
+  /// Check if this album is in the user's library
+  bool get inLibrary {
+    if (provider == 'library') return true;
+    return providerMappings?.any((m) => m.providerInstance == 'library') ?? false;
+  }
+
+  @override
+  Map<String, dynamic> toJson() {
+    final json = super.toJson();
+    if (artists != null) {
+      json['artists'] = artists!.map((a) => a.toJson()).toList();
+    }
+    if (albumType != null) json['album_type'] = albumType;
+    if (year != null) json['year'] = year;
+    return json;
+  }
 }
 
 class Track extends MediaItem {
@@ -224,6 +266,16 @@ class Track extends MediaItem {
 
   String get artistsString =>
       artists?.map((a) => a.name).join(', ') ?? 'Unknown Artist';
+
+  @override
+  Map<String, dynamic> toJson() {
+    final json = super.toJson();
+    if (artists != null) {
+      json['artists'] = artists!.map((a) => a.toJson()).toList();
+    }
+    if (album != null) json['album'] = album!.toJson();
+    return json;
+  }
 }
 
 class Playlist extends MediaItem {
@@ -262,3 +314,363 @@ class Playlist extends MediaItem {
     );
   }
 }
+
+class Chapter {
+  final int chapterNumber;
+  final int positionMs;
+  final String title;
+  final Duration? duration;
+
+  Chapter({
+    required this.chapterNumber,
+    required this.positionMs,
+    required this.title,
+    this.duration,
+  });
+
+  factory Chapter.fromJson(Map<String, dynamic> json) {
+    // MA API returns chapters with format:
+    // {position: 1, name: "Opening Credits", start: 0.0, end: 17.6}
+    // We need to handle both this format and potential others
+
+    // Get chapter number (MA uses 'position' for chapter number)
+    int chapterNum = 0;
+    if (json['position'] is int) {
+      chapterNum = json['position'] as int;
+    } else if (json['chapter_number'] is int) {
+      chapterNum = json['chapter_number'] as int;
+    } else if (json['chapter_id'] is int) {
+      chapterNum = json['chapter_id'] as int;
+    }
+
+    // Get position in milliseconds (MA uses 'start' in seconds)
+    int posMs = 0;
+    if (json['start'] != null) {
+      // MA provides start time in seconds (can be double)
+      posMs = ((json['start'] as num) * 1000).toInt();
+    } else if (json['position_ms'] != null) {
+      posMs = json['position_ms'] as int;
+    }
+
+    // Get title (MA uses 'name')
+    String title = json['name'] as String? ??
+                   json['title'] as String? ??
+                   'Chapter $chapterNum';
+
+    // Calculate duration from start/end if available
+    Duration? dur;
+    if (json['start'] != null && json['end'] != null) {
+      final startSec = (json['start'] as num).toDouble();
+      final endSec = (json['end'] as num).toDouble();
+      dur = Duration(milliseconds: ((endSec - startSec) * 1000).toInt());
+    } else if (json['duration'] != null) {
+      dur = Duration(seconds: (json['duration'] as num).toInt());
+    }
+
+    return Chapter(
+      chapterNumber: chapterNum,
+      positionMs: posMs,
+      title: title,
+      duration: dur,
+    );
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      'chapter_number': chapterNumber,
+      'position_ms': positionMs,
+      'title': title,
+      if (duration != null) 'duration': duration!.inSeconds,
+    };
+  }
+}
+
+class Audiobook extends MediaItem {
+  final List<Artist>? authors;
+  final List<Artist>? narrators;
+  final String? publisher;
+  final String? description;
+  final int? year;
+  final List<Chapter>? chapters;
+  final int? resumePositionMs;
+  final bool? fullyPlayed;
+  /// Browse order from API - used as fallback for series sequencing
+  final int? browseOrder;
+
+  Audiobook({
+    required super.itemId,
+    required super.provider,
+    required super.name,
+    this.authors,
+    this.narrators,
+    this.publisher,
+    this.description,
+    this.year,
+    this.chapters,
+    this.resumePositionMs,
+    this.fullyPlayed,
+    this.browseOrder,
+    super.sortName,
+    super.uri,
+    super.providerMappings,
+    super.metadata,
+    super.favorite,
+    super.duration,
+  }) : super(mediaType: MediaType.audiobook);
+
+  factory Audiobook.fromJson(Map<String, dynamic> json) {
+    final item = MediaItem.fromJson(json);
+
+    // Parse year
+    int? year;
+    final yearValue = json['year'];
+    if (yearValue is int) {
+      year = yearValue;
+    } else if (yearValue is String) {
+      year = int.tryParse(yearValue);
+    }
+
+    // Helper to parse authors/narrators that can be either strings or Artist objects
+    List<Artist>? parseArtistList(dynamic data) {
+      if (data == null) return null;
+      if (data is! List) return null;
+
+      return data.map((e) {
+        if (e is String) {
+          // MA returns just the name as a string
+          return Artist(
+            itemId: '',
+            provider: 'library',
+            name: e,
+          );
+        } else if (e is Map<String, dynamic>) {
+          // Full Artist object
+          return Artist.fromJson(e);
+        }
+        return Artist(itemId: '', provider: 'library', name: 'Unknown');
+      }).toList();
+    }
+
+    // Parse chapters - check top level first, then metadata
+    List<Chapter>? chapters;
+    final metadata = json['metadata'] as Map<String, dynamic>?;
+
+    dynamic chaptersData = json['chapters'];
+    if (chaptersData == null && metadata != null) {
+      chaptersData = metadata['chapters'];
+    }
+
+    if (chaptersData is List && chaptersData.isNotEmpty) {
+      chapters = chaptersData
+          .map((e) => Chapter.fromJson(e as Map<String, dynamic>))
+          .toList();
+    }
+
+    // Parse description - check top level first, then metadata
+    String? description = json['description'] as String?;
+    if (description == null && metadata != null) {
+      description = metadata['description'] as String?;
+    }
+
+    return Audiobook(
+      itemId: item.itemId,
+      provider: item.provider,
+      name: item.name,
+      authors: parseArtistList(json['authors']),
+      narrators: parseArtistList(json['narrators']),
+      publisher: json['publisher'] as String?,
+      description: description,
+      year: year,
+      chapters: chapters,
+      resumePositionMs: json['resume_position_ms'] as int?,
+      fullyPlayed: json['fully_played'] as bool?,
+      browseOrder: json['_browse_order'] as int?,
+      sortName: item.sortName,
+      uri: item.uri,
+      providerMappings: item.providerMappings,
+      metadata: item.metadata,
+      favorite: item.favorite,
+      duration: item.duration,
+    );
+  }
+
+  String get authorsString =>
+      authors?.map((a) => a.name).join(', ') ?? 'Unknown Author';
+
+  String get narratorsString =>
+      narrators?.map((n) => n.name).join(', ') ?? 'Unknown Narrator';
+
+  /// Get progress as a percentage (0.0 to 1.0)
+  double get progress {
+    if (fullyPlayed == true) return 1.0;
+    if (resumePositionMs == null || duration == null) return 0.0;
+    final totalMs = duration!.inMilliseconds;
+    if (totalMs == 0) return 0.0;
+    return (resumePositionMs! / totalMs).clamp(0.0, 1.0);
+  }
+
+  /// Get series sequence number from metadata (for sorting within a series)
+  /// Tries various metadata fields commonly used by audiobook providers
+  double? get seriesSequence {
+    // First try the parent's position field (used by MA browse results)
+    if (position != null) return position!.toDouble();
+
+    // Try extracting number from sort_name (e.g., "01 - Book Title" or "Book 1")
+    if (sortName != null && sortName!.isNotEmpty) {
+      // Try to extract leading number
+      final match = RegExp(r'^(\d+)').firstMatch(sortName!);
+      if (match != null) {
+        return double.tryParse(match.group(1)!);
+      }
+      // Try to extract "Book N" pattern
+      final bookMatch = RegExp(r'[Bb]ook\s*(\d+)').firstMatch(sortName!);
+      if (bookMatch != null) {
+        return double.tryParse(bookMatch.group(1)!);
+      }
+    }
+
+    // Try extracting from the name itself
+    final nameMatch = RegExp(r'^(\d+)').firstMatch(name);
+    if (nameMatch != null) {
+      return double.tryParse(nameMatch.group(1)!);
+    }
+    final bookNameMatch = RegExp(r'[Bb]ook\s*(\d+)').firstMatch(name);
+    if (bookNameMatch != null) {
+      return double.tryParse(bookNameMatch.group(1)!);
+    }
+
+    if (metadata == null) return null;
+
+    // Try common metadata fields for series sequence
+    final seq = metadata!['sequence'] ??
+                metadata!['series_sequence'] ??
+                metadata!['series_number'] ??
+                metadata!['position'] ??
+                metadata!['sort_order'] ??
+                metadata!['order'];
+
+    if (seq is num) return seq.toDouble();
+    if (seq is String) return double.tryParse(seq);
+
+    // Check if there's a series object with sequence
+    final series = metadata!['series'];
+    if (series is Map) {
+      final seriesSeq = series['sequence'] ?? series['number'] ?? series['order'];
+      if (seriesSeq is num) return seriesSeq.toDouble();
+      if (seriesSeq is String) return double.tryParse(seriesSeq);
+    }
+    if (series is List && series.isNotEmpty) {
+      final first = series.first;
+      if (first is Map) {
+        final seriesSeq = first['sequence'] ?? first['number'] ?? first['order'];
+        if (seriesSeq is num) return seriesSeq.toDouble();
+        if (seriesSeq is String) return double.tryParse(seriesSeq);
+      }
+    }
+
+    // Last resort: use browse order from API (preserves MA/Audiobookshelf order)
+    if (browseOrder != null) return browseOrder!.toDouble();
+
+    return null;
+  }
+
+  @override
+  Map<String, dynamic> toJson() {
+    final json = super.toJson();
+    if (authors != null) {
+      json['authors'] = authors!.map((a) => a.toJson()).toList();
+    }
+    if (narrators != null) {
+      json['narrators'] = narrators!.map((n) => n.toJson()).toList();
+    }
+    if (publisher != null) json['publisher'] = publisher;
+    if (description != null) json['description'] = description;
+    if (year != null) json['year'] = year;
+    if (chapters != null) {
+      json['chapters'] = chapters!.map((c) => c.toJson()).toList();
+    }
+    if (resumePositionMs != null) json['resume_position_ms'] = resumePositionMs;
+    if (fullyPlayed != null) json['fully_played'] = fullyPlayed;
+    if (browseOrder != null) json['_browse_order'] = browseOrder;
+    return json;
+  }
+}
+
+/// Represents a browseable folder in Music Assistant (providers, series, authors, etc.)
+class BrowseFolder {
+  final String path;
+  final String name;
+  final String? label;
+  final String? thumbnailUrl;
+  final bool canExpand;
+  final List<MediaItem>? items;
+
+  BrowseFolder({
+    required this.path,
+    required this.name,
+    this.label,
+    this.thumbnailUrl,
+    this.canExpand = true,
+    this.items,
+  });
+
+  factory BrowseFolder.fromJson(Map<String, dynamic> json) {
+    // MA returns either a BrowseFolder or a MediaItem
+    // BrowseFolder has 'path' and 'name', MediaItem has 'item_id' and 'media_type'
+    return BrowseFolder(
+      path: json['path'] as String? ?? json['uri'] as String? ?? '',
+      name: json['name'] as String? ?? json['label'] as String? ?? 'Unknown',
+      label: json['label'] as String?,
+      thumbnailUrl: _extractThumbnail(json),
+      canExpand: json['can_expand'] as bool? ?? true,
+    );
+  }
+
+  static String? _extractThumbnail(Map<String, dynamic> json) {
+    // Check for image in metadata
+    final metadata = json['metadata'] as Map<String, dynamic>?;
+    if (metadata != null) {
+      final images = metadata['images'] as List<dynamic>?;
+      if (images != null && images.isNotEmpty) {
+        final first = images.first as Map<String, dynamic>;
+        return first['path'] as String?;
+      }
+    }
+    // Check for direct thumbnail
+    return json['thumbnail'] as String? ?? json['image'] as String?;
+  }
+}
+
+/// Represents an audiobook series
+class AudiobookSeries {
+  final String id;
+  final String name;
+  final String? thumbnailUrl;
+  final List<Audiobook>? books;
+  final int? bookCount;
+
+  AudiobookSeries({
+    required this.id,
+    required this.name,
+    this.thumbnailUrl,
+    this.books,
+    this.bookCount,
+  });
+
+  factory AudiobookSeries.fromBrowseFolder(BrowseFolder folder) {
+    return AudiobookSeries(
+      id: folder.path,
+      name: folder.name,
+      thumbnailUrl: folder.thumbnailUrl,
+    );
+  }
+
+  factory AudiobookSeries.fromJson(Map<String, dynamic> json) {
+    return AudiobookSeries(
+      id: json['path'] as String? ?? json['id'] as String? ?? '',
+      name: json['name'] as String? ?? json['label'] as String? ?? 'Unknown Series',
+      thumbnailUrl: BrowseFolder._extractThumbnail(json),
+      bookCount: json['book_count'] as int?,
+    );
+  }
+}

lib/models/player.dart

@@ -12,6 +12,11 @@ class Player {
   final bool? volumeMuted;
   final double? elapsedTime; // Seconds elapsed in current track
   final double? elapsedTimeLastUpdated; // Unix timestamp when elapsed_time was last updated
+  final List<String>? groupMembers; // List of player IDs in sync group (includes self)
+  final String? syncedTo; // Player ID this player is synced to (null if leader or not synced)
+  final String? activeSource; // The currently active source for this player
+  final bool isExternalSource; // True when an external source (optical, Spotify, etc.) is active
+  final String? appId; // The app_id from MA - 'music_assistant' when MA is playing, else external source
 
   Player({
     required this.playerId,
@@ -25,6 +30,11 @@ class Player {
     this.volumeMuted,
     this.elapsedTime,
     this.elapsedTimeLastUpdated,
+    this.groupMembers,
+    this.syncedTo,
+    this.activeSource,
+    this.isExternalSource = false,
+    this.appId,
   });
 
   /// Create a copy of this Player with some fields replaced
@@ -40,6 +50,11 @@ class Player {
     bool? volumeMuted,
     double? elapsedTime,
     double? elapsedTimeLastUpdated,
+    List<String>? groupMembers,
+    String? syncedTo,
+    String? activeSource,
+    bool? isExternalSource,
+    String? appId,
   }) {
     return Player(
       playerId: playerId ?? this.playerId,
@@ -53,6 +68,11 @@ class Player {
       volumeMuted: volumeMuted ?? this.volumeMuted,
       elapsedTime: elapsedTime ?? this.elapsedTime,
       elapsedTimeLastUpdated: elapsedTimeLastUpdated ?? this.elapsedTimeLastUpdated,
+      groupMembers: groupMembers ?? this.groupMembers,
+      syncedTo: syncedTo ?? this.syncedTo,
+      activeSource: activeSource ?? this.activeSource,
+      isExternalSource: isExternalSource ?? this.isExternalSource,
+      appId: appId ?? this.appId,
     );
   }
 
@@ -61,8 +81,37 @@ class Player {
   bool get isMuted => volumeMuted ?? false;
   int get volume => volumeLevel ?? 0;
 
+  // Group properties
+  // A player is grouped if it's a leader with members OR a child synced to another
+  bool get isGrouped => (groupMembers != null && groupMembers!.length > 1) || syncedTo != null;
+  bool get isGroupLeader => groupMembers != null && groupMembers!.length > 1 && syncedTo == null;
+  bool get isGroupChild => syncedTo != null;
+
+  // A player is manually synced if it's synced TO another player (child of a sync group)
+  // This excludes pre-configured MA speaker groups which have groupMembers but no syncedTo
+  // Used for yellow border highlight - only shows for players the user manually synced
+  bool get isManuallySynced => syncedTo != null;
+
   // Track when this Player object was created (for local interpolation fallback)
   static final Map<String, double> _playerCreationTimes = {};
+  static const int _maxCreationTimesEntries = 50;
+
+  /// Clean up old creation time entries using LRU eviction
+  static void _cleanupCreationTimes() {
+    if (_playerCreationTimes.length <= _maxCreationTimesEntries) return;
+
+    // Sort by timestamp value (oldest first) for true LRU eviction
+    final sortedEntries = _playerCreationTimes.entries.toList()
+      ..sort((a, b) => a.value.compareTo(b.value));
+
+    // Remove oldest entries until we're at target size
+    final entriesToRemove = sortedEntries.take(
+      _playerCreationTimes.length - _maxCreationTimesEntries,
+    );
+    for (final entry in entriesToRemove) {
+      _playerCreationTimes.remove(entry.key);
+    }
+  }
 
   // Calculate current elapsed time (interpolated if playing)
   double get currentElapsedTime {
@@ -104,13 +153,8 @@ class Player {
     if (!_playerCreationTimes.containsKey(creationKey)) {
       // First time seeing this elapsed_time - record when we saw it
       _playerCreationTimes[creationKey] = now;
-      // Clean up old entries to prevent memory leak
-      if (_playerCreationTimes.length > 100) {
-        final keysToRemove = _playerCreationTimes.keys.take(50).toList();
-        for (final key in keysToRemove) {
-          _playerCreationTimes.remove(key);
-        }
-      }
+      // Clean up old entries to prevent memory leak (LRU eviction)
+      _cleanupCreationTimes();
     }
 
     final creationTime = _playerCreationTimes[creationKey]!;
@@ -164,6 +208,68 @@ class Player {
     elapsedTime ??= topLevelElapsedTime;
     elapsedTimeLastUpdated ??= topLevelLastUpdated;
 
+    // Parse group members - MA returns this as a list of player IDs
+    final groupMembersList = json['group_members'] as List<dynamic>?;
+    final groupMembers = groupMembersList?.map((e) => e.toString()).toList();
+
+    // Parse synced_to - the player ID this player is synced to
+    final syncedTo = json['synced_to'] as String?;
+
+    // Parse active_source - the currently active source for this player
+    final activeSource = json['active_source'] as String?;
+
+    // Detect external source (optical, Spotify, AirPlay, etc.)
+    // Primary indicator: app_id - if not 'music_assistant', it's an external source
+    // Secondary indicators: URI patterns and media_type
+    bool isExternalSource = false;
+
+    // Check app_id first - this is the most reliable indicator for DLNA players
+    // When MA is playing: app_id = 'music_assistant'
+    // When external source: app_id = 'http', 'spotify', etc.
+    final appId = json['app_id'] as String?;
+    if (appId != null && appId.isNotEmpty && appId != 'music_assistant') {
+      // app_id is set but not 'music_assistant' - external source is active
+      isExternalSource = true;
+    }
+
+    // Also check current_media for additional external source indicators
+    if (!isExternalSource && json.containsKey('current_media')) {
+      final currentMedia = json['current_media'] as Map<String, dynamic>?;
+      if (currentMedia != null) {
+        final uri = currentMedia['uri'] as String?;
+        final mediaType = currentMedia['media_type'] as String?;
+
+        // External source indicators:
+        // 1. URI is a simple identifier like 'optical', 'line_in', 'bluetooth', 'hdmi'
+        // 2. URI starts with external protocols: 'spotify://', 'airplay://', etc.
+        // 3. Media type is 'unknown' (MA doesn't recognize the source)
+        if (uri != null) {
+          final uriLower = uri.toLowerCase();
+          // Simple external source identifiers (no :// or /)
+          final isSimpleExternalId = !uri.contains('://') && !uri.contains('/') &&
+              (uriLower == 'optical' || uriLower == 'line_in' || uriLower == 'bluetooth' ||
+               uriLower == 'hdmi' || uriLower == 'tv' || uriLower == 'aux' ||
+               uriLower == 'coaxial' || uriLower == 'toslink');
+          // External streaming protocols
+          final isExternalProtocol = uriLower.startsWith('spotify://') ||
+              uriLower.startsWith('airplay://') ||
+              uriLower.startsWith('cast://') ||
+              uriLower.startsWith('bluetooth://');
+
+          isExternalSource = isSimpleExternalId || isExternalProtocol;
+        }
+
+        // Also check media_type - 'unknown' often indicates external source
+        if (!isExternalSource && mediaType == 'unknown') {
+          // If media_type is unknown and URI doesn't look like MA content, it's external
+          final uri = currentMedia['uri'] as String?;
+          if (uri != null && !uri.startsWith('library://') && !uri.contains('://track/')) {
+            isExternalSource = true;
+          }
+        }
+      }
+    }
+
     return Player(
       playerId: json['player_id'] as String,
       name: json['name'] as String,
@@ -176,6 +282,11 @@ class Player {
       volumeMuted: json['volume_muted'] as bool?,
       elapsedTime: elapsedTime,
       elapsedTimeLastUpdated: elapsedTimeLastUpdated,
+      groupMembers: groupMembers,
+      syncedTo: syncedTo,
+      activeSource: activeSource,
+      isExternalSource: isExternalSource,
+      appId: appId,
     );
   }
 
@@ -192,6 +303,11 @@ class Player {
       if (volumeMuted != null) 'volume_muted': volumeMuted,
       if (elapsedTime != null) 'elapsed_time': elapsedTime,
       if (elapsedTimeLastUpdated != null) 'elapsed_time_last_updated': elapsedTimeLastUpdated,
+      if (groupMembers != null) 'group_members': groupMembers,
+      if (syncedTo != null) 'synced_to': syncedTo,
+      if (activeSource != null) 'active_source': activeSource,
+      'is_external_source': isExternalSource,
+      if (appId != null) 'app_id': appId,
     };
   }
 }

lib/providers/connection_provider.dart

@@ -2,6 +2,8 @@ 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';
@@ -109,7 +111,7 @@ class ConnectionProvider with ChangeNotifier {
     }
   }
 
-  /// Fetch user profile from MA and set owner name
+  /// Fetch user profile from MA and set owner name + create/activate local profile
   Future<void> _fetchAndSetUserProfileName() async {
     if (_api == null) return;
 
@@ -132,6 +134,15 @@ class ConnectionProvider with ChangeNotifier {
       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');
       }
@@ -178,7 +189,9 @@ class ConnectionProvider with ChangeNotifier {
             _logger.log('✅ MA authentication successful');
             onAuthenticated?.call();
           } else if (state == MAConnectionState.disconnected) {
-            _cacheService.clearAll();
+            // 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();
           }
         },
@@ -204,6 +217,12 @@ class ConnectionProvider with ChangeNotifier {
   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();
   }

lib/providers/library_provider.dart

@@ -4,6 +4,7 @@ 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)
@@ -138,8 +139,12 @@ class LibraryProvider with ChangeNotifier {
       _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),
+        _api!.getArtists(limit: LibraryConstants.maxLibraryItems, albumArtistsOnly: showOnlyArtistsWithAlbums),
         _api!.getAlbums(limit: LibraryConstants.maxLibraryItems),
         _api!.getTracks(limit: LibraryConstants.maxLibraryItems),
       ]);
@@ -166,10 +171,14 @@ class LibraryProvider with ChangeNotifier {
       _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;

lib/providers/locale_provider.dart

@@ -0,0 +1,40 @@
+import 'package:flutter/material.dart';
+import '../services/settings_service.dart';
+
+class LocaleProvider extends ChangeNotifier {
+  Locale? _locale; // null = system default
+
+  LocaleProvider() {
+    _loadLocale();
+  }
+
+  Locale? get locale => _locale;
+
+  Future<void> _loadLocale() async {
+    final savedLocale = await SettingsService.getLocale();
+    if (savedLocale != null) {
+      _locale = Locale(savedLocale);
+    }
+    notifyListeners();
+  }
+
+  Future<void> setLocale(Locale? locale) async {
+    _locale = locale;
+    await SettingsService.saveLocale(locale?.languageCode);
+    notifyListeners();
+  }
+
+  /// Returns the display name for a locale
+  static String getDisplayName(String? languageCode, BuildContext context) {
+    switch (languageCode) {
+      case 'en':
+        return 'English';
+      case 'de':
+        return 'Deutsch';
+      case null:
+        return 'System';
+      default:
+        return languageCode;
+    }
+  }
+}

lib/providers/player_provider.dart

@@ -506,7 +506,15 @@ class PlayerProvider with ChangeNotifier {
           return false;
         }
 
-        if (nameLower == 'this device' || player.playerId.startsWith('ma_')) {
+        // 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;
         }
@@ -551,28 +559,28 @@ class PlayerProvider with ChangeNotifier {
         if (playerToSelect == null) {
           final lastSelectedPlayerId = await SettingsService.getLastSelectedPlayerId();
 
+          // Priority 1: Last selected player
           if (lastSelectedPlayerId != null) {
-            try {
-              playerToSelect = _availablePlayers.firstWhere(
-                (p) => p.playerId == lastSelectedPlayerId && p.available,
-              );
-            } catch (e) {}
+            playerToSelect = _availablePlayers.cast<Player?>().firstWhere(
+              (p) => p!.playerId == lastSelectedPlayerId && p.available,
+              orElse: () => null,
+            );
           }
 
+          // Priority 2: Built-in (local) player
           if (playerToSelect == null && builtinPlayerId != null) {
-            try {
-              playerToSelect = _availablePlayers.firstWhere(
-                (p) => p.playerId == builtinPlayerId && p.available,
-              );
-            } catch (e) {}
+            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) {
-            try {
-              playerToSelect = _availablePlayers.firstWhere(
-                (p) => p.state == 'playing' && p.available,
-              );
-            } catch (e) {}
+            playerToSelect = _availablePlayers.cast<Player?>().firstWhere(
+              (p) => p!.state == 'playing' && p.available && !p.isExternalSource,
+              orElse: () => null,
+            );
           }
 
           if (playerToSelect == null) {
@@ -898,10 +906,10 @@ class PlayerProvider with ChangeNotifier {
     }
   }
 
-  Future<void> toggleShuffle(String queueId) async {
+  Future<void> toggleShuffle(String queueId, bool shuffleEnabled) async {
     if (_api == null) return;
     try {
-      await _api!.toggleShuffle(queueId);
+      await _api!.toggleShuffle(queueId, shuffleEnabled);
     } catch (e) {
       ErrorHandler.logError('Toggle shuffle', e);
       rethrow;

lib/screens/album_details_screen.dart

@@ -8,17 +8,23 @@ import '../theme/palette_helper.dart';
 import '../theme/theme_provider.dart';
 import '../services/metadata_service.dart';
 import '../services/debug_logger.dart';
+import '../services/recently_played_service.dart';
 import '../widgets/global_player_overlay.dart';
+import '../widgets/player_picker_sheet.dart';
+import '../l10n/app_localizations.dart';
 import 'artist_details_screen.dart';
 
 class AlbumDetailsScreen extends StatefulWidget {
   final Album album;
   final String? heroTagSuffix;
+  /// Initial image URL from the source (e.g., AlbumCard) for seamless hero animation
+  final String? initialImageUrl;
 
   const AlbumDetailsScreen({
-    super.key, 
+    super.key,
     required this.album,
     this.heroTagSuffix,
+    this.initialImageUrl,
   });
 
   @override
@@ -30,43 +36,51 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
   List<Track> _tracks = [];
   bool _isLoading = true;
   bool _isFavorite = false;
+  bool _isInLibrary = false;
   ColorScheme? _lightColorScheme;
   ColorScheme? _darkColorScheme;
   int? _expandedTrackIndex;
   bool _isDescriptionExpanded = false;
   String? _albumDescription;
-  
+  Album? _freshAlbum; // Full album data with image metadata
+
+  /// Get the best album data available (fresh with images, or widget.album as fallback)
+  Album get _displayAlbum => _freshAlbum ?? widget.album;
+
   String get _heroTagSuffix => widget.heroTagSuffix != null ? '_${widget.heroTagSuffix}' : '';
 
   @override
   void initState() {
     super.initState();
     _isFavorite = widget.album.favorite ?? false;
+    _isInLibrary = widget.album.inLibrary;
     _loadTracks();
     _loadAlbumDescription();
-    _refreshFavoriteStatus();
 
-    // CRITICAL FIX: Defer color extraction until after the transition completes
-    // This prevents expensive palette extraction during hero animation
-    // Wait for the first frame to be painted, then extract colors
+    // CRITICAL FIX: Defer both fresh data loading AND color extraction until
+    // after the hero animation completes. This prevents:
+    // 1. setState with new image URL during animation → grey icon flash
+    // 2. Expensive palette extraction blocking animation frames
     WidgetsBinding.instance.addPostFrameCallback((_) {
-      // Add small delay to ensure transition is complete
+      // 350ms matches FadeSlidePageRoute duration (300ms) + buffer
       Future.delayed(const Duration(milliseconds: 350), () {
         if (mounted) {
+          _loadFreshAlbumData();
           _extractColors();
         }
       });
     });
   }
 
-  Future<void> _refreshFavoriteStatus() async {
+  /// Load fresh album data from API to get full metadata including images
+  Future<void> _loadFreshAlbumData() async {
     final maProvider = context.read<MusicAssistantProvider>();
     if (maProvider.api == null) return;
 
     // Need a URI to fetch fresh album data
     final albumUri = widget.album.uri;
     if (albumUri == null || albumUri.isEmpty) {
-      _logger.log('Cannot refresh favorite status: album has no URI');
+      _logger.log('Cannot load fresh album: album has no URI');
       return;
     }
 
@@ -74,17 +88,20 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
       final freshAlbum = await maProvider.api!.getAlbumByUri(albumUri);
       if (freshAlbum != null && mounted) {
         setState(() {
+          _freshAlbum = freshAlbum;
           _isFavorite = freshAlbum.favorite ?? false;
         });
+        // Re-extract colors now that we have fresh album with images
+        _extractColors();
       }
     } catch (e) {
-      _logger.log('Error refreshing favorite status: $e');
+      _logger.log('Error loading fresh album data: $e');
     }
   }
 
   Future<void> _extractColors() async {
     final maProvider = context.read<MusicAssistantProvider>();
-    final imageUrl = maProvider.getImageUrl(widget.album, size: 512);
+    final imageUrl = maProvider.getImageUrl(_displayAlbum, size: 512);
 
     if (imageUrl == null) return;
 
@@ -106,10 +123,10 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
 
   Future<void> _toggleFavorite() async {
     final maProvider = context.read<MusicAssistantProvider>();
-    if (maProvider.api == null) return;
 
     try {
       final newState = !_isFavorite;
+      bool success;
 
       if (newState) {
         // For adding: use the actual provider and itemId from provider_mappings
@@ -125,22 +142,24 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
               orElse: () => widget.album.providerMappings!.first,
             ),
           );
-          actualProvider = mapping.providerInstance;
+          // Use providerDomain (e.g., "spotify") not providerInstance (e.g., "spotify--xyz")
+          actualProvider = mapping.providerDomain;
           actualItemId = mapping.itemId;
         }
 
         _logger.log('Adding to favorites: provider=$actualProvider, itemId=$actualItemId');
-        await maProvider.api!.addToFavorites('album', actualItemId, actualProvider);
+        success = await maProvider.addToFavorites(
+          mediaType: 'album',
+          itemId: actualItemId,
+          provider: actualProvider,
+        );
       } else {
         // For removing: need the library_item_id (numeric)
-        // When provider is "library", itemId is the library ID as a string
-        // Otherwise, we need to find it from provider_mappings
         int? libraryItemId;
 
         if (widget.album.provider == 'library') {
           libraryItemId = int.tryParse(widget.album.itemId);
         } else if (widget.album.providerMappings != null) {
-          // Find the library mapping
           final libraryMapping = widget.album.providerMappings!.firstWhere(
             (m) => m.providerInstance == 'library',
             orElse: () => widget.album.providerMappings!.first,
@@ -155,33 +174,139 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
           throw Exception('Could not determine library ID for this album');
         }
 
-        _logger.log('Removing from favorites: libraryItemId=$libraryItemId');
-        await maProvider.api!.removeFromFavorites('album', libraryItemId);
+        success = await maProvider.removeFromFavorites(
+          mediaType: 'album',
+          libraryItemId: libraryItemId,
+        );
       }
 
-      setState(() {
-        _isFavorite = newState;
-      });
+      if (success) {
+        // Optimistically update UI regardless of online/offline state
+        setState(() {
+          _isFavorite = newState;
+        });
 
-      // Invalidate home cache so the home screen shows updated favorite status
-      maProvider.invalidateHomeCache();
+        // Invalidate home cache so the home screen shows updated favorite status
+        maProvider.invalidateHomeCache();
 
-      if (mounted) {
-        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(
-            content: Text(
-              _isFavorite ? 'Added to favorites' : 'Removed from favorites',
+        if (mounted) {
+          final isOffline = !maProvider.isConnected;
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text(
+                isOffline
+                    ? S.of(context)!.actionQueuedForSync
+                    : (_isFavorite ? S.of(context)!.addedToFavorites : S.of(context)!.removedFromFavorites),
+              ),
+              duration: const Duration(seconds: 1),
             ),
-            duration: const Duration(seconds: 1),
-          ),
-        );
+          );
+        }
       }
     } catch (e) {
       _logger.log('Error toggling favorite: $e');
       if (mounted) {
         ScaffoldMessenger.of(context).showSnackBar(
           SnackBar(
-            content: Text('Failed to update favorite: $e'),
+            content: Text(S.of(context)!.failedToUpdateFavorite(e.toString())),
+            duration: const Duration(seconds: 2),
+          ),
+        );
+      }
+    }
+  }
+
+  /// Toggle library status
+  Future<void> _toggleLibrary() async {
+    final maProvider = context.read<MusicAssistantProvider>();
+
+    try {
+      final newState = !_isInLibrary;
+      bool success;
+
+      if (newState) {
+        // Add to library - MUST use non-library provider
+        String? actualProvider;
+        String? actualItemId;
+
+        if (widget.album.providerMappings != null && widget.album.providerMappings!.isNotEmpty) {
+          // For adding to library, we MUST use a non-library provider
+          final nonLibraryMapping = widget.album.providerMappings!.where(
+            (m) => m.providerInstance != 'library' && m.providerDomain != 'library',
+          ).firstOrNull;
+
+          if (nonLibraryMapping != null) {
+            actualProvider = nonLibraryMapping.providerDomain;
+            actualItemId = nonLibraryMapping.itemId;
+          }
+        }
+
+        // Fallback to item's own provider if no non-library mapping found
+        if (actualProvider == null || actualItemId == null) {
+          if (widget.album.provider != 'library') {
+            actualProvider = widget.album.provider;
+            actualItemId = widget.album.itemId;
+          } else {
+            // Item is library-only, can't add
+            _logger.log('Cannot add to library: album is library-only');
+            return;
+          }
+        }
+
+        _logger.log('Adding album to library: provider=$actualProvider, itemId=$actualItemId');
+        success = await maProvider.addToLibrary(
+          mediaType: 'album',
+          provider: actualProvider,
+          itemId: actualItemId,
+        );
+      } else {
+        // Remove from library
+        int? libraryItemId;
+        if (widget.album.provider == 'library') {
+          libraryItemId = int.tryParse(widget.album.itemId);
+        } else if (widget.album.providerMappings != null) {
+          final libraryMapping = widget.album.providerMappings!.firstWhere(
+            (m) => m.providerInstance == 'library',
+            orElse: () => widget.album.providerMappings!.first,
+          );
+          if (libraryMapping.providerInstance == 'library') {
+            libraryItemId = int.tryParse(libraryMapping.itemId);
+          }
+        }
+
+        if (libraryItemId == null) {
+          _logger.log('Cannot remove from library: no library ID found');
+          return;
+        }
+
+        success = await maProvider.removeFromLibrary(
+          mediaType: 'album',
+          libraryItemId: libraryItemId,
+        );
+      }
+
+      if (success) {
+        setState(() {
+          _isInLibrary = newState;
+        });
+
+        if (mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text(
+                _isInLibrary ? S.of(context)!.addedToLibrary : S.of(context)!.removedFromLibrary,
+              ),
+              duration: const Duration(seconds: 1),
+            ),
+          );
+        }
+      }
+    } catch (e) {
+      _logger.log('Error toggling album library: $e');
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text('Failed to update library: $e'),
             duration: const Duration(seconds: 2),
           ),
         );
@@ -194,11 +319,11 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
 
     final track = _tracks[trackIndex];
     final maProvider = context.read<MusicAssistantProvider>();
-    if (maProvider.api == null) return;
-
     final currentFavorite = track.favorite ?? false;
 
     try {
+      bool success;
+
       if (currentFavorite) {
         // Remove from favorites - need library_item_id
         int? libraryItemId;
@@ -215,7 +340,12 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
         }
 
         if (libraryItemId != null) {
-          await maProvider.api!.removeFromFavorites('track', libraryItemId);
+          success = await maProvider.removeFromFavorites(
+            mediaType: 'track',
+            libraryItemId: libraryItemId,
+          );
+        } else {
+          success = false;
         }
       } else {
         // Add to favorites
@@ -230,44 +360,54 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
               orElse: () => track.providerMappings!.first,
             ),
           );
-          actualProvider = mapping.providerInstance;
+          // Use providerDomain (e.g., "spotify") not providerInstance (e.g., "spotify--xyz")
+          actualProvider = mapping.providerDomain;
           actualItemId = mapping.itemId;
         }
 
-        await maProvider.api!.addToFavorites('track', actualItemId, actualProvider);
+        success = await maProvider.addToFavorites(
+          mediaType: 'track',
+          itemId: actualItemId,
+          provider: actualProvider,
+        );
       }
 
-      // Update local state - create new track with toggled favorite
-      setState(() {
-        _tracks[trackIndex] = Track(
-          itemId: track.itemId,
-          provider: track.provider,
-          name: track.name,
-          uri: track.uri,
-          favorite: !currentFavorite,
-          artists: track.artists,
-          album: track.album,
-          duration: track.duration,
-          providerMappings: track.providerMappings,
-        );
-      });
+      if (success) {
+        // Optimistically update local state
+        setState(() {
+          _tracks[trackIndex] = Track(
+            itemId: track.itemId,
+            provider: track.provider,
+            name: track.name,
+            uri: track.uri,
+            favorite: !currentFavorite,
+            artists: track.artists,
+            album: track.album,
+            duration: track.duration,
+            providerMappings: track.providerMappings,
+          );
+        });
 
-      if (mounted) {
-        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(
-            content: Text(
-              !currentFavorite ? 'Added to favorites' : 'Removed from favorites',
+        if (mounted) {
+          final isOffline = !maProvider.isConnected;
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text(
+                isOffline
+                    ? S.of(context)!.actionQueuedForSync
+                    : (!currentFavorite ? S.of(context)!.addedToFavorites : S.of(context)!.removedFromFavorites),
+              ),
+              duration: const Duration(seconds: 1),
             ),
-            duration: const Duration(seconds: 1),
-          ),
-        );
+          );
+        }
       }
     } catch (e) {
       _logger.log('Error toggling track favorite: $e');
       if (mounted) {
         ScaffoldMessenger.of(context).showSnackBar(
           SnackBar(
-            content: Text('Failed to update favorite: $e'),
+            content: Text(S.of(context)!.failedToUpdateFavorite(e.toString())),
             duration: const Duration(seconds: 2),
           ),
         );
@@ -277,16 +417,46 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
 
   Future<void> _loadTracks() async {
     final provider = context.read<MusicAssistantProvider>();
-    final tracks = await provider.getAlbumTracksWithCache(
-      widget.album.provider,
-      widget.album.itemId,
-    );
+    final cacheKey = '${widget.album.provider}_${widget.album.itemId}';
 
-    if (mounted) {
-      setState(() {
-        _tracks = tracks;
-        _isLoading = false;
-      });
+    // 1. Show cached data immediately (if available)
+    final cachedTracks = provider.getCachedAlbumTracks(cacheKey);
+    if (cachedTracks != null && cachedTracks.isNotEmpty) {
+      if (mounted) {
+        setState(() {
+          _tracks = cachedTracks;
+          _isLoading = false;
+        });
+      }
+    }
+
+    // 2. Fetch fresh data in background (silent refresh)
+    try {
+      final freshTracks = await provider.getAlbumTracksWithCache(
+        widget.album.provider,
+        widget.album.itemId,
+        forceRefresh: cachedTracks != null, // Force refresh if we had cache
+      );
+
+      // 3. Update if we got different data
+      if (mounted && freshTracks.isNotEmpty) {
+        final tracksChanged = _tracks.length != freshTracks.length ||
+            (_tracks.isNotEmpty && freshTracks.isNotEmpty &&
+             _tracks.first.itemId != freshTracks.first.itemId);
+        if (tracksChanged || _tracks.isEmpty) {
+          setState(() {
+            _tracks = freshTracks;
+            _isLoading = false;
+          });
+        }
+      }
+    } catch (e) {
+      _logger.log('⚠️ Background refresh failed: $e');
+    }
+
+    // Ensure loading is false even if everything failed
+    if (mounted && _isLoading) {
+      setState(() => _isLoading = false);
     }
   }
 
@@ -299,7 +469,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
       // Use the selected player
       final player = maProvider.selectedPlayer;
       if (player == null) {
-        _showError('No player selected');
+        _showError(S.of(context)!.noPlayerSelected);
         return;
       }
 
@@ -308,6 +478,9 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
       // Queue all tracks via Music Assistant
       await maProvider.playTracks(player.playerId, _tracks, startIndex: 0);
       _logger.log('Album queued on ${player.name}');
+
+      // Record to local recently played (per-profile)
+      RecentlyPlayedService.instance.recordAlbumPlayed(widget.album);
       // Stay on album page - mini player will appear
     } catch (e) {
       _logger.log('Error playing album: $e');
@@ -322,7 +495,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
       // Use the selected player
       final player = maProvider.selectedPlayer;
       if (player == null) {
-        _showError('No player selected');
+        _showError(S.of(context)!.noPlayerSelected);
         return;
       }
 
@@ -358,14 +531,14 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
           children: [
             const SizedBox(height: 16),
             Text(
-              'Add album to queue on...',
+              S.of(context)!.addAlbumToQueueOn,
               style: Theme.of(context).textTheme.titleLarge,
             ),
             const SizedBox(height: 16),
             if (players.isEmpty)
-              const Padding(
-                padding: EdgeInsets.all(32.0),
-                child: Text('No players available'),
+              Padding(
+                padding: const EdgeInsets.all(32.0),
+                child: Text(S.of(context)!.noPlayersAvailable),
               )
             else
               Flexible(
@@ -393,9 +566,9 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                           _logger.log('Album added to queue on ${player.name}');
                           if (mounted) {
                             ScaffoldMessenger.of(context).showSnackBar(
-                              const SnackBar(
-                                content: Text('Album added to queue'),
-                                duration: Duration(seconds: 1),
+                              SnackBar(
+                                content: Text(S.of(context)!.albumAddedToQueue),
+                                duration: const Duration(seconds: 1),
                               ),
                             );
                           }
@@ -438,14 +611,14 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
           children: [
             const SizedBox(height: 16),
             Text(
-              'Add to queue on...',
+              S.of(context)!.addToQueueOn,
               style: Theme.of(context).textTheme.titleLarge,
             ),
             const SizedBox(height: 16),
             if (players.isEmpty)
-              const Padding(
-                padding: EdgeInsets.all(32.0),
-                child: Text('No players available'),
+              Padding(
+                padding: const EdgeInsets.all(32.0),
+                child: Text(S.of(context)!.noPlayersAvailable),
               )
             else
               Flexible(
@@ -472,9 +645,9 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                           );
                           if (mounted) {
                             ScaffoldMessenger.of(context).showSnackBar(
-                              const SnackBar(
-                                content: Text('Tracks added to queue'),
-                                duration: Duration(seconds: 1),
+                              SnackBar(
+                                content: Text(S.of(context)!.tracksAddedToQueue),
+                                duration: const Duration(seconds: 1),
                               ),
                             );
                           }
@@ -487,7 +660,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                   },
                 ),
               ),
-            const SizedBox(height: 16),
+            SizedBox(height: MediaQuery.of(context).padding.bottom + 16),
           ],
         ),
       ),
@@ -590,9 +763,12 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
   Widget build(BuildContext context) {
     // CRITICAL FIX: Use select() instead of watch() to reduce rebuilds
     // Only rebuild when specific properties change, not on every provider update
-    final imageUrl = context.select<MusicAssistantProvider, String?>(
-      (provider) => provider.getImageUrl(widget.album, size: 512),
+    // Use _displayAlbum which has fresh data with images if available
+    final providerImageUrl = context.select<MusicAssistantProvider, String?>(
+      (provider) => provider.getImageUrl(_displayAlbum, size: 512),
     );
+    // Use initialImageUrl as fallback for seamless hero animation
+    final imageUrl = providerImageUrl ?? widget.initialImageUrl;
     final adaptiveTheme = context.select<ThemeProvider, bool>(
       (provider) => provider.adaptiveTheme,
     );
@@ -629,10 +805,16 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
       },
       child: Scaffold(
         backgroundColor: colorScheme.background,
-        body: CustomScrollView(
+        body: LayoutBuilder(
+          builder: (context, constraints) {
+            // Responsive cover size: 70% of screen width, clamped between 200-320
+            final coverSize = (constraints.maxWidth * 0.7).clamp(200.0, 320.0);
+            final expandedHeight = coverSize + 70;
+
+            return CustomScrollView(
         slivers: [
           SliverAppBar(
-            expandedHeight: 350, // Increased height for bigger art
+            expandedHeight: expandedHeight,
             pinned: true,
             backgroundColor: colorScheme.background,
             leading: IconButton(
@@ -650,35 +832,50 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                   const SizedBox(height: 60),
                   GestureDetector(
                     onTap: () => _showFullscreenArt(imageUrl),
-                    child: Hero(
-                      tag: HeroTags.albumCover + (widget.album.uri ?? widget.album.itemId) + _heroTagSuffix,
-                      child: Container(
-                        width: 280, // Increased size
-                        height: 280,
-                        decoration: BoxDecoration(
-                          color: colorScheme.surfaceVariant,
-                          borderRadius: BorderRadius.circular(16), // Slightly more rounded
-                          boxShadow: [
-                            BoxShadow(
-                              color: Colors.black.withOpacity(0.3),
-                              blurRadius: 20,
-                              offset: const Offset(0, 10),
-                            ),
-                          ],
-                          image: imageUrl != null
-                              ? DecorationImage(
-                                  image: CachedNetworkImageProvider(imageUrl),
-                                  fit: BoxFit.cover,
-                                )
-                              : null,
+                    // Shadow container (outside Hero for correct clipping)
+                    child: Container(
+                      decoration: BoxDecoration(
+                        borderRadius: BorderRadius.circular(12),
+                        boxShadow: [
+                          BoxShadow(
+                            color: Colors.black.withOpacity(0.3),
+                            blurRadius: 20,
+                            offset: const Offset(0, 10),
+                          ),
+                        ],
+                      ),
+                      child: Hero(
+                        tag: HeroTags.albumCover + (widget.album.uri ?? widget.album.itemId) + _heroTagSuffix,
+                        // FIXED: Match source structure - ClipRRect(12) → Container → CachedNetworkImage
+                        child: ClipRRect(
+                          borderRadius: BorderRadius.circular(12),
+                          child: Container(
+                            width: coverSize,
+                            height: coverSize,
+                            color: colorScheme.surfaceVariant,
+                            child: imageUrl != null
+                                ? CachedNetworkImage(
+                                    imageUrl: imageUrl,
+                                    fit: BoxFit.cover,
+                                    // Match source memCacheWidth for smooth Hero
+                                    memCacheWidth: 256,
+                                    memCacheHeight: 256,
+                                    fadeInDuration: Duration.zero,
+                                    fadeOutDuration: Duration.zero,
+                                    placeholder: (_, __) => const SizedBox(),
+                                    errorWidget: (_, __, ___) => Icon(
+                                      Icons.album_rounded,
+                                      size: coverSize * 0.43,
+                                      color: colorScheme.onSurfaceVariant,
+                                    ),
+                                  )
+                                : Icon(
+                                    Icons.album_rounded,
+                                    size: coverSize * 0.43,
+                                    color: colorScheme.onSurfaceVariant,
+                                  ),
+                          ),
                         ),
-                        child: imageUrl == null
-                            ? Icon(
-                                Icons.album_rounded,
-                                size: 120,
-                                color: colorScheme.onSurfaceVariant,
-                              )
-                            : null,
                       ),
                     ),
                   ),
@@ -688,7 +885,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
           ),
           SliverToBoxAdapter(
             child: Padding(
-              padding: const EdgeInsets.all(24.0),
+              padding: const EdgeInsets.fromLTRB(24.0, 24.0, 24.0, 12.0),
               child: Column(
                 crossAxisAlignment: CrossAxisAlignment.start,
                 children: [
@@ -697,7 +894,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                     child: Material(
                       color: Colors.transparent,
                       child: Text(
-                        widget.album.name,
+                        widget.album.nameWithYear,
                         style: textTheme.headlineMedium?.copyWith(
                           color: colorScheme.onBackground,
                           fontWeight: FontWeight.bold,
@@ -759,7 +956,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                           child: ElevatedButton.icon(
                             onPressed: _isLoading || _tracks.isEmpty ? null : _playAlbum,
                             icon: const Icon(Icons.play_arrow_rounded),
-                            label: const Text('Play'),
+                            label: Text(S.of(context)!.play),
                             style: ElevatedButton.styleFrom(
                               backgroundColor: colorScheme.primary,
                               foregroundColor: colorScheme.onPrimary,
@@ -829,17 +1026,32 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                           ),
                         ),
                       ),
+
+                      const SizedBox(width: 12),
+
+                      // Library Button
+                      SizedBox(
+                        height: 50,
+                        width: 50,
+                        child: FilledButton.tonal(
+                          onPressed: _toggleLibrary,
+                          style: FilledButton.styleFrom(
+                            padding: EdgeInsets.zero,
+                            shape: RoundedRectangleBorder(
+                              borderRadius: BorderRadius.circular(12),
+                            ),
+                          ),
+                          child: Icon(
+                            _isInLibrary ? Icons.library_add_check : Icons.library_add,
+                            color: _isInLibrary
+                                ? colorScheme.primary
+                                : colorScheme.onSurfaceVariant,
+                          ),
+                        ),
+                      ),
                     ],
                   ),
                   const SizedBox(height: 24),
-                  Text(
-                    'Tracks',
-                    style: textTheme.titleLarge?.copyWith(
-                      color: colorScheme.onBackground,
-                      fontWeight: FontWeight.bold,
-                    ),
-                  ),
-                  const SizedBox(height: 12),
                 ],
               ),
             ),
@@ -854,7 +1066,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
             SliverFillRemaining(
               child: Center(
                 child: Text(
-                  'No tracks found',
+                  S.of(context)!.noTracksFound,
                   style: TextStyle(
                     color: colorScheme.onBackground.withOpacity(0.54),
                     fontSize: 16,
@@ -1006,118 +1218,71 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
             ),
           const SliverToBoxAdapter(child: SizedBox(height: 164)), // Space for bottom nav + mini player
         ],
-      ),
+      );
+          },
+        ),
       ),
     );
   }
 
   void _showPlayAlbumFromHereMenu(BuildContext context, int startIndex) {
     final maProvider = context.read<MusicAssistantProvider>();
-    final players = maProvider.availablePlayers;
 
-    _showPlayOnSheet(
-      context,
-      players,
-      onPlayerSelected: (player) {
+    GlobalPlayerOverlay.hidePlayer();
+
+    showPlayerPickerSheet(
+      context: context,
+      title: S.of(context)!.playOn,
+      players: maProvider.availablePlayers,
+      selectedPlayer: maProvider.selectedPlayer,
+      onPlayerSelected: (player) async {
         maProvider.selectPlayer(player);
-        maProvider.playTracks(
+        await maProvider.playTracks(
           player.playerId,
           _tracks,
           startIndex: startIndex,
         );
       },
-    );
+    ).whenComplete(() {
+      GlobalPlayerOverlay.showPlayer();
+    });
   }
 
   void _showPlayRadioMenu(BuildContext context, int trackIndex) {
     final maProvider = context.read<MusicAssistantProvider>();
-    final players = maProvider.availablePlayers;
     final track = _tracks[trackIndex];
 
-    _showPlayOnSheet(
-      context,
-      players,
-      onPlayerSelected: (player) {
+    GlobalPlayerOverlay.hidePlayer();
+
+    showPlayerPickerSheet(
+      context: context,
+      title: S.of(context)!.playOn,
+      players: maProvider.availablePlayers,
+      selectedPlayer: maProvider.selectedPlayer,
+      onPlayerSelected: (player) async {
         maProvider.selectPlayer(player);
-        maProvider.playRadio(player.playerId, track);
+        await maProvider.playRadio(player.playerId, track);
       },
-    );
+    ).whenComplete(() {
+      GlobalPlayerOverlay.showPlayer();
+    });
   }
 
   void _showPlayOnMenu(BuildContext context) {
     final maProvider = context.read<MusicAssistantProvider>();
-    final players = maProvider.availablePlayers;
 
-    _showPlayOnSheet(
-      context,
-      players,
-      onPlayerSelected: (player) {
-        maProvider.selectPlayer(player);
-        maProvider.playTracks(player.playerId, _tracks);
-      },
-    );
-  }
-
-  /// Shared "Play on..." bottom sheet with fixed height and scrollable list
-  void _showPlayOnSheet(
-    BuildContext context,
-    List players, {
-    required void Function(dynamic player) onPlayerSelected,
-  }) {
-    // Slide mini player down out of the way
     GlobalPlayerOverlay.hidePlayer();
 
-    final screenHeight = MediaQuery.of(context).size.height;
-    final bottomPadding = MediaQuery.of(context).padding.bottom;
-    final sheetHeight = (screenHeight * 0.45) + bottomPadding; // Fixed 45% + safe area
-
-    showModalBottomSheet(
+    showPlayerPickerSheet(
       context: context,
-      backgroundColor: Colors.transparent,
-      isScrollControlled: true,
-      builder: (context) => Container(
-        height: sheetHeight,
-        decoration: BoxDecoration(
-          color: Theme.of(context).colorScheme.surface,
-          borderRadius: const BorderRadius.vertical(top: Radius.circular(20)),
-        ),
-        child: Column(
-          children: [
-            const SizedBox(height: 16),
-            Text(
-              'Play on...',
-              style: Theme.of(context).textTheme.titleLarge,
-            ),
-            const SizedBox(height: 16),
-            Expanded(
-              child: players.isEmpty
-                  ? const Center(
-                      child: Text('No players available'),
-                    )
-                  : ListView.builder(
-                      padding: EdgeInsets.only(bottom: bottomPadding + 16),
-                      itemCount: players.length,
-                      itemBuilder: (context, index) {
-                        final player = players[index];
-                        return ListTile(
-                          leading: Icon(
-                            Icons.speaker,
-                            color: Theme.of(context).colorScheme.onSurface,
-                          ),
-                          title: Text(player.name),
-                          onTap: () {
-                            Navigator.pop(context);
-                            onPlayerSelected(player);
-                          },
-                        );
-                      },
-                    ),
-            ),
-          ],
-        ),
-      ),
+      title: S.of(context)!.playOn,
+      players: maProvider.availablePlayers,
+      selectedPlayer: maProvider.selectedPlayer,
+      onPlayerSelected: (player) async {
+        maProvider.selectPlayer(player);
+        await maProvider.playTracks(player.playerId, _tracks);
+      },
     ).whenComplete(() {
-      // Slide mini player back up when sheet is dismissed
       GlobalPlayerOverlay.showPlayer();
     });
   }

lib/screens/audiobook_author_screen.dart

@@ -0,0 +1,546 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:material_design_icons_flutter/material_design_icons_flutter.dart';
+import '../models/media_item.dart';
+import '../providers/music_assistant_provider.dart';
+import '../widgets/global_player_overlay.dart';
+import '../theme/palette_helper.dart';
+import '../theme/theme_provider.dart';
+import '../services/settings_service.dart';
+import '../services/metadata_service.dart';
+import '../services/debug_logger.dart';
+import '../utils/page_transitions.dart';
+import '../constants/hero_tags.dart';
+import '../l10n/app_localizations.dart';
+import 'audiobook_detail_screen.dart';
+
+class AudiobookAuthorScreen extends StatefulWidget {
+  final String authorName;
+  final List<Audiobook> audiobooks;
+  final String? heroTagSuffix;
+  final String? initialAuthorImageUrl;
+
+  const AudiobookAuthorScreen({
+    super.key,
+    required this.authorName,
+    required this.audiobooks,
+    this.heroTagSuffix,
+    this.initialAuthorImageUrl,
+  });
+
+  @override
+  State<AudiobookAuthorScreen> createState() => _AudiobookAuthorScreenState();
+}
+
+class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
+  final _logger = DebugLogger();
+  late List<Audiobook> _audiobooks;
+  ColorScheme? _lightColorScheme;
+  ColorScheme? _darkColorScheme;
+  String? _authorImageUrl;
+
+  // View preferences
+  String _sortOrder = 'alpha'; // 'alpha' or 'year'
+  String _viewMode = 'grid2'; // 'grid2', 'grid3', 'list'
+
+  String get _heroTagSuffix => widget.heroTagSuffix != null ? '_${widget.heroTagSuffix}' : '';
+
+  @override
+  void initState() {
+    super.initState();
+    _audiobooks = List.from(widget.audiobooks);
+    // Use initial image URL immediately for smooth hero animation
+    _authorImageUrl = widget.initialAuthorImageUrl;
+    _loadViewPreferences();
+    _sortAudiobooks();
+    _loadAuthorImage();
+  }
+
+  Future<void> _loadAuthorImage() async {
+    final imageUrl = await MetadataService.getAuthorImageUrl(widget.authorName);
+    if (mounted && imageUrl != null) {
+      setState(() {
+        _authorImageUrl = imageUrl;
+      });
+    }
+  }
+
+  Future<void> _loadViewPreferences() async {
+    final sortOrder = await SettingsService.getAuthorAudiobooksSortOrder();
+    final viewMode = await SettingsService.getAuthorAudiobooksViewMode();
+    if (mounted) {
+      setState(() {
+        _sortOrder = sortOrder;
+        _viewMode = viewMode;
+        _sortAudiobooks();
+      });
+    }
+  }
+
+  void _toggleSortOrder() {
+    final newOrder = _sortOrder == 'alpha' ? 'year' : 'alpha';
+    setState(() {
+      _sortOrder = newOrder;
+      _sortAudiobooks();
+    });
+    SettingsService.setAuthorAudiobooksSortOrder(newOrder);
+  }
+
+  void _cycleViewMode() {
+    String newMode;
+    switch (_viewMode) {
+      case 'grid2':
+        newMode = 'grid3';
+        break;
+      case 'grid3':
+        newMode = 'list';
+        break;
+      default:
+        newMode = 'grid2';
+    }
+    setState(() {
+      _viewMode = newMode;
+    });
+    SettingsService.setAuthorAudiobooksViewMode(newMode);
+  }
+
+  void _sortAudiobooks() {
+    if (_sortOrder == 'year') {
+      _audiobooks.sort((a, b) {
+        if (a.year == null && b.year == null) return a.name.compareTo(b.name);
+        if (a.year == null) return 1;
+        if (b.year == null) return -1;
+        return a.year!.compareTo(b.year!);
+      });
+    } else {
+      _audiobooks.sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final adaptiveTheme = context.select<ThemeProvider, bool>(
+      (provider) => provider.adaptiveTheme,
+    );
+    final adaptiveLightScheme = context.select<ThemeProvider, ColorScheme?>(
+      (provider) => provider.adaptiveLightScheme,
+    );
+    final adaptiveDarkScheme = context.select<ThemeProvider, ColorScheme?>(
+      (provider) => provider.adaptiveDarkScheme,
+    );
+
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+
+    ColorScheme? adaptiveScheme;
+    if (adaptiveTheme) {
+      adaptiveScheme = isDark
+        ? (_darkColorScheme ?? adaptiveDarkScheme)
+        : (_lightColorScheme ?? adaptiveLightScheme);
+    }
+    final colorScheme = adaptiveScheme ?? Theme.of(context).colorScheme;
+    final textTheme = Theme.of(context).textTheme;
+
+    return PopScope(
+      canPop: true,
+      onPopInvokedWithResult: (didPop, result) {
+        if (didPop) {
+          clearAdaptiveColorsOnBack(context);
+        }
+      },
+      child: Scaffold(
+        backgroundColor: colorScheme.surface,
+        body: CustomScrollView(
+          slivers: [
+            SliverAppBar(
+              expandedHeight: 200,
+              pinned: true,
+              backgroundColor: colorScheme.surface,
+              leading: IconButton(
+                icon: const Icon(Icons.arrow_back_rounded),
+                onPressed: () {
+                  clearAdaptiveColorsOnBack(context);
+                  Navigator.pop(context);
+                },
+                color: colorScheme.onSurface,
+              ),
+              flexibleSpace: FlexibleSpaceBar(
+                background: Column(
+                  mainAxisAlignment: MainAxisAlignment.center,
+                  children: [
+                    const SizedBox(height: 60),
+                    Hero(
+                      tag: HeroTags.authorImage + widget.authorName + _heroTagSuffix,
+                      child: Container(
+                        width: 200,
+                        height: 200,
+                        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,
+                                  ),
+                                  errorWidget: (_, __, ___) => Icon(
+                                    MdiIcons.accountOutline,
+                                    size: 100,
+                                    color: colorScheme.onPrimaryContainer,
+                                  ),
+                                )
+                              : Icon(
+                                  MdiIcons.accountOutline,
+                                  size: 100,
+                                  color: colorScheme.onPrimaryContainer,
+                                ),
+                        ),
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+            SliverToBoxAdapter(
+              child: Padding(
+                padding: const EdgeInsets.all(24.0),
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Text(
+                      widget.authorName,
+                      style: textTheme.headlineMedium?.copyWith(
+                        color: colorScheme.onSurface,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                    const SizedBox(height: 8),
+                    Text(
+                      S.of(context)!.audiobookCount(_audiobooks.length),
+                      style: textTheme.bodyLarge?.copyWith(
+                        color: colorScheme.onSurface.withOpacity(0.7),
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+            // Audiobooks Section Header with controls
+            SliverToBoxAdapter(
+              child: Padding(
+                padding: const EdgeInsets.fromLTRB(24.0, 8.0, 12.0, 8.0),
+                child: Row(
+                  children: [
+                    Text(
+                      S.of(context)!.audiobooks,
+                      style: textTheme.titleLarge?.copyWith(
+                        color: colorScheme.onSurface,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                    const Spacer(),
+                    // Sort toggle
+                    IconButton(
+                      icon: Icon(
+                        _sortOrder == 'alpha' ? Icons.sort_by_alpha : Icons.calendar_today,
+                        color: colorScheme.primary,
+                        size: 20,
+                      ),
+                      tooltip: _sortOrder == 'alpha' ? S.of(context)!.sortByYear : S.of(context)!.sortAlphabetically,
+                      onPressed: _toggleSortOrder,
+                      visualDensity: VisualDensity.compact,
+                      padding: EdgeInsets.zero,
+                      constraints: const BoxConstraints(minWidth: 36, minHeight: 36),
+                    ),
+                    // View mode toggle
+                    IconButton(
+                      icon: Icon(
+                        _viewMode == 'list'
+                            ? Icons.view_list
+                            : _viewMode == 'grid3'
+                                ? Icons.grid_view
+                                : Icons.grid_on,
+                        color: colorScheme.primary,
+                        size: 20,
+                      ),
+                      tooltip: _viewMode == 'grid2'
+                          ? S.of(context)!.threeColumnGrid
+                          : _viewMode == 'grid3'
+                              ? S.of(context)!.listView
+                              : S.of(context)!.twoColumnGrid,
+                      onPressed: _cycleViewMode,
+                      visualDensity: VisualDensity.compact,
+                      padding: EdgeInsets.zero,
+                      constraints: const BoxConstraints(minWidth: 36, minHeight: 36),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+            _buildAudiobookSliver(),
+            const SliverToBoxAdapter(child: SizedBox(height: 140)),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildAudiobookSliver() {
+    if (_viewMode == 'list') {
+      return SliverPadding(
+        padding: const EdgeInsets.symmetric(horizontal: 12),
+        sliver: SliverList(
+          delegate: SliverChildBuilderDelegate(
+            (context, index) => _buildAudiobookListTile(_audiobooks[index]),
+            childCount: _audiobooks.length,
+          ),
+        ),
+      );
+    }
+
+    final crossAxisCount = _viewMode == 'grid3' ? 3 : 2;
+    final childAspectRatio = _viewMode == 'grid3' ? 0.65 : 0.70;
+
+    return SliverPadding(
+      padding: const EdgeInsets.symmetric(horizontal: 12),
+      sliver: SliverGrid(
+        gridDelegate: SliverGridDelegateWithFixedCrossAxisCount(
+          crossAxisCount: crossAxisCount,
+          childAspectRatio: childAspectRatio,
+          crossAxisSpacing: 12,
+          mainAxisSpacing: 12,
+        ),
+        delegate: SliverChildBuilderDelegate(
+          (context, index) => _buildAudiobookCard(_audiobooks[index]),
+          childCount: _audiobooks.length,
+        ),
+      ),
+    );
+  }
+
+  Widget _buildAudiobookCard(Audiobook book) {
+    final maProvider = context.read<MusicAssistantProvider>();
+    final imageUrl = maProvider.getImageUrl(book, size: 256);
+    final colorScheme = Theme.of(context).colorScheme;
+    final textTheme = Theme.of(context).textTheme;
+    final heroSuffix = 'author${_heroTagSuffix}';
+
+    return InkWell(
+      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix, initialImageUrl: imageUrl),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          AspectRatio(
+            aspectRatio: 1.0,
+            child: Stack(
+              children: [
+                Hero(
+                  tag: HeroTags.audiobookCover + (book.uri ?? book.itemId) + '_$heroSuffix',
+                  child: ClipRRect(
+                    borderRadius: BorderRadius.circular(8),
+                    child: Container(
+                      color: colorScheme.surfaceContainerHighest,
+                      child: imageUrl != null
+                          ? CachedNetworkImage(
+                              imageUrl: imageUrl,
+                              fit: BoxFit.cover,
+                              width: double.infinity,
+                              height: double.infinity,
+                              fadeInDuration: Duration.zero,
+                              fadeOutDuration: Duration.zero,
+                              placeholder: (_, __) => Center(
+                                child: Icon(
+                                  MdiIcons.bookOutline,
+                                  size: 48,
+                                  color: colorScheme.onSurfaceVariant,
+                                ),
+                              ),
+                              errorWidget: (_, __, ___) => Center(
+                                child: Icon(
+                                  MdiIcons.bookOutline,
+                                  size: 48,
+                                  color: colorScheme.onSurfaceVariant,
+                                ),
+                              ),
+                            )
+                          : Center(
+                              child: Icon(
+                                MdiIcons.bookOutline,
+                                size: 48,
+                                color: colorScheme.onSurfaceVariant,
+                              ),
+                            ),
+                    ),
+                  ),
+                ),
+                // Progress indicator
+                if (book.progress > 0)
+                  Positioned(
+                    bottom: 0,
+                    left: 0,
+                    right: 0,
+                    child: LinearProgressIndicator(
+                      value: book.progress,
+                      backgroundColor: Colors.black54,
+                      valueColor: AlwaysStoppedAnimation<Color>(colorScheme.primary),
+                      minHeight: 3,
+                    ),
+                  ),
+              ],
+            ),
+          ),
+          const SizedBox(height: 8),
+          Hero(
+            tag: HeroTags.audiobookTitle + (book.uri ?? book.itemId) + '_$heroSuffix',
+            child: Material(
+              color: Colors.transparent,
+              child: Text(
+                book.name,
+                style: textTheme.titleSmall?.copyWith(
+                  color: colorScheme.onSurface,
+                  fontWeight: FontWeight.w500,
+                ),
+                maxLines: 2,
+                overflow: TextOverflow.ellipsis,
+              ),
+            ),
+          ),
+          if (book.narratorsString != S.of(context)!.unknownNarrator)
+            Text(
+              S.of(context)!.narratedBy(book.narratorsString),
+              style: textTheme.bodySmall?.copyWith(
+                color: colorScheme.onSurface.withOpacity(0.6),
+              ),
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+            ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildAudiobookListTile(Audiobook book) {
+    final maProvider = context.read<MusicAssistantProvider>();
+    final imageUrl = maProvider.getImageUrl(book, size: 128);
+    final colorScheme = Theme.of(context).colorScheme;
+    final textTheme = Theme.of(context).textTheme;
+    final heroSuffix = 'author${_heroTagSuffix}';
+
+    return ListTile(
+      contentPadding: const EdgeInsets.symmetric(horizontal: 12, vertical: 4),
+      leading: Hero(
+        tag: HeroTags.audiobookCover + (book.uri ?? book.itemId) + '_$heroSuffix',
+        child: ClipRRect(
+          borderRadius: BorderRadius.circular(4),
+          child: Stack(
+            children: [
+              Container(
+                width: 56,
+                height: 56,
+                color: colorScheme.surfaceContainerHighest,
+                child: imageUrl != null
+                    ? CachedNetworkImage(
+                        imageUrl: imageUrl,
+                        fit: BoxFit.cover,
+                        fadeInDuration: Duration.zero,
+                        fadeOutDuration: Duration.zero,
+                        placeholder: (_, __) => Icon(
+                          MdiIcons.bookOutline,
+                          color: colorScheme.onSurfaceVariant,
+                        ),
+                        errorWidget: (_, __, ___) => Icon(
+                          MdiIcons.bookOutline,
+                          color: colorScheme.onSurfaceVariant,
+                        ),
+                      )
+                    : Icon(
+                        MdiIcons.bookOutline,
+                        color: colorScheme.onSurfaceVariant,
+                      ),
+              ),
+              if (book.progress > 0)
+                Positioned(
+                  bottom: 0,
+                  left: 0,
+                  right: 0,
+                  child: LinearProgressIndicator(
+                    value: book.progress,
+                    backgroundColor: Colors.black54,
+                    valueColor: AlwaysStoppedAnimation<Color>(colorScheme.primary),
+                    minHeight: 2,
+                  ),
+                ),
+            ],
+          ),
+        ),
+      ),
+      title: Hero(
+        tag: HeroTags.audiobookTitle + (book.uri ?? book.itemId) + '_$heroSuffix',
+        child: Material(
+          color: Colors.transparent,
+          child: Text(
+            book.name,
+            style: textTheme.titleMedium?.copyWith(
+              color: colorScheme.onSurface,
+              fontWeight: FontWeight.w500,
+            ),
+            maxLines: 1,
+            overflow: TextOverflow.ellipsis,
+          ),
+        ),
+      ),
+      subtitle: Text(
+        book.narratorsString != S.of(context)!.unknownNarrator
+            ? S.of(context)!.narratedBy(book.narratorsString)
+            : book.duration != null
+                ? _formatDuration(book.duration!)
+                : '',
+        style: textTheme.bodySmall?.copyWith(
+          color: colorScheme.onSurface.withOpacity(0.7),
+        ),
+        maxLines: 1,
+        overflow: TextOverflow.ellipsis,
+      ),
+      trailing: book.progress > 0
+          ? Text(
+              '${(book.progress * 100).toInt()}%',
+              style: textTheme.bodySmall?.copyWith(
+                color: colorScheme.primary,
+              ),
+            )
+          : null,
+      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix, initialImageUrl: imageUrl),
+    );
+  }
+
+  void _navigateToAudiobook(Audiobook book, {String? heroTagSuffix, String? initialImageUrl}) {
+    Navigator.push(
+      context,
+      FadeSlidePageRoute(
+        child: AudiobookDetailScreen(
+          audiobook: book,
+          heroTagSuffix: heroTagSuffix,
+          initialImageUrl: initialImageUrl,
+        ),
+      ),
+    );
+  }
+
+  String _formatDuration(Duration duration) {
+    final hours = duration.inHours;
+    final minutes = duration.inMinutes % 60;
+    if (hours > 0) {
+      return '${hours}h ${minutes}m';
+    }
+    return '${minutes}m';
+  }
+}

lib/screens/audiobook_series_screen.dart

@@ -0,0 +1,853 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:material_design_icons_flutter/material_design_icons_flutter.dart';
+import 'package:palette_generator/palette_generator.dart';
+import '../models/media_item.dart';
+import '../providers/music_assistant_provider.dart';
+import '../widgets/global_player_overlay.dart' show BottomSpacing;
+import '../services/settings_service.dart';
+import '../services/debug_logger.dart';
+import '../utils/page_transitions.dart';
+import '../constants/hero_tags.dart';
+import 'audiobook_detail_screen.dart';
+import '../l10n/app_localizations.dart';
+
+class AudiobookSeriesScreen extends StatefulWidget {
+  final AudiobookSeries series;
+  final String? heroTag;
+  /// Pre-loaded cover URLs from the library screen for smooth Hero animation
+  final List<String>? initialCovers;
+
+  const AudiobookSeriesScreen({
+    super.key,
+    required this.series,
+    this.heroTag,
+    this.initialCovers,
+  });
+
+  @override
+  State<AudiobookSeriesScreen> createState() => _AudiobookSeriesScreenState();
+}
+
+class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
+  final _logger = DebugLogger();
+  List<Audiobook> _audiobooks = [];
+  bool _isLoading = true;
+  String? _error;
+
+  // View preferences
+  String _sortOrder = 'series'; // 'series' (by series number) or 'alpha'
+  String _viewMode = 'grid2'; // 'grid2', 'grid3', 'list'
+
+  // Extracted colors from book covers
+  List<Color> _extractedColors = [];
+
+  // Cover URLs - start with initial covers, update when books load
+  List<String> _coverUrls = [];
+
+  @override
+  void initState() {
+    super.initState();
+    // Use initial covers immediately for smooth Hero animation
+    if (widget.initialCovers != null && widget.initialCovers!.isNotEmpty) {
+      _coverUrls = List.from(widget.initialCovers!);
+      // Start color extraction from initial covers
+      _extractColorsFromUrls(widget.initialCovers!);
+    }
+    _loadViewPreferences();
+    // Defer loading until after first frame to ensure UI renders first
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (mounted) {
+        _loadSeriesBooks();
+      }
+    });
+  }
+
+  /// Extract colors from cover URLs (used for initial covers)
+  Future<void> _extractColorsFromUrls(List<String> coverUrls) async {
+    final extractedColors = <Color>[];
+
+    for (final url in coverUrls.take(4)) {
+      try {
+        final palette = await PaletteGenerator.fromImageProvider(
+          CachedNetworkImageProvider(url),
+          maximumColorCount: 8,
+        );
+
+        if (palette.darkMutedColor != null) {
+          extractedColors.add(palette.darkMutedColor!.color);
+        }
+        if (palette.mutedColor != null) {
+          extractedColors.add(palette.mutedColor!.color);
+        }
+        if (palette.darkVibrantColor != null) {
+          extractedColors.add(palette.darkVibrantColor!.color);
+        }
+        if (palette.dominantColor != null) {
+          final hsl = HSLColor.fromColor(palette.dominantColor!.color);
+          extractedColors.add(hsl.withLightness((hsl.lightness * 0.4).clamp(0.1, 0.3)).toColor());
+        }
+      } catch (e) {
+        _logger.log('📚 Error extracting colors: $e');
+      }
+    }
+
+    if (extractedColors.isNotEmpty && mounted) {
+      setState(() {
+        _extractedColors = extractedColors;
+      });
+    }
+  }
+
+  Future<void> _loadViewPreferences() async {
+    final sortOrder = await SettingsService.getSeriesAudiobooksSortOrder();
+    final viewMode = await SettingsService.getSeriesAudiobooksViewMode();
+    if (mounted) {
+      setState(() {
+        _sortOrder = sortOrder;
+        _viewMode = viewMode;
+      });
+    }
+  }
+
+  void _toggleSortOrder() {
+    final newOrder = _sortOrder == 'series' ? 'alpha' : 'series';
+    setState(() {
+      _sortOrder = newOrder;
+      _sortAudiobooks();
+    });
+    SettingsService.setSeriesAudiobooksSortOrder(newOrder);
+  }
+
+  void _cycleViewMode() {
+    String newMode;
+    switch (_viewMode) {
+      case 'grid2':
+        newMode = 'grid3';
+        break;
+      case 'grid3':
+        newMode = 'list';
+        break;
+      default:
+        newMode = 'grid2';
+    }
+    setState(() {
+      _viewMode = newMode;
+    });
+    SettingsService.setSeriesAudiobooksViewMode(newMode);
+  }
+
+  void _sortAudiobooks() {
+    if (_sortOrder == 'series') {
+      // Sort by series number (sequence), falling back to name for books without sequence
+      _audiobooks.sort((a, b) {
+        final seqA = a.seriesSequence;
+        final seqB = b.seriesSequence;
+        if (seqA == null && seqB == null) return a.name.compareTo(b.name);
+        if (seqA == null) return 1; // Books without sequence go to end
+        if (seqB == null) return -1;
+        return seqA.compareTo(seqB);
+      });
+    } else {
+      // Sort alphabetically
+      _audiobooks.sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
+    }
+  }
+
+  Future<void> _loadSeriesBooks() async {
+    _logger.log('📚 SeriesScreen _loadSeriesBooks START');
+    try {
+      setState(() {
+        _isLoading = true;
+        _error = null;
+      });
+      _logger.log('📚 SeriesScreen setState done, getting provider...');
+
+      final maProvider = context.read<MusicAssistantProvider>();
+      _logger.log('📚 SeriesScreen got provider, api=${maProvider.api != null}');
+
+      if (maProvider.api == null) {
+        setState(() {
+          _error = S.of(context)!.notConnected;
+          _isLoading = false;
+        });
+        return;
+      }
+
+      _logger.log('📚 SeriesScreen calling getSeriesAudiobooks: path=${widget.series.id}');
+      final books = await maProvider.api!.getSeriesAudiobooks(widget.series.id);
+      _logger.log('📚 SeriesScreen got ${books.length} books');
+
+      // Debug: Log sequence data for each book
+      for (final book in books) {
+        _logger.log('📚 Book: "${book.name}" | position=${book.position} | browseOrder=${book.browseOrder} | sortName=${book.sortName} | seq=${book.seriesSequence} | metadata.series=${book.metadata?['series']}');
+      }
+
+      if (mounted) {
+        // Update cover URLs from loaded books
+        final newCovers = <String>[];
+        for (final book in books.take(9)) {
+          final imageUrl = maProvider.getImageUrl(book);
+          if (imageUrl != null) {
+            newCovers.add(imageUrl);
+          }
+        }
+
+        setState(() {
+          _audiobooks = books;
+          _sortAudiobooks(); // Sort inside setState so UI updates
+          // Update covers if we got new ones (may have more than initial)
+          if (newCovers.isNotEmpty) {
+            _coverUrls = newCovers;
+          }
+          _isLoading = false;
+        });
+        // Debug: Log sorted order
+        _logger.log('📚 Sorted order ($_sortOrder):');
+        for (final book in _audiobooks) {
+          _logger.log('  - ${book.seriesSequence ?? "null"}: ${book.name}');
+        }
+
+        // Extract colors from book covers asynchronously
+        _extractCoverColors(maProvider);
+      }
+    } catch (e, stack) {
+      _logger.log('📚 SeriesScreen error: $e');
+      _logger.log('📚 SeriesScreen stack: $stack');
+      if (mounted) {
+        setState(() {
+          _error = 'Failed to load books: $e';
+          _isLoading = false;
+        });
+      }
+    }
+  }
+
+  /// Extract colors from book covers for empty grid cells
+  Future<void> _extractCoverColors(MusicAssistantProvider maProvider) async {
+    final extractedColors = <Color>[];
+
+    // Extract colors from first few book covers
+    for (final book in _audiobooks.take(4)) {
+      final imageUrl = maProvider.getImageUrl(book);
+      if (imageUrl == null) continue;
+
+      try {
+        final palette = await PaletteGenerator.fromImageProvider(
+          CachedNetworkImageProvider(imageUrl),
+          maximumColorCount: 8,
+        );
+
+        // Get dark muted colors for grid squares
+        if (palette.darkMutedColor != null) {
+          extractedColors.add(palette.darkMutedColor!.color);
+        }
+        if (palette.mutedColor != null) {
+          extractedColors.add(palette.mutedColor!.color);
+        }
+        if (palette.darkVibrantColor != null) {
+          extractedColors.add(palette.darkVibrantColor!.color);
+        }
+        if (palette.dominantColor != null) {
+          // Darken the dominant color for better appearance
+          final hsl = HSLColor.fromColor(palette.dominantColor!.color);
+          extractedColors.add(hsl.withLightness((hsl.lightness * 0.4).clamp(0.1, 0.3)).toColor());
+        }
+      } catch (e) {
+        _logger.log('📚 Error extracting colors: $e');
+      }
+    }
+
+    if (extractedColors.isNotEmpty && mounted) {
+      setState(() {
+        _extractedColors = extractedColors;
+      });
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    final textTheme = Theme.of(context).textTheme;
+    final maProvider = context.watch<MusicAssistantProvider>();
+    final l10n = S.of(context)!;
+
+    return Scaffold(
+      backgroundColor: colorScheme.surface,
+      body: LayoutBuilder(
+        builder: (context, constraints) {
+          // Responsive cover size: 70% of screen width, clamped between 200-320
+          final coverSize = (constraints.maxWidth * 0.7).clamp(200.0, 320.0);
+          final expandedHeight = coverSize + 70;
+
+          return CustomScrollView(
+        slivers: [
+          // App bar with series cover collage (matches audiobook detail screen)
+          SliverAppBar(
+            expandedHeight: expandedHeight,
+            pinned: true,
+            backgroundColor: colorScheme.surface,
+            leading: IconButton(
+              icon: const Icon(Icons.arrow_back_rounded),
+              onPressed: () => Navigator.pop(context),
+              color: colorScheme.onSurface,
+            ),
+            flexibleSpace: FlexibleSpaceBar(
+              background: Column(
+                mainAxisAlignment: MainAxisAlignment.center,
+                children: [
+                  const SizedBox(height: 60),
+                  // Series cover collage - responsive size
+                  Hero(
+                    tag: widget.heroTag ?? 'series_cover_${widget.series.id}',
+                    child: Container(
+                      width: coverSize,
+                      height: coverSize,
+                      decoration: BoxDecoration(
+                        color: colorScheme.surfaceContainerHighest,
+                        borderRadius: BorderRadius.circular(12),
+                        boxShadow: [
+                          BoxShadow(
+                            color: Colors.black.withOpacity(0.2),
+                            blurRadius: 10,
+                            offset: const Offset(0, 4),
+                          ),
+                        ],
+                      ),
+                      child: ClipRRect(
+                        borderRadius: BorderRadius.circular(12),
+                        child: _buildSeriesCover(colorScheme, maProvider),
+                      ),
+                    ),
+                  ),
+                ],
+              ),
+            ),
+          ),
+
+          // Title and count
+          SliverToBoxAdapter(
+            child: Padding(
+              padding: const EdgeInsets.all(24.0),
+              child: Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Text(
+                    widget.series.name,
+                    style: textTheme.headlineMedium?.copyWith(
+                      color: colorScheme.onSurface,
+                      fontWeight: FontWeight.bold,
+                    ),
+                  ),
+                  const SizedBox(height: 8),
+                  Text(
+                    _isLoading
+                        ? l10n.loading
+                        : l10n.bookCount(_audiobooks.length),
+                    style: textTheme.bodyLarge?.copyWith(
+                      color: colorScheme.onSurface.withOpacity(0.7),
+                    ),
+                  ),
+                ],
+              ),
+            ),
+          ),
+
+          // Books section header with controls
+          SliverToBoxAdapter(
+            child: Padding(
+              padding: const EdgeInsets.fromLTRB(24.0, 8.0, 12.0, 8.0),
+              child: Row(
+                children: [
+                  Text(
+                    l10n.books,
+                    style: textTheme.titleLarge?.copyWith(
+                      color: colorScheme.onSurface,
+                      fontWeight: FontWeight.bold,
+                    ),
+                  ),
+                  const Spacer(),
+                  // Sort toggle
+                  IconButton(
+                    icon: Icon(
+                      _sortOrder == 'series' ? Icons.format_list_numbered : Icons.sort_by_alpha,
+                      color: colorScheme.primary,
+                      size: 20,
+                    ),
+                    tooltip: _sortOrder == 'series' ? S.of(context)!.sortAlphabetically : S.of(context)!.sortBySeriesOrder,
+                    onPressed: _toggleSortOrder,
+                    visualDensity: VisualDensity.compact,
+                    padding: EdgeInsets.zero,
+                    constraints: const BoxConstraints(minWidth: 36, minHeight: 36),
+                  ),
+                  // View mode toggle
+                  IconButton(
+                    icon: Icon(
+                      _viewMode == 'list'
+                          ? Icons.view_list
+                          : _viewMode == 'grid3'
+                              ? Icons.grid_view
+                              : Icons.grid_on,
+                      color: colorScheme.primary,
+                      size: 20,
+                    ),
+                    tooltip: _viewMode == 'grid2'
+                        ? S.of(context)!.threeColumnGrid
+                        : _viewMode == 'grid3'
+                            ? S.of(context)!.listView
+                            : S.of(context)!.twoColumnGrid,
+                    onPressed: _cycleViewMode,
+                    visualDensity: VisualDensity.compact,
+                    padding: EdgeInsets.zero,
+                    constraints: const BoxConstraints(minWidth: 36, minHeight: 36),
+                  ),
+                ],
+              ),
+            ),
+          ),
+
+          // Content
+          if (_isLoading)
+            const SliverFillRemaining(
+              child: Center(child: CircularProgressIndicator()),
+            )
+          else if (_error != null)
+            SliverFillRemaining(
+              child: Center(
+                child: Column(
+                  mainAxisAlignment: MainAxisAlignment.center,
+                  children: [
+                    Icon(Icons.error_outline, size: 48, color: colorScheme.error),
+                    const SizedBox(height: 16),
+                    Text(_error!, style: TextStyle(color: colorScheme.error)),
+                    const SizedBox(height: 16),
+                    ElevatedButton(
+                      onPressed: _loadSeriesBooks,
+                      child: Text(l10n.retry),
+                    ),
+                  ],
+                ),
+              ),
+            )
+          else if (_audiobooks.isEmpty)
+            SliverFillRemaining(
+              child: Center(
+                child: Column(
+                  mainAxisAlignment: MainAxisAlignment.center,
+                  children: [
+                    Icon(Icons.library_books_outlined,
+                        size: 48, color: colorScheme.onSurfaceVariant),
+                    const SizedBox(height: 16),
+                    Text(
+                      S.of(context)!.noBooksInSeries,
+                      style: TextStyle(color: colorScheme.onSurfaceVariant),
+                    ),
+                  ],
+                ),
+              ),
+            )
+          else
+            _buildAudiobookSliver(maProvider),
+
+          // Bottom padding for mini player
+          SliverToBoxAdapter(
+            child: SizedBox(height: BottomSpacing.withMiniPlayer),
+          ),
+        ],
+      );
+        },
+      ),
+    );
+  }
+
+  // Dark pastel colors for empty cells - muted and book-like
+  static const _emptyColors = [
+    Color(0xFF2D3436), // Dark slate
+    Color(0xFF34495E), // Dark blue-grey
+    Color(0xFF4A3728), // Dark brown
+    Color(0xFF2C3E50), // Midnight blue
+    Color(0xFF3D3D3D), // Charcoal
+    Color(0xFF4A4458), // Dark purple-grey
+    Color(0xFF3E4A47), // Dark teal-grey
+    Color(0xFF4A3F35), // Dark warm grey
+  ];
+
+  Widget _buildSeriesCover(ColorScheme colorScheme, MusicAssistantProvider maProvider) {
+    // Use _coverUrls which may have initial covers or loaded covers
+    // Only show placeholder if we truly have no covers
+    if (_coverUrls.isEmpty) {
+      return Container(
+        color: colorScheme.surfaceContainerHighest,
+        child: Center(
+          child: Icon(
+            Icons.collections_bookmark_rounded,
+            size: 64,
+            color: colorScheme.onSurfaceVariant.withOpacity(0.5),
+          ),
+        ),
+      );
+    }
+
+    final covers = _coverUrls;
+
+    // Dynamic grid size based on number of covers (matches library screen)
+    // 1 cover = 1x1, 2-4 covers = 2x2, 5+ covers = 3x3
+    int gridSize;
+    if (covers.length == 1) {
+      gridSize = 1;
+    } else if (covers.length <= 4) {
+      gridSize = 2;
+    } else {
+      gridSize = 3;
+    }
+
+    // Use series ID to pick consistent colors and nested grid patterns
+    final colorSeed = widget.series.id.hashCode;
+
+    // Pad covers to fill grid
+    final displayCovers = List<String?>.filled(gridSize * gridSize, null);
+    for (var i = 0; i < covers.length && i < displayCovers.length; i++) {
+      displayCovers[i] = covers[i];
+    }
+
+    // Build grid using Column/Row for proper sizing (no scrolling issues)
+    return Column(
+      children: List.generate(gridSize, (row) {
+        return Expanded(
+          child: Row(
+            children: List.generate(gridSize, (col) {
+              final index = row * gridSize + col;
+              final coverUrl = displayCovers[index];
+
+              return Expanded(
+                child: coverUrl != null
+                      ? CachedNetworkImage(
+                          imageUrl: coverUrl,
+                          fit: BoxFit.cover,
+                          fadeInDuration: Duration.zero,
+                          fadeOutDuration: Duration.zero,
+                          placeholder: (_, __) => Container(
+                            color: colorScheme.surfaceContainerHighest,
+                          ),
+                          errorWidget: (_, __, ___) => Container(
+                            color: colorScheme.surfaceContainerHighest,
+                            child: Icon(
+                              Icons.book,
+                              color: colorScheme.onSurfaceVariant.withOpacity(0.3),
+                              size: 20,
+                            ),
+                          ),
+                        )
+                      : _buildEmptyCell(colorSeed, index),
+              );
+            }),
+          ),
+        );
+      }),
+    );
+  }
+
+  /// Builds an empty cell with either a solid color or a nested grid
+  /// The pattern is deterministic based on series ID and cell index
+  Widget _buildEmptyCell(int colorSeed, int cellIndex) {
+    // Use extracted colors if available, otherwise fall back to static palette
+    final baseColors = _extractedColors.isNotEmpty ? _extractedColors : _emptyColors;
+    // Tone down colors - reduce saturation and darken
+    final colors = baseColors.map((c) {
+      final hsl = HSLColor.fromColor(c);
+      return hsl
+          .withSaturation((hsl.saturation * 0.5).clamp(0.05, 0.25))
+          .withLightness((hsl.lightness * 0.7).clamp(0.08, 0.20))
+          .toColor();
+    }).toList();
+
+    // Use combined seed for deterministic but varied patterns
+    final seed = colorSeed + cellIndex * 17; // Prime multiplier for better distribution
+
+    // Determine nested grid size: 1 (solid), 2 (2x2), or 3 (3x3)
+    // Distribution: ~50% solid, ~30% 2x2, ~20% 3x3
+    final sizeRoll = seed.abs() % 100;
+    int nestedSize;
+    if (sizeRoll < 50) {
+      nestedSize = 1; // Solid color
+    } else if (sizeRoll < 80) {
+      nestedSize = 2; // 2x2 grid
+    } else {
+      nestedSize = 3; // 3x3 grid
+    }
+
+    if (nestedSize == 1) {
+      // Solid color
+      final colorIndex = seed.abs() % colors.length;
+      return Container(color: colors[colorIndex]);
+    }
+
+    // Build nested grid (no margins - seamless)
+    return Column(
+      children: List.generate(nestedSize, (row) {
+        return Expanded(
+          child: Row(
+            children: List.generate(nestedSize, (col) {
+              final nestedIndex = row * nestedSize + col;
+              // Use different seed for each nested cell
+              final nestedSeed = seed + nestedIndex * 7;
+              final colorIndex = nestedSeed.abs() % colors.length;
+              return Expanded(
+                child: Container(color: colors[colorIndex]),
+              );
+            }),
+          ),
+        );
+      }),
+    );
+  }
+
+  Widget _buildAudiobookSliver(MusicAssistantProvider maProvider) {
+    if (_viewMode == 'list') {
+      return SliverPadding(
+        padding: const EdgeInsets.symmetric(horizontal: 12),
+        sliver: SliverList(
+          delegate: SliverChildBuilderDelegate(
+            (context, index) => _buildAudiobookListTile(_audiobooks[index], maProvider),
+            childCount: _audiobooks.length,
+          ),
+        ),
+      );
+    }
+
+    final crossAxisCount = _viewMode == 'grid3' ? 3 : 2;
+    final childAspectRatio = _viewMode == 'grid3' ? 0.65 : 0.70;
+
+    return SliverPadding(
+      padding: const EdgeInsets.symmetric(horizontal: 12),
+      sliver: SliverGrid(
+        gridDelegate: SliverGridDelegateWithFixedCrossAxisCount(
+          crossAxisCount: crossAxisCount,
+          childAspectRatio: childAspectRatio,
+          crossAxisSpacing: 12,
+          mainAxisSpacing: 12,
+        ),
+        delegate: SliverChildBuilderDelegate(
+          (context, index) => _buildAudiobookCard(_audiobooks[index], maProvider),
+          childCount: _audiobooks.length,
+        ),
+      ),
+    );
+  }
+
+  Widget _buildAudiobookCard(Audiobook book, MusicAssistantProvider maProvider) {
+    final imageUrl = maProvider.getImageUrl(book, size: 256);
+    final colorScheme = Theme.of(context).colorScheme;
+    final textTheme = Theme.of(context).textTheme;
+    final heroSuffix = 'series_${widget.series.id}';
+
+    return InkWell(
+      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix, initialImageUrl: imageUrl),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          AspectRatio(
+            aspectRatio: 1.0,
+            child: Stack(
+              children: [
+                Hero(
+                  tag: HeroTags.audiobookCover + (book.uri ?? book.itemId) + '_$heroSuffix',
+                  child: ClipRRect(
+                    borderRadius: BorderRadius.circular(8),
+                    child: Container(
+                      color: colorScheme.surfaceContainerHighest,
+                      child: imageUrl != null
+                          ? CachedNetworkImage(
+                              imageUrl: imageUrl,
+                              fit: BoxFit.cover,
+                              width: double.infinity,
+                              height: double.infinity,
+                              fadeInDuration: Duration.zero,
+                              fadeOutDuration: Duration.zero,
+                              placeholder: (_, __) => Center(
+                                child: Icon(
+                                  MdiIcons.bookOutline,
+                                  size: 48,
+                                  color: colorScheme.onSurfaceVariant,
+                                ),
+                              ),
+                              errorWidget: (_, __, ___) => Center(
+                                child: Icon(
+                                  MdiIcons.bookOutline,
+                                  size: 48,
+                                  color: colorScheme.onSurfaceVariant,
+                                ),
+                              ),
+                            )
+                          : Center(
+                              child: Icon(
+                                MdiIcons.bookOutline,
+                                size: 48,
+                                color: colorScheme.onSurfaceVariant,
+                              ),
+                            ),
+                    ),
+                  ),
+                ),
+                // Progress indicator
+                if (book.progress > 0)
+                  Positioned(
+                    bottom: 0,
+                    left: 0,
+                    right: 0,
+                    child: LinearProgressIndicator(
+                      value: book.progress,
+                      backgroundColor: Colors.black54,
+                      valueColor: AlwaysStoppedAnimation<Color>(colorScheme.primary),
+                      minHeight: 3,
+                    ),
+                  ),
+              ],
+            ),
+          ),
+          const SizedBox(height: 8),
+          Hero(
+            tag: HeroTags.audiobookTitle + (book.uri ?? book.itemId) + '_$heroSuffix',
+            child: Material(
+              color: Colors.transparent,
+              child: Text(
+                book.name,
+                style: textTheme.titleSmall?.copyWith(
+                  color: colorScheme.onSurface,
+                  fontWeight: FontWeight.w500,
+                ),
+                maxLines: 2,
+                overflow: TextOverflow.ellipsis,
+              ),
+            ),
+          ),
+          if (book.authorsString.isNotEmpty && book.authorsString != S.of(context)!.unknownAuthor)
+            Text(
+              book.authorsString,
+              style: textTheme.bodySmall?.copyWith(
+                color: colorScheme.onSurface.withOpacity(0.6),
+              ),
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+            ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildAudiobookListTile(Audiobook book, MusicAssistantProvider maProvider) {
+    final imageUrl = maProvider.getImageUrl(book, size: 128);
+    final colorScheme = Theme.of(context).colorScheme;
+    final textTheme = Theme.of(context).textTheme;
+    final heroSuffix = 'series_${widget.series.id}';
+
+    return ListTile(
+      contentPadding: const EdgeInsets.symmetric(horizontal: 12, vertical: 4),
+      leading: Hero(
+        tag: HeroTags.audiobookCover + (book.uri ?? book.itemId) + '_$heroSuffix',
+        child: ClipRRect(
+          borderRadius: BorderRadius.circular(4),
+          child: Stack(
+            children: [
+              Container(
+                width: 56,
+                height: 56,
+                color: colorScheme.surfaceContainerHighest,
+                child: imageUrl != null
+                    ? CachedNetworkImage(
+                        imageUrl: imageUrl,
+                        fit: BoxFit.cover,
+                        fadeInDuration: Duration.zero,
+                        fadeOutDuration: Duration.zero,
+                        placeholder: (_, __) => Icon(
+                          MdiIcons.bookOutline,
+                          color: colorScheme.onSurfaceVariant,
+                        ),
+                        errorWidget: (_, __, ___) => Icon(
+                          MdiIcons.bookOutline,
+                          color: colorScheme.onSurfaceVariant,
+                        ),
+                      )
+                    : Icon(
+                        MdiIcons.bookOutline,
+                        color: colorScheme.onSurfaceVariant,
+                      ),
+              ),
+              if (book.progress > 0)
+                Positioned(
+                  bottom: 0,
+                  left: 0,
+                  right: 0,
+                  child: LinearProgressIndicator(
+                    value: book.progress,
+                    backgroundColor: Colors.black54,
+                    valueColor: AlwaysStoppedAnimation<Color>(colorScheme.primary),
+                    minHeight: 2,
+                  ),
+                ),
+            ],
+          ),
+        ),
+      ),
+      title: Hero(
+        tag: HeroTags.audiobookTitle + (book.uri ?? book.itemId) + '_$heroSuffix',
+        child: Material(
+          color: Colors.transparent,
+          child: Text(
+            book.name,
+            style: textTheme.titleMedium?.copyWith(
+              color: colorScheme.onSurface,
+              fontWeight: FontWeight.w500,
+            ),
+            maxLines: 1,
+            overflow: TextOverflow.ellipsis,
+          ),
+        ),
+      ),
+      subtitle: Text(
+        book.authorsString.isNotEmpty && book.authorsString != S.of(context)!.unknownAuthor
+            ? book.authorsString
+            : book.duration != null
+                ? _formatDuration(book.duration!)
+                : '',
+        style: textTheme.bodySmall?.copyWith(
+          color: colorScheme.onSurface.withOpacity(0.7),
+        ),
+        maxLines: 1,
+        overflow: TextOverflow.ellipsis,
+      ),
+      trailing: book.progress > 0
+          ? Text(
+              '${(book.progress * 100).toInt()}%',
+              style: textTheme.bodySmall?.copyWith(
+                color: colorScheme.primary,
+              ),
+            )
+          : null,
+      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix, initialImageUrl: imageUrl),
+    );
+  }
+
+  void _navigateToAudiobook(Audiobook book, {String? heroTagSuffix, String? initialImageUrl}) {
+    Navigator.push(
+      context,
+      FadeSlidePageRoute(
+        child: AudiobookDetailScreen(
+          audiobook: book,
+          heroTagSuffix: heroTagSuffix,
+          initialImageUrl: initialImageUrl,
+        ),
+      ),
+    );
+  }
+
+  String _formatDuration(Duration duration) {
+    final hours = duration.inHours;
+    final minutes = duration.inMinutes % 60;
+    if (hours > 0) {
+      return '${hours}h ${minutes}m';
+    }
+    return '${minutes}m';
+  }
+}

lib/screens/debug_log_screen.dart

@@ -5,6 +5,7 @@ import 'package:share_plus/share_plus.dart';
 import '../services/debug_logger.dart';
 import '../providers/music_assistant_provider.dart';
 import '../widgets/global_player_overlay.dart';
+import '../l10n/app_localizations.dart';
 
 class DebugLogScreen extends StatefulWidget {
   const DebugLogScreen({super.key});
@@ -42,10 +43,10 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
   void _copyLogs() {
     Clipboard.setData(ClipboardData(text: _logger.getAllLogs()));
     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),
       ),
     );
   }
@@ -58,7 +59,7 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
 
       await Share.share(
         report,
-        subject: 'Ensemble Bug Report',
+        subject: S.of(context)!.ensembleBugReport,
       );
     } finally {
       if (mounted) {
@@ -72,9 +73,9 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
       _logger.clear();
     });
     ScaffoldMessenger.of(context).showSnackBar(
-      const SnackBar(
-        content: Text('Logs cleared'),
-        duration: Duration(seconds: 1),
+      SnackBar(
+        content: Text(S.of(context)!.logsCleared),
+        duration: const Duration(seconds: 1),
       ),
     );
   }
@@ -93,7 +94,7 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
         builder: (context) => AlertDialog(
           backgroundColor: const Color(0xFF2a2a2a),
           title: Text(
-            'All Players (${allPlayers.length})',
+            S.of(context)!.allPlayersCount(allPlayers.length),
             style: const TextStyle(color: Colors.white),
           ),
           content: SizedBox(
@@ -153,27 +154,27 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
                       crossAxisAlignment: CrossAxisAlignment.start,
                       children: [
                         Text(
-                          'ID: ${player.playerId}',
+                          S.of(context)!.playerId(player.playerId),
                           style: const TextStyle(color: Colors.white70, fontSize: 11),
                         ),
                         Text(
-                          'Available: ${player.available} | Provider: ${player.provider}',
+                          S.of(context)!.playerInfo(player.available.toString(), player.provider ?? 'unknown'),
                           style: const TextStyle(color: Colors.white70, fontSize: 11),
                         ),
                         if (isCurrentPlayer)
-                          const Text(
-                            '← This device',
-                            style: TextStyle(color: Colors.green, fontSize: 11, fontWeight: FontWeight.bold),
+                          Text(
+                            S.of(context)!.thisDevice,
+                            style: const TextStyle(color: Colors.green, fontSize: 11, fontWeight: FontWeight.bold),
                           ),
                         if (isGhost && !isCorrupt)
-                          const Text(
-                            '⚠️ Ghost player (duplicate)',
-                            style: TextStyle(color: Colors.red, fontSize: 11),
+                          Text(
+                            S.of(context)!.ghostPlayer,
+                            style: const TextStyle(color: Colors.red, fontSize: 11),
                           ),
                         if (isCorrupt)
-                          const Text(
-                            '⚠️ Unavailable/Corrupt',
-                            style: TextStyle(color: Colors.orange, fontSize: 11),
+                          Text(
+                            S.of(context)!.unavailableCorrupt,
+                            style: const TextStyle(color: Colors.orange, fontSize: 11),
                           ),
                       ],
                     ),
@@ -195,15 +196,15 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
                 if (context.mounted) {
                   Navigator.pop(context);
                   ScaffoldMessenger.of(context).showSnackBar(
-                    const SnackBar(content: Text('Player list copied to clipboard!')),
+                    SnackBar(content: Text(S.of(context)!.playerListCopied)),
                   );
                 }
               },
-              child: const Text('Copy List'),
+              child: Text(S.of(context)!.copyList),
             ),
             TextButton(
               onPressed: () => Navigator.pop(context),
-              child: const Text('Close'),
+              child: Text(S.of(context)!.close),
             ),
           ],
         ),
@@ -211,7 +212,7 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
     } catch (e) {
       if (mounted) {
         ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Error loading players: $e')),
+          SnackBar(content: Text(S.of(context)!.errorLoadingPlayers(e.toString()))),
         );
       }
     }
@@ -229,9 +230,9 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
           onPressed: () => Navigator.pop(context),
           color: Colors.white,
         ),
-        title: const Text(
-          'Debug Logs',
-          style: TextStyle(
+        title: Text(
+          S.of(context)!.debugLogs,
+          style: const TextStyle(
             color: Colors.white,
             fontSize: 20,
             fontWeight: FontWeight.w300,
@@ -256,11 +257,11 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
                   icon: const Icon(Icons.share_rounded),
                   onPressed: _shareBugReport,
                   color: Colors.white,
-                  tooltip: 'Share bug report',
+                  tooltip: S.of(context)!.shareBugReport,
                 ),
           PopupMenuButton<String>(
             icon: const Icon(Icons.more_vert, color: Colors.white),
-            tooltip: 'More options',
+            tooltip: S.of(context)!.moreOptions,
             onSelected: (value) async {
               switch (value) {
                 case 'show_players':
@@ -275,27 +276,27 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
               }
             },
             itemBuilder: (context) => [
-              const PopupMenuItem(
+              PopupMenuItem(
                 value: 'show_players',
                 child: ListTile(
-                  leading: Icon(Icons.speaker_group_rounded),
-                  title: Text('View All Players'),
+                  leading: const Icon(Icons.speaker_group_rounded),
+                  title: Text(S.of(context)!.viewAllPlayers),
                   dense: true,
                 ),
               ),
-              const PopupMenuItem(
+              PopupMenuItem(
                 value: 'copy_logs',
                 child: ListTile(
-                  leading: Icon(Icons.copy_rounded),
-                  title: Text('Copy Logs'),
+                  leading: const Icon(Icons.copy_rounded),
+                  title: Text(S.of(context)!.copyLogs),
                   dense: true,
                 ),
               ),
-              const PopupMenuItem(
+              PopupMenuItem(
                 value: 'clear_logs',
                 child: ListTile(
-                  leading: Icon(Icons.delete_rounded),
-                  title: Text('Clear Logs'),
+                  leading: const Icon(Icons.delete_rounded),
+                  title: Text(S.of(context)!.clearLogs),
                   dense: true,
                 ),
               ),
@@ -317,20 +318,20 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
                   scrollDirection: Axis.horizontal,
                   child: Row(
                     children: [
-                      _buildFilterChip('All', LogLevel.debug),
+                      _buildFilterChip(S.of(context)!.all, LogLevel.debug),
                       const SizedBox(width: 8),
-                      _buildFilterChip('Info+', LogLevel.info),
+                      _buildFilterChip(S.of(context)!.infoPlus, LogLevel.info),
                       const SizedBox(width: 8),
-                      _buildFilterChip('Warnings', LogLevel.warning),
+                      _buildFilterChip(S.of(context)!.warnings, LogLevel.warning),
                       const SizedBox(width: 8),
-                      _buildFilterChip('Errors', LogLevel.error),
+                      _buildFilterChip(S.of(context)!.errors, LogLevel.error),
                     ],
                   ),
                 ),
                 const SizedBox(height: 8),
                 // Stats
                 Text(
-                  'Showing ${_filteredEntries.length} of ${_logger.entries.length} entries',
+                  S.of(context)!.showingEntries(_filteredEntries.length, _logger.entries.length),
                   style: const TextStyle(color: Colors.white54, fontSize: 11),
                 ),
               ],
@@ -338,10 +339,10 @@ class _DebugLogScreenState extends State<DebugLogScreen> {
           ),
           Expanded(
             child: _filteredEntries.isEmpty
-                ? const Center(
+                ? Center(
                     child: Text(
-                      'No logs yet',
-                      style: TextStyle(
+                      S.of(context)!.noLogsYet,
+                      style: const TextStyle(
                         color: Colors.white54,
                         fontSize: 16,
                       ),

lib/screens/home_screen.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:provider/provider.dart';
+import '../l10n/app_localizations.dart';
 import '../providers/navigation_provider.dart';
 import '../widgets/global_player_overlay.dart';
 import 'new_home_screen.dart';
@@ -39,7 +40,7 @@ class _HomeScreenState extends State<HomeScreen> {
     ScaffoldMessenger.of(context).clearSnackBars();
     ScaffoldMessenger.of(context).showSnackBar(
       SnackBar(
-        content: const Text('Press back again to minimize'),
+        content: Text(S.of(context)!.pressBackToMinimize),
         duration: const Duration(seconds: 2),
         behavior: SnackBarBehavior.floating,
         margin: const EdgeInsets.only(bottom: 80, left: 16, right: 16),
@@ -61,6 +62,18 @@ class _HomeScreenState extends State<HomeScreen> {
           onPopInvokedWithResult: (didPop, result) {
             if (didPop) return;
 
+            // If player reveal (device list) is visible, dismiss it first (with animation)
+            if (GlobalPlayerOverlay.isPlayerRevealVisible) {
+              GlobalPlayerOverlay.dismissPlayerReveal();
+              return;
+            }
+
+            // If queue panel is open, close it first (before collapsing player)
+            if (GlobalPlayerOverlay.isQueuePanelOpen) {
+              GlobalPlayerOverlay.closeQueuePanel();
+              return;
+            }
+
             // If global player is expanded, collapse it first
             if (GlobalPlayerOverlay.isPlayerExpanded) {
               GlobalPlayerOverlay.collapsePlayer();

lib/screens/library_albums_screen.dart

@@ -4,6 +4,7 @@ import '../providers/music_assistant_provider.dart';
 import '../models/media_item.dart';
 import '../widgets/album_card.dart';
 import '../widgets/common/empty_state.dart';
+import '../l10n/app_localizations.dart';
 
 class LibraryAlbumsScreen extends StatelessWidget {
   const LibraryAlbumsScreen({super.key});
@@ -25,7 +26,7 @@ class LibraryAlbumsScreen extends StatelessWidget {
           color: colorScheme.onBackground,
         ),
         title: Text(
-          'Albums',
+          S.of(context)!.albums,
           style: textTheme.headlineSmall?.copyWith(
             color: colorScheme.onBackground,
             fontWeight: FontWeight.w300,
@@ -46,7 +47,9 @@ class LibraryAlbumsScreen extends StatelessWidget {
   Widget _buildAlbumsList(BuildContext context, List<Album> albums, bool isLoading) {
     final colorScheme = Theme.of(context).colorScheme;
 
-    if (isLoading) {
+    // Show cached data immediately if available, even while loading
+    // Only show spinner if we have no data at all AND we're loading
+    if (albums.isEmpty && isLoading) {
       return Center(
         child: CircularProgressIndicator(color: colorScheme.primary),
       );
@@ -54,13 +57,14 @@ class LibraryAlbumsScreen extends StatelessWidget {
 
     if (albums.isEmpty) {
       return EmptyState.albums(
+        context: context,
         onRefresh: () => context.read<MusicAssistantProvider>().loadLibrary(),
       );
     }
 
     return RefreshIndicator(
       color: colorScheme.primary,
-      backgroundColor: colorScheme.surface,
+      backgroundColor: colorScheme.background,
       onRefresh: () async {
         await context.read<MusicAssistantProvider>().loadLibrary();
       },

lib/screens/library_artists_screen.dart

@@ -6,6 +6,7 @@ import '../utils/page_transitions.dart';
 import '../widgets/common/empty_state.dart';
 import '../widgets/artist_avatar.dart';
 import 'artist_details_screen.dart';
+import '../l10n/app_localizations.dart';
 
 class LibraryArtistsScreen extends StatelessWidget {
   const LibraryArtistsScreen({super.key});
@@ -27,7 +28,7 @@ class LibraryArtistsScreen extends StatelessWidget {
           color: colorScheme.onBackground,
         ),
         title: Text(
-          'Artists',
+          S.of(context)!.artists,
           style: textTheme.headlineSmall?.copyWith(
             color: colorScheme.onBackground,
             fontWeight: FontWeight.w300,
@@ -48,7 +49,9 @@ class LibraryArtistsScreen extends StatelessWidget {
   Widget _buildArtistsList(BuildContext context, List<Artist> artists, bool isLoading) {
     final colorScheme = Theme.of(context).colorScheme;
 
-    if (isLoading) {
+    // Show cached data immediately if available, even while loading
+    // Only show spinner if we have no data at all AND we're loading
+    if (artists.isEmpty && isLoading) {
       return Center(
         child: CircularProgressIndicator(color: colorScheme.primary),
       );
@@ -56,13 +59,14 @@ class LibraryArtistsScreen extends StatelessWidget {
 
     if (artists.isEmpty) {
       return EmptyState.artists(
+        context: context,
         onRefresh: () => context.read<MusicAssistantProvider>().loadLibrary(),
       );
     }
 
     return RefreshIndicator(
       color: colorScheme.primary,
-      backgroundColor: colorScheme.surface,
+      backgroundColor: colorScheme.background,
       onRefresh: () async {
         await context.read<MusicAssistantProvider>().loadLibrary();
       },

lib/screens/library_playlists_screen.dart

@@ -5,6 +5,7 @@ import '../providers/music_assistant_provider.dart';
 import '../models/media_item.dart';
 import '../widgets/common/empty_state.dart';
 import 'playlist_details_screen.dart';
+import '../l10n/app_localizations.dart';
 
 class LibraryPlaylistsScreen extends StatefulWidget {
   const LibraryPlaylistsScreen({super.key});
@@ -29,17 +30,11 @@ class _LibraryPlaylistsScreenState extends State<LibraryPlaylistsScreen> {
     });
 
     final maProvider = context.read<MusicAssistantProvider>();
-    if (maProvider.api != null) {
-      final playlists = await maProvider.api!.getPlaylists(limit: 100);
-      setState(() {
-        _playlists = playlists;
-        _isLoading = false;
-      });
-    } else {
-      setState(() {
-        _isLoading = false;
-      });
-    }
+    final playlists = await maProvider.getPlaylists(limit: 100);
+    setState(() {
+      _playlists = playlists;
+      _isLoading = false;
+    });
   }
 
   @override
@@ -59,7 +54,7 @@ class _LibraryPlaylistsScreenState extends State<LibraryPlaylistsScreen> {
           color: colorScheme.onBackground,
         ),
         title: Text(
-          'Playlists',
+          S.of(context)!.playlists,
           style: textTheme.headlineSmall?.copyWith(
             color: colorScheme.onBackground,
             fontWeight: FontWeight.w300,
@@ -74,19 +69,21 @@ class _LibraryPlaylistsScreenState extends State<LibraryPlaylistsScreen> {
   Widget _buildPlaylistsList(BuildContext context, MusicAssistantProvider provider) {
     final colorScheme = Theme.of(context).colorScheme;
 
-    if (_isLoading) {
+    // Show cached data immediately if available, even while loading
+    // Only show spinner if we have no data at all AND we're loading
+    if (_playlists.isEmpty && _isLoading) {
       return Center(
         child: CircularProgressIndicator(color: colorScheme.primary),
       );
     }
 
     if (_playlists.isEmpty) {
-      return EmptyState.playlists(onRefresh: _loadPlaylists);
+      return EmptyState.playlists(context: context, onRefresh: _loadPlaylists);
     }
 
     return RefreshIndicator(
       color: colorScheme.primary,
-      backgroundColor: colorScheme.surface,
+      backgroundColor: colorScheme.background,
       onRefresh: _loadPlaylists,
       child: ListView.builder(
         itemCount: _playlists.length,
@@ -138,8 +135,8 @@ class _LibraryPlaylistsScreenState extends State<LibraryPlaylistsScreen> {
         ),
         subtitle: Text(
           playlist.trackCount != null
-              ? '${playlist.trackCount} tracks'
-              : playlist.owner ?? 'Playlist',
+              ? '${playlist.trackCount} ${S.of(context)!.tracks}'
+              : playlist.owner ?? S.of(context)!.playlist,
           style: textTheme.bodySmall?.copyWith(
             color: colorScheme.onSurface.withOpacity(0.7),
           ),

lib/screens/library_tracks_screen.dart

@@ -4,6 +4,7 @@ import 'package:cached_network_image/cached_network_image.dart';
 import '../providers/music_assistant_provider.dart';
 import '../models/media_item.dart';
 import '../widgets/common/empty_state.dart';
+import '../l10n/app_localizations.dart';
 
 class LibraryTracksScreen extends StatelessWidget {
   const LibraryTracksScreen({super.key});
@@ -25,7 +26,7 @@ class LibraryTracksScreen extends StatelessWidget {
           color: colorScheme.onBackground,
         ),
         title: Text(
-          'Tracks',
+          S.of(context)!.tracks,
           style: textTheme.headlineSmall?.copyWith(
             color: colorScheme.onBackground,
             fontWeight: FontWeight.w300,
@@ -41,14 +42,16 @@ class LibraryTracksScreen extends StatelessWidget {
       BuildContext context, MusicAssistantProvider provider) {
     final colorScheme = Theme.of(context).colorScheme;
 
-    if (provider.isLoading) {
+    // Show cached data immediately if available, even while loading
+    // Only show spinner if we have no data at all AND we're loading
+    if (provider.tracks.isEmpty && provider.isLoading) {
       return Center(
         child: CircularProgressIndicator(color: colorScheme.primary),
       );
     }
 
     if (provider.tracks.isEmpty) {
-      return EmptyState.tracks(onRefresh: provider.loadLibrary);
+      return EmptyState.tracks(context: context, onRefresh: provider.loadLibrary);
     }
 
     return ListView.builder(
@@ -129,7 +132,7 @@ class LibraryTracksScreen extends StatelessWidget {
 
     if (maProvider.selectedPlayer == null) {
       ScaffoldMessenger.of(context).showSnackBar(
-        const SnackBar(content: Text('No player selected')),
+        SnackBar(content: Text(S.of(context)!.noPlayerSelected)),
       );
       return;
     }

lib/screens/login_screen.dart

@@ -2,9 +2,12 @@ import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import '../providers/music_assistant_provider.dart';
 import '../services/settings_service.dart';
+import '../services/database_service.dart';
+import '../services/profile_service.dart';
 import '../services/auth/auth_strategy.dart';
 import '../services/debug_logger.dart';
 import '../widgets/debug/debug_console.dart';
+import '../l10n/app_localizations.dart';
 import 'home_screen.dart';
 
 class LoginScreen extends StatefulWidget {
@@ -30,6 +33,8 @@ class _LoginScreenState extends State<LoginScreen> {
   String? _error;
   bool _showDebug = false;
   List<String> _debugLogs = [];
+  String? _resolvedServerUrl; // The actual URL after fallback (e.g., HTTP if HTTPS failed)
+  bool _usedHttpFallback = false; // True if HTTPS failed and we fell back to HTTP
 
   @override
   void initState() {
@@ -94,10 +99,27 @@ class _LoginScreenState extends State<LoginScreen> {
       return 'http://$url';
     }
 
+    // Tailscale URLs (*.ts.net) - default to http:// since VPN tunnel is already encrypted
+    if (url.endsWith('.ts.net') || url.contains('.ts.net:')) {
+      return 'http://$url';
+    }
+
     // For domain names, default to https://
     return 'https://$url';
   }
 
+  /// Check if the URL is using HTTP (for security warning display)
+  bool _isHttpConnection(String url) {
+    final normalized = _normalizeServerUrl(url);
+    return normalized.startsWith('http://') && !normalized.startsWith('https://');
+  }
+
+  /// Check if the URL is a Tailscale URL (safe for HTTP)
+  bool _isTailscaleUrl(String url) {
+    final normalized = url.trim().toLowerCase();
+    return normalized.contains('.ts.net');
+  }
+
   String _buildServerUrl() {
     // Normalize the base URL
     var url = _normalizeServerUrl(_serverUrlController.text.trim());
@@ -137,7 +159,7 @@ class _LoginScreenState extends State<LoginScreen> {
   Future<void> _detectAuthRequirements() async {
     if (_serverUrlController.text.trim().isEmpty) {
       setState(() {
-        _error = 'Please enter your Music Assistant server address';
+        _error = S.of(context)!.pleaseEnterServerAddress;
       });
       return;
     }
@@ -147,6 +169,8 @@ class _LoginScreenState extends State<LoginScreen> {
       _error = null;
       _detectedAuthStrategy = null;
       _detectedAuthType = null;
+      _resolvedServerUrl = null;
+      _usedHttpFallback = false;
       _debugLogs.clear();
     });
 
@@ -160,11 +184,18 @@ class _LoginScreenState extends State<LoginScreen> {
       // Auto-detect authentication requirements
       final strategy = await provider.authManager.detectAuthStrategy(serverUrl);
 
+      // Check if auth manager used a different URL (e.g., HTTP fallback)
+      final resolvedUrl = provider.authManager.lastSuccessfulUrl;
+      if (resolvedUrl != null && resolvedUrl != serverUrl) {
+        _addDebugLog('URL resolved via fallback: $resolvedUrl');
+        _usedHttpFallback = serverUrl.startsWith('https://') && resolvedUrl.startsWith('http://');
+      }
+
       _addDebugLog('Detection complete. Strategy: ${strategy?.name ?? 'null'}');
 
       if (strategy == null) {
         setState(() {
-          _error = 'Cannot determine authentication requirements. Please check server URL.';
+          _error = S.of(context)!.cannotDetermineAuth;
           _isDetectingAuth = false;
         });
         return;
@@ -173,6 +204,7 @@ class _LoginScreenState extends State<LoginScreen> {
       setState(() {
         _detectedAuthStrategy = strategy;
         _detectedAuthType = _getAuthTypeName(strategy.name);
+        _resolvedServerUrl = resolvedUrl;
         _isDetectingAuth = false;
       });
 
@@ -199,13 +231,13 @@ class _LoginScreenState extends State<LoginScreen> {
   String _getAuthTypeName(String strategyName) {
     switch (strategyName) {
       case 'none':
-        return 'No Authentication';
+        return S.of(context)!.noAuthentication;
       case 'basic':
-        return 'HTTP Basic Auth';
+        return S.of(context)!.httpBasicAuth;
       case 'authelia':
-        return 'Authelia';
+        return S.of(context)!.authelia;
       case 'music_assistant':
-        return 'Music Assistant Login';
+        return S.of(context)!.musicAssistantLogin;
       default:
         return 'Unknown';
     }
@@ -229,7 +261,7 @@ class _LoginScreenState extends State<LoginScreen> {
   Future<void> _connect() async {
     if (_serverUrlController.text.trim().isEmpty) {
       setState(() {
-        _error = 'Please enter your Music Assistant server address';
+        _error = S.of(context)!.pleaseEnterServerAddress;
       });
       return;
     }
@@ -239,7 +271,7 @@ class _LoginScreenState extends State<LoginScreen> {
     final isMaAuth = _detectedAuthStrategy?.name == 'music_assistant';
     if (!isMaAuth && _ownerNameController.text.trim().isEmpty) {
       setState(() {
-        _error = 'Please enter your name';
+        _error = S.of(context)!.pleaseEnterName;
       });
       return;
     }
@@ -250,7 +282,9 @@ class _LoginScreenState extends State<LoginScreen> {
     });
 
     try {
-      final serverUrl = _buildServerUrl();
+      // Use the resolved URL if available (e.g., from HTTP fallback), otherwise build it
+      final serverUrl = _resolvedServerUrl ?? _buildServerUrl();
+      _addDebugLog('Using server URL for connection: $serverUrl');
       final port = _portController.text.trim();
 
       // Validate port (if provided)
@@ -259,7 +293,7 @@ class _LoginScreenState extends State<LoginScreen> {
         portNum = int.tryParse(port);
         if (portNum == null || portNum < 1 || portNum > 65535) {
           setState(() {
-            _error = 'Please enter a valid port number (1-65535)';
+            _error = S.of(context)!.pleaseEnterValidPort;
             _isConnecting = false;
           });
           return;
@@ -269,7 +303,13 @@ class _LoginScreenState extends State<LoginScreen> {
       // Save owner name (if provided) and port to settings
       // For MA auth, the owner name will be set from user profile after login
       if (!isMaAuth && _ownerNameController.text.trim().isNotEmpty) {
-        await SettingsService.setOwnerName(_ownerNameController.text.trim());
+        final ownerName = _ownerNameController.text.trim();
+        await SettingsService.setOwnerName(ownerName);
+
+        // Create/activate profile in local database for manual name entry
+        if (DatabaseService.instance.isInitialized) {
+          await ProfileService.instance.onManualNameEntered(ownerName);
+        }
       }
       await SettingsService.setWebSocketPort(portNum);
 
@@ -285,7 +325,7 @@ class _LoginScreenState extends State<LoginScreen> {
 
         if (username.isEmpty || password.isEmpty) {
           setState(() {
-            _error = 'Please enter username and password';
+            _error = S.of(context)!.pleaseEnterCredentials;
             _isConnecting = false;
           });
           return;
@@ -311,7 +351,7 @@ class _LoginScreenState extends State<LoginScreen> {
 
         if (!success) {
           setState(() {
-            _error = 'Authentication failed. Please check your credentials.';
+            _error = S.of(context)!.authFailed;
             _isConnecting = false;
           });
           return;
@@ -345,7 +385,7 @@ class _LoginScreenState extends State<LoginScreen> {
 
         if (username.isEmpty || password.isEmpty) {
           setState(() {
-            _error = 'Please enter username and password';
+            _error = S.of(context)!.pleaseEnterCredentials;
             _isConnecting = false;
           });
           return;
@@ -369,7 +409,7 @@ class _LoginScreenState extends State<LoginScreen> {
 
           if (accessToken == null) {
             setState(() {
-              _error = 'Music Assistant login failed. Please check your credentials.';
+              _error = S.of(context)!.maLoginFailed;
               _isConnecting = false;
             });
             return;
@@ -403,6 +443,18 @@ class _LoginScreenState extends State<LoginScreen> {
       }
 
       if (provider.isConnected) {
+        // For first-time users, wait for player selection so the welcome
+        // overlay can appear immediately without home screen flash.
+        // This matches the logic in AppStartup._checkAndConnect().
+        final hasCompletedOnboarding = await SettingsService.getHasCompletedOnboarding();
+        if (!hasCompletedOnboarding) {
+          // First-time user: wait for connection + player selection
+          for (int i = 0; i < 20; i++) {
+            await Future.delayed(const Duration(milliseconds: 250));
+            if (provider.selectedPlayer != null) break;
+          }
+        }
+
         // Navigate to home screen
         if (mounted) {
           // Ensure keyboard is closed before navigating
@@ -413,7 +465,7 @@ class _LoginScreenState extends State<LoginScreen> {
         }
       } else {
         setState(() {
-          _error = 'Could not connect to server. Please check the address and try again.';
+          _error = S.of(context)!.connectionFailed;
           _isConnecting = false;
         });
       }
@@ -461,7 +513,7 @@ class _LoginScreenState extends State<LoginScreen> {
 
               // Server URL
               Text(
-                'Server Address',
+                S.of(context)!.serverAddress,
                 style: textTheme.titleMedium?.copyWith(
                   color: colorScheme.onBackground,
                   fontWeight: FontWeight.w500,
@@ -473,7 +525,7 @@ class _LoginScreenState extends State<LoginScreen> {
                 controller: _serverUrlController,
                 style: TextStyle(color: colorScheme.onSurface),
                 decoration: InputDecoration(
-                  hintText: 'e.g., music.example.com or 192.168.1.100',
+                  hintText: S.of(context)!.serverAddressHint,
                   hintStyle: TextStyle(color: colorScheme.onSurface.withOpacity(0.38)),
                   filled: true,
                   fillColor: colorScheme.surfaceVariant.withOpacity(0.3),
@@ -500,7 +552,7 @@ class _LoginScreenState extends State<LoginScreen> {
               if (_detectedAuthStrategy != null &&
                   _detectedAuthStrategy!.name != 'music_assistant') ...[
                 Text(
-                  'Your Name',
+                  S.of(context)!.yourName,
                   style: textTheme.titleMedium?.copyWith(
                     color: colorScheme.onBackground,
                     fontWeight: FontWeight.w500,
@@ -512,7 +564,7 @@ class _LoginScreenState extends State<LoginScreen> {
                   controller: _ownerNameController,
                   style: TextStyle(color: colorScheme.onSurface),
                   decoration: InputDecoration(
-                    hintText: 'Your first name',
+                    hintText: S.of(context)!.yourFirstName,
                     hintStyle: TextStyle(color: colorScheme.onSurface.withOpacity(0.38)),
                     filled: true,
                     fillColor: colorScheme.surfaceVariant.withOpacity(0.3),
@@ -535,7 +587,7 @@ class _LoginScreenState extends State<LoginScreen> {
 
               // Port
               Text(
-                'Port (Optional)',
+                S.of(context)!.portOptional,
                 style: textTheme.titleMedium?.copyWith(
                   color: colorScheme.onBackground,
                   fontWeight: FontWeight.w500,
@@ -543,7 +595,7 @@ class _LoginScreenState extends State<LoginScreen> {
               ),
               const SizedBox(height: 8),
               Text(
-                'Leave blank for reverse proxy or standard ports. Enter 8095 for direct connection.',
+                S.of(context)!.portDescription,
                 style: TextStyle(
                   color: colorScheme.onBackground.withOpacity(0.6),
                   fontSize: 12,
@@ -555,7 +607,7 @@ class _LoginScreenState extends State<LoginScreen> {
                 controller: _portController,
                 style: TextStyle(color: colorScheme.onSurface),
                 decoration: InputDecoration(
-                  hintText: 'e.g., 8095 or leave blank',
+                  hintText: S.of(context)!.portHint,
                   hintStyle: TextStyle(color: colorScheme.onSurface.withOpacity(0.38)),
                   filled: true,
                   fillColor: colorScheme.surfaceVariant.withOpacity(0.3),
@@ -600,7 +652,7 @@ class _LoginScreenState extends State<LoginScreen> {
                           crossAxisAlignment: CrossAxisAlignment.start,
                           children: [
                             Text(
-                              'Detected: $_detectedAuthType',
+                              S.of(context)!.detectedAuthType(_detectedAuthType!),
                               style: TextStyle(
                                 color: needsAuth
                                     ? colorScheme.onPrimaryContainer
@@ -613,7 +665,7 @@ class _LoginScreenState extends State<LoginScreen> {
                               Padding(
                                 padding: const EdgeInsets.only(top: 4),
                                 child: Text(
-                                  'This server requires authentication',
+                                  S.of(context)!.serverRequiresAuth,
                                   style: TextStyle(
                                     color: colorScheme.onPrimaryContainer.withOpacity(0.7),
                                     fontSize: 12,
@@ -627,12 +679,77 @@ class _LoginScreenState extends State<LoginScreen> {
                   ),
                 ),
 
+              // HTTP connection info banner
+              if (_resolvedServerUrl != null && _isHttpConnection(_resolvedServerUrl!))
+                Container(
+                  padding: const EdgeInsets.all(16),
+                  margin: const EdgeInsets.only(bottom: 24),
+                  decoration: BoxDecoration(
+                    color: _isTailscaleUrl(_serverUrlController.text)
+                        ? colorScheme.secondaryContainer.withOpacity(0.3)
+                        : colorScheme.errorContainer.withOpacity(0.3),
+                    borderRadius: BorderRadius.circular(12),
+                    border: _isTailscaleUrl(_serverUrlController.text)
+                        ? null
+                        : Border.all(color: colorScheme.error.withOpacity(0.3)),
+                  ),
+                  child: Row(
+                    children: [
+                      Icon(
+                        _isTailscaleUrl(_serverUrlController.text)
+                            ? Icons.vpn_lock_rounded
+                            : Icons.warning_amber_rounded,
+                        color: _isTailscaleUrl(_serverUrlController.text)
+                            ? colorScheme.secondary
+                            : colorScheme.error,
+                        size: 24,
+                      ),
+                      const SizedBox(width: 12),
+                      Expanded(
+                        child: Column(
+                          crossAxisAlignment: CrossAxisAlignment.start,
+                          children: [
+                            Text(
+                              _isTailscaleUrl(_serverUrlController.text)
+                                  ? S.of(context)!.tailscaleVpnConnection
+                                  : S.of(context)!.unencryptedConnection,
+                              style: TextStyle(
+                                color: _isTailscaleUrl(_serverUrlController.text)
+                                    ? colorScheme.onSecondaryContainer
+                                    : colorScheme.onErrorContainer,
+                                fontSize: 14,
+                                fontWeight: FontWeight.w600,
+                              ),
+                            ),
+                            Padding(
+                              padding: const EdgeInsets.only(top: 4),
+                              child: Text(
+                                _isTailscaleUrl(_serverUrlController.text)
+                                    ? S.of(context)!.usingHttpOverTailscale
+                                    : _usedHttpFallback
+                                        ? S.of(context)!.httpsFailedUsingHttp
+                                        : S.of(context)!.httpNotEncrypted,
+                                style: TextStyle(
+                                  color: (_isTailscaleUrl(_serverUrlController.text)
+                                      ? colorScheme.onSecondaryContainer
+                                      : colorScheme.onErrorContainer).withOpacity(0.7),
+                                  fontSize: 12,
+                                ),
+                              ),
+                            ),
+                          ],
+                        ),
+                      ),
+                    ],
+                  ),
+                ),
+
               // Authentication fields (shown only if auth required)
               if (needsAuth) ...[
                 // Auth Server URL (only for Authelia)
                 if (_detectedAuthStrategy?.name == 'authelia') ...[
                   Text(
-                    'Auth Server URL (Optional)',
+                    S.of(context)!.authServerUrlOptional,
                     style: textTheme.titleMedium?.copyWith(
                       color: colorScheme.onBackground,
                       fontWeight: FontWeight.w500,
@@ -640,7 +757,7 @@ class _LoginScreenState extends State<LoginScreen> {
                   ),
                   const SizedBox(height: 8),
                   Text(
-                    'Leave empty if authentication is on the same server',
+                    S.of(context)!.authServerUrlDescription,
                     style: TextStyle(
                       color: colorScheme.onBackground.withOpacity(0.6),
                       fontSize: 12,
@@ -652,7 +769,7 @@ class _LoginScreenState extends State<LoginScreen> {
                     controller: _authServerUrlController,
                     style: TextStyle(color: colorScheme.onSurface),
                     decoration: InputDecoration(
-                      hintText: 'e.g., auth.example.com (if different from server)',
+                      hintText: S.of(context)!.authServerUrlHint,
                       hintStyle: TextStyle(color: colorScheme.onSurface.withOpacity(0.38)),
                       filled: true,
                       fillColor: colorScheme.surfaceVariant.withOpacity(0.3),
@@ -673,7 +790,7 @@ class _LoginScreenState extends State<LoginScreen> {
                 ],
 
                 Text(
-                  'Username',
+                  S.of(context)!.username,
                   style: textTheme.titleMedium?.copyWith(
                     color: colorScheme.onBackground,
                     fontWeight: FontWeight.w500,
@@ -686,7 +803,7 @@ class _LoginScreenState extends State<LoginScreen> {
                   focusNode: _usernameFocusNode,
                   style: TextStyle(color: colorScheme.onSurface),
                   decoration: InputDecoration(
-                    hintText: 'Username',
+                    hintText: S.of(context)!.username,
                     hintStyle: TextStyle(color: colorScheme.onSurface.withOpacity(0.38)),
                     filled: true,
                     fillColor: colorScheme.surfaceVariant.withOpacity(0.3),
@@ -706,7 +823,7 @@ class _LoginScreenState extends State<LoginScreen> {
                 const SizedBox(height: 16),
 
                 Text(
-                  'Password',
+                  S.of(context)!.password,
                   style: textTheme.titleMedium?.copyWith(
                     color: colorScheme.onBackground,
                     fontWeight: FontWeight.w500,
@@ -718,7 +835,7 @@ class _LoginScreenState extends State<LoginScreen> {
                   controller: _passwordController,
                   style: TextStyle(color: colorScheme.onSurface),
                   decoration: InputDecoration(
-                    hintText: 'Password',
+                    hintText: S.of(context)!.password,
                     hintStyle: TextStyle(color: colorScheme.onSurface.withOpacity(0.38)),
                     filled: true,
                     fillColor: colorScheme.surfaceVariant.withOpacity(0.3),
@@ -808,9 +925,9 @@ class _LoginScreenState extends State<LoginScreen> {
                             ),
                           ),
                           const SizedBox(width: 12),
-                          const Text(
-                            'Detecting authentication...',
-                            style: TextStyle(
+                          Text(
+                            S.of(context)!.detectingAuth,
+                            style: const TextStyle(
                               fontSize: 16,
                               fontWeight: FontWeight.bold,
                             ),
@@ -827,7 +944,7 @@ class _LoginScreenState extends State<LoginScreen> {
                             ),
                           )
                         : Text(
-                            _detectedAuthStrategy == null ? 'Detect & Connect' : 'Connect',
+                            _detectedAuthStrategy == null ? S.of(context)!.detectAndConnect : S.of(context)!.connect,
                             style: const TextStyle(
                               fontSize: 16,
                               fontWeight: FontWeight.bold,

lib/screens/new_home_screen.dart

@@ -1,14 +1,20 @@
 import 'package:flutter/material.dart';
 import 'package:flutter/scheduler.dart';
 import 'package:provider/provider.dart';
+import '../l10n/app_localizations.dart';
 import '../providers/music_assistant_provider.dart';
 import '../services/settings_service.dart';
 import '../services/debug_logger.dart';
+import '../services/sync_service.dart';
 import '../widgets/global_player_overlay.dart';
 import '../widgets/player_selector.dart';
 import '../widgets/album_row.dart';
 import '../widgets/artist_row.dart';
 import '../widgets/track_row.dart';
+import '../widgets/audiobook_row.dart';
+import '../widgets/series_row.dart';
+import '../widgets/playlist_row.dart';
+import '../widgets/radio_station_row.dart';
 import '../widgets/common/disconnected_state.dart';
 import 'settings_screen.dart';
 import 'search_screen.dart';
@@ -31,8 +37,14 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
   bool _showFavoriteAlbums = false;
   bool _showFavoriteArtists = false;
   bool _showFavoriteTracks = false;
-  // Random order for favorites (generated once per session)
-  late List<int> _favoritesOrder;
+  bool _showFavoritePlaylists = false;
+  bool _showFavoriteRadioStations = false;
+  // Audiobook rows (default off)
+  bool _showContinueListeningAudiobooks = false;
+  bool _showDiscoverAudiobooks = false;
+  bool _showDiscoverSeries = false;
+  // Row order (loaded from settings)
+  List<String> _homeRowOrder = List.from(SettingsService.defaultHomeRowOrder);
 
   @override
   bool get wantKeepAlive => true;
@@ -41,8 +53,6 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
   void initState() {
     super.initState();
     WidgetsBinding.instance.addObserver(this);
-    // Generate random order for favorites rows (0, 1, 2 shuffled)
-    _favoritesOrder = [0, 1, 2]..shuffle();
     _loadSettings();
   }
 
@@ -67,6 +77,12 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
     final showFavAlbums = await SettingsService.getShowFavoriteAlbums();
     final showFavArtists = await SettingsService.getShowFavoriteArtists();
     final showFavTracks = await SettingsService.getShowFavoriteTracks();
+    final showFavPlaylists = await SettingsService.getShowFavoritePlaylists();
+    final showFavRadio = await SettingsService.getShowFavoriteRadioStations();
+    final showContAudiobooks = await SettingsService.getShowContinueListeningAudiobooks();
+    final showDiscAudiobooks = await SettingsService.getShowDiscoverAudiobooks();
+    final showDiscSeries = await SettingsService.getShowDiscoverSeries();
+    final rowOrder = await SettingsService.getHomeRowOrder();
     if (mounted) {
       setState(() {
         _showRecentAlbums = showRecent;
@@ -75,6 +91,12 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
         _showFavoriteAlbums = showFavAlbums;
         _showFavoriteArtists = showFavArtists;
         _showFavoriteTracks = showFavTracks;
+        _showFavoritePlaylists = showFavPlaylists;
+        _showFavoriteRadioStations = showFavRadio;
+        _showContinueListeningAudiobooks = showContAudiobooks;
+        _showDiscoverAudiobooks = showDiscAudiobooks;
+        _showDiscoverSeries = showDiscSeries;
+        _homeRowOrder = rowOrder;
       });
     }
   }
@@ -84,6 +106,9 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
     final provider = context.read<MusicAssistantProvider>();
     provider.invalidateHomeCache();
 
+    // Force full library sync from MA API
+    await provider.forceLibrarySync();
+
     // Reload settings in case they changed
     await _loadSettings();
 
@@ -127,6 +152,28 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
         titleSpacing: 0,
         centerTitle: false,
         actions: [
+          // Sync indicator - shows when library is syncing in background
+          ListenableBuilder(
+            listenable: SyncService.instance,
+            builder: (context, _) {
+              if (!SyncService.instance.isSyncing) {
+                return const SizedBox.shrink();
+              }
+              return Padding(
+                padding: const EdgeInsets.only(right: 8.0),
+                child: SizedBox(
+                  width: 20,
+                  height: 20,
+                  child: CircularProgressIndicator(
+                    strokeWidth: 2,
+                    valueColor: AlwaysStoppedAnimation<Color>(
+                      Theme.of(context).colorScheme.primary.withOpacity(0.7),
+                    ),
+                  ),
+                ),
+              );
+            },
+          ),
           const PlayerSelector(),
         ],
       ),
@@ -135,19 +182,63 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
           selector: (_, p) => p.isConnected,
           builder: (context, isConnected, child) {
             final maProvider = context.read<MusicAssistantProvider>();
-            return !isConnected
-                ? DisconnectedState.full(
-                    onSettings: () => Navigator.push(
-                      context,
-                      MaterialPageRoute(builder: (context) => const SettingsScreen()),
+            final syncService = SyncService.instance;
+
+            // Show cached data even when not connected (if we have cache)
+            // Only show disconnected state if we have no cached data at all
+            if (!isConnected && !syncService.hasCache) {
+              return DisconnectedState.full(
+                context: context,
+                onSettings: () => Navigator.push(
+                  context,
+                  MaterialPageRoute(builder: (context) => const SettingsScreen()),
+                ),
+              );
+            }
+
+            return Stack(
+              children: [
+                // Main content
+                RefreshIndicator(
+                  onRefresh: _onRefresh,
+                  color: colorScheme.primary,
+                  backgroundColor: colorScheme.background,
+                  child: _buildConnectedView(context, maProvider),
+                ),
+                // Connecting banner overlay (doesn't affect layout)
+                // Hide when we have cached players - UI is functional during background reconnect
+                if (!isConnected && syncService.hasCache && !maProvider.hasCachedPlayers)
+                  Positioned(
+                    top: 0,
+                    left: 0,
+                    right: 0,
+                    child: Container(
+                      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 6),
+                      color: colorScheme.primaryContainer.withOpacity(0.9),
+                      child: Row(
+                        mainAxisAlignment: MainAxisAlignment.center,
+                        children: [
+                          SizedBox(
+                            width: 12,
+                            height: 12,
+                            child: CircularProgressIndicator(
+                              strokeWidth: 2,
+                              color: colorScheme.primary,
+                            ),
+                          ),
+                          const SizedBox(width: 8),
+                          Text(
+                            S.of(context)!.connecting,
+                            style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                              color: colorScheme.onPrimaryContainer,
+                            ),
+                          ),
+                        ],
+                      ),
                     ),
-                  )
-                : RefreshIndicator(
-                    onRefresh: _onRefresh,
-                    color: colorScheme.primary,
-                    backgroundColor: colorScheme.surface,
-                    child: _buildConnectedView(context, maProvider),
-                  );
+                  ),
+              ],
+            );
           },
         ),
       ),
@@ -160,14 +251,11 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
     // Use LayoutBuilder to get available screen height
     return LayoutBuilder(
       builder: (context, constraints) {
-        // Simple calculation: available height divided by 3 rows
-        // Each row includes its title, artwork, and info
+        // Each row is always 1/3 of screen height
+        // 1 row = 1/3, 2 rows = 2/3, 3 rows = full screen, 4+ rows scroll
         final availableHeight = constraints.maxHeight - BottomSpacing.withMiniPlayer;
         final rowHeight = availableHeight / 3;
 
-        // Build favorites rows in random order
-        final favoritesWidgets = _buildFavoritesRows(provider, rowHeight);
-
         // Use Android 12+ stretch overscroll effect
         return NotificationListener<ScrollNotification>(
           onNotification: (notification) {
@@ -192,37 +280,7 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
               child: Column(
                 key: _refreshKey,
                 crossAxisAlignment: CrossAxisAlignment.start,
-                children: [
-                  // Recently played albums (optional)
-                  if (_showRecentAlbums)
-                    AlbumRow(
-                      key: const ValueKey('recent-albums'),
-                      title: 'Recently Played',
-                      loadAlbums: () => provider.getRecentAlbumsWithCache(),
-                      rowHeight: rowHeight,
-                    ),
-
-                  // Discover Artists (optional)
-                  if (_showDiscoverArtists)
-                    ArtistRow(
-                      key: const ValueKey('discover-artists'),
-                      title: 'Discover Artists',
-                      loadArtists: () => provider.getDiscoverArtistsWithCache(),
-                      rowHeight: rowHeight,
-                    ),
-
-                  // Discover Albums (optional)
-                  if (_showDiscoverAlbums)
-                    AlbumRow(
-                      key: const ValueKey('discover-albums'),
-                      title: 'Discover Albums',
-                      loadAlbums: () => provider.getDiscoverAlbumsWithCache(),
-                      rowHeight: rowHeight,
-                    ),
-
-                  // Favorites rows in random order
-                  ...favoritesWidgets,
-                ],
+                children: _buildOrderedRows(provider, rowHeight),
               ),
             ),
           ),
@@ -231,51 +289,122 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
     );
   }
 
-  /// Build favorites rows in random order (order set once per session)
-  List<Widget> _buildFavoritesRows(MusicAssistantProvider provider, double rowHeight) {
-    // Create list of enabled favorites with their order index
-    final enabledFavorites = <MapEntry<int, Widget>>[];
+  /// Build rows in the user's configured order
+  List<Widget> _buildOrderedRows(MusicAssistantProvider provider, double rowHeight) {
+    final rows = <Widget>[];
 
-    if (_showFavoriteAlbums) {
-      enabledFavorites.add(MapEntry(
-        _favoritesOrder[0],
-        AlbumRow(
+    for (final rowId in _homeRowOrder) {
+      final widget = _buildRowWidget(rowId, provider, rowHeight);
+      if (widget != null) {
+        rows.add(widget);
+      }
+    }
+
+    return rows;
+  }
+
+  /// Build a single row widget by ID, returns null if row is disabled
+  Widget? _buildRowWidget(String rowId, MusicAssistantProvider provider, double rowHeight) {
+    switch (rowId) {
+      case 'recent-albums':
+        if (!_showRecentAlbums) return null;
+        return AlbumRow(
+          key: const ValueKey('recent-albums'),
+          title: S.of(context)!.recentlyPlayed,
+          loadAlbums: () => provider.getRecentAlbumsWithCache(),
+          getCachedAlbums: () => provider.getCachedRecentAlbums(),
+          rowHeight: rowHeight,
+        );
+      case 'discover-artists':
+        if (!_showDiscoverArtists) return null;
+        return ArtistRow(
+          key: const ValueKey('discover-artists'),
+          title: S.of(context)!.discoverArtists,
+          loadArtists: () => provider.getDiscoverArtistsWithCache(),
+          getCachedArtists: () => provider.getCachedDiscoverArtists(),
+          rowHeight: rowHeight,
+        );
+      case 'discover-albums':
+        if (!_showDiscoverAlbums) return null;
+        return AlbumRow(
+          key: const ValueKey('discover-albums'),
+          title: S.of(context)!.discoverAlbums,
+          loadAlbums: () => provider.getDiscoverAlbumsWithCache(),
+          getCachedAlbums: () => provider.getCachedDiscoverAlbums(),
+          rowHeight: rowHeight,
+        );
+      case 'continue-listening':
+        if (!_showContinueListeningAudiobooks) return null;
+        return AudiobookRow(
+          key: const ValueKey('continue-listening'),
+          title: S.of(context)!.continueListening,
+          loadAudiobooks: () => provider.getInProgressAudiobooksWithCache(),
+          getCachedAudiobooks: () => provider.getCachedInProgressAudiobooks(),
+          rowHeight: rowHeight,
+        );
+      case 'discover-audiobooks':
+        if (!_showDiscoverAudiobooks) return null;
+        return AudiobookRow(
+          key: const ValueKey('discover-audiobooks'),
+          title: S.of(context)!.discoverAudiobooks,
+          loadAudiobooks: () => provider.getDiscoverAudiobooksWithCache(),
+          getCachedAudiobooks: () => provider.getCachedDiscoverAudiobooks(),
+          rowHeight: rowHeight,
+        );
+      case 'discover-series':
+        if (!_showDiscoverSeries) return null;
+        return SeriesRow(
+          key: const ValueKey('discover-series'),
+          title: S.of(context)!.discoverSeries,
+          loadSeries: () => provider.getDiscoverSeriesWithCache(),
+          getCachedSeries: () => provider.getCachedDiscoverSeries(),
+          rowHeight: rowHeight,
+        );
+      case 'favorite-albums':
+        if (!_showFavoriteAlbums) return null;
+        return AlbumRow(
           key: const ValueKey('favorite-albums'),
-          title: 'Favorite Albums',
+          title: S.of(context)!.favoriteAlbums,
           loadAlbums: () => provider.getFavoriteAlbums(),
           rowHeight: rowHeight,
-        ),
-      ));
-    }
-
-    if (_showFavoriteArtists) {
-      enabledFavorites.add(MapEntry(
-        _favoritesOrder[1],
-        ArtistRow(
+        );
+      case 'favorite-artists':
+        if (!_showFavoriteArtists) return null;
+        return ArtistRow(
           key: const ValueKey('favorite-artists'),
-          title: 'Favorite Artists',
+          title: S.of(context)!.favoriteArtists,
           loadArtists: () => provider.getFavoriteArtists(),
           rowHeight: rowHeight,
-        ),
-      ));
-    }
-
-    if (_showFavoriteTracks) {
-      enabledFavorites.add(MapEntry(
-        _favoritesOrder[2],
-        TrackRow(
+        );
+      case 'favorite-tracks':
+        if (!_showFavoriteTracks) return null;
+        return TrackRow(
           key: const ValueKey('favorite-tracks'),
-          title: 'Favorite Tracks',
+          title: S.of(context)!.favoriteTracks,
           loadTracks: () => provider.getFavoriteTracks(),
           rowHeight: rowHeight,
-        ),
-      ));
+        );
+      case 'favorite-playlists':
+        if (!_showFavoritePlaylists) return null;
+        return PlaylistRow(
+          key: const ValueKey('favorite-playlists'),
+          title: S.of(context)!.favoritePlaylists,
+          loadPlaylists: () => provider.getFavoritePlaylists(),
+          heroTagSuffix: 'home',
+          rowHeight: rowHeight,
+        );
+      case 'favorite-radio-stations':
+        if (!_showFavoriteRadioStations) return null;
+        return RadioStationRow(
+          key: const ValueKey('favorite-radio-stations'),
+          title: S.of(context)!.favoriteRadioStations,
+          loadRadioStations: () => provider.getFavoriteRadioStations(),
+          heroTagSuffix: 'home',
+          rowHeight: rowHeight,
+        );
+      default:
+        return null;
     }
-
-    // Sort by the random order index
-    enabledFavorites.sort((a, b) => a.key.compareTo(b.key));
-
-    return enabledFavorites.map((e) => e.value).toList();
   }
 }
 

lib/screens/playlist_details_screen.dart

@@ -1,8 +1,10 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
+import '../l10n/app_localizations.dart';
 import '../models/media_item.dart';
 import '../providers/music_assistant_provider.dart';
 import '../services/debug_logger.dart';
+import '../services/recently_played_service.dart';
 
 final _playlistLogger = DebugLogger();
 
@@ -33,21 +35,48 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> {
   }
 
   Future<void> _loadTracks() async {
-    setState(() {
-      _isLoading = true;
-    });
-
     final maProvider = context.read<MusicAssistantProvider>();
-    final tracks = await maProvider.getPlaylistTracksWithCache(
-      widget.provider,
-      widget.itemId,
-    );
+    final cacheKey = '${widget.provider}_${widget.itemId}';
 
-    if (mounted) {
-      setState(() {
-        _tracks = tracks;
-        _isLoading = false;
-      });
+    // 1. Show cached data immediately (if available)
+    final cachedTracks = maProvider.getCachedPlaylistTracks(cacheKey);
+    if (cachedTracks != null && cachedTracks.isNotEmpty) {
+      if (mounted) {
+        setState(() {
+          _tracks = cachedTracks;
+          _isLoading = false;
+        });
+      }
+    } else {
+      setState(() => _isLoading = true);
+    }
+
+    // 2. Fetch fresh data in background (silent refresh)
+    try {
+      final freshTracks = await maProvider.getPlaylistTracksWithCache(
+        widget.provider,
+        widget.itemId,
+        forceRefresh: cachedTracks != null,
+      );
+
+      // 3. Update if we got different data
+      if (mounted && freshTracks.isNotEmpty) {
+        final tracksChanged = _tracks.length != freshTracks.length ||
+            (_tracks.isNotEmpty && freshTracks.isNotEmpty &&
+             _tracks.first.itemId != freshTracks.first.itemId);
+        if (tracksChanged || _tracks.isEmpty) {
+          setState(() {
+            _tracks = freshTracks;
+            _isLoading = false;
+          });
+        }
+      }
+    } catch (e) {
+      // Silent failure - keep showing cached data
+    }
+
+    if (mounted && _isLoading) {
+      setState(() => _isLoading = false);
     }
   }
 
@@ -60,7 +89,7 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> {
       // Use the selected player
       final player = maProvider.selectedPlayer;
       if (player == null) {
-        _showError('No player selected');
+        _showError(S.of(context)!.noPlayerSelected);
         return;
       }
 
@@ -70,10 +99,13 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> {
       await maProvider.playTracks(player.playerId, _tracks, startIndex: 0);
       _playlistLogger.info('Playlist queued successfully', context: 'Playlist');
 
+      // Record to local recently played (per-profile)
+      RecentlyPlayedService.instance.recordPlaylistPlayed(widget.playlist);
+
       if (mounted) {
         ScaffoldMessenger.of(context).showSnackBar(
           SnackBar(
-            content: Text('Playing ${widget.playlist.name}'),
+            content: Text(S.of(context)!.playing(widget.playlist.name)),
             duration: const Duration(seconds: 2),
           ),
         );
@@ -191,7 +223,7 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> {
                     child: ElevatedButton.icon(
                       onPressed: _isLoading ? null : _playPlaylist,
                       icon: const Icon(Icons.play_arrow_rounded),
-                      label: const Text('Play'),
+                      label: Text(S.of(context)!.play),
                       style: ElevatedButton.styleFrom(
                         backgroundColor: Colors.white,
                         foregroundColor: const Color(0xFF1a1a1a),
@@ -204,9 +236,9 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> {
                   ),
                   const SizedBox(height: 24),
                   // Tracks header
-                  const Text(
-                    'Tracks',
-                    style: TextStyle(
+                  Text(
+                    S.of(context)!.tracks,
+                    style: const TextStyle(
                       color: Colors.white,
                       fontSize: 18,
                       fontWeight: FontWeight.bold,
@@ -226,7 +258,7 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> {
                   ? SliverFillRemaining(
                       child: Center(
                         child: Text(
-                          'No tracks in playlist',
+                          S.of(context)!.noTracksInPlaylist,
                           style: TextStyle(
                             color: Colors.grey[600],
                             fontSize: 16,
@@ -323,7 +355,7 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> {
         onPressed: () async {
           final player = maProvider.selectedPlayer;
           if (player == null) {
-            _showError('No player selected');
+            _showError(S.of(context)!.noPlayerSelected);
             return;
           }
 
@@ -332,9 +364,9 @@ class _PlaylistDetailsScreenState extends State<PlaylistDetailsScreen> {
             await maProvider.playTracks(player.playerId, _tracks, startIndex: index);
             if (mounted) {
               ScaffoldMessenger.of(context).showSnackBar(
-                const SnackBar(
-                  content: Text('Playing track'),
-                  duration: Duration(seconds: 1),
+                SnackBar(
+                  content: Text(S.of(context)!.playingTrack),
+                  duration: const Duration(seconds: 1),
                 ),
               );
             }

lib/screens/podcast_detail_screen.dart

@@ -0,0 +1,873 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:material_design_icons_flutter/material_design_icons_flutter.dart';
+import '../models/media_item.dart';
+import '../providers/music_assistant_provider.dart';
+import '../widgets/global_player_overlay.dart';
+import '../widgets/player_picker_sheet.dart';
+import '../theme/palette_helper.dart';
+import '../theme/theme_provider.dart';
+import '../services/debug_logger.dart';
+import '../constants/hero_tags.dart';
+import '../l10n/app_localizations.dart';
+
+class PodcastDetailScreen extends StatefulWidget {
+  final MediaItem podcast;
+  final String? heroTagSuffix;
+  final String? initialImageUrl;
+
+  const PodcastDetailScreen({
+    super.key,
+    required this.podcast,
+    this.heroTagSuffix,
+    this.initialImageUrl,
+  });
+
+  @override
+  State<PodcastDetailScreen> createState() => _PodcastDetailScreenState();
+}
+
+class _PodcastDetailScreenState extends State<PodcastDetailScreen> {
+  final _logger = DebugLogger();
+  ColorScheme? _lightColorScheme;
+  ColorScheme? _darkColorScheme;
+  List<MediaItem> _episodes = [];
+  bool _isLoadingEpisodes = false;
+  bool _isDescriptionExpanded = false;
+  bool _isInLibrary = false;
+  String? _expandedEpisodeId; // Track which episode is expanded for actions
+
+  String get _heroTagSuffix => widget.heroTagSuffix != null ? '_${widget.heroTagSuffix}' : '';
+
+  @override
+  void initState() {
+    super.initState();
+    _isInLibrary = _checkIfInLibrary(widget.podcast);
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      Future.delayed(const Duration(milliseconds: 350), () {
+        if (mounted) {
+          _extractColors();
+        }
+      });
+      _loadEpisodes();
+    });
+  }
+
+  /// Check if podcast is in library
+  bool _checkIfInLibrary(MediaItem podcast) {
+    if (podcast.provider == 'library') return true;
+    return podcast.providerMappings?.any((m) => m.providerInstance == 'library') ?? false;
+  }
+
+  /// Toggle library status
+  Future<void> _toggleLibrary() async {
+    final maProvider = context.read<MusicAssistantProvider>();
+
+    try {
+      final newState = !_isInLibrary;
+      bool success;
+
+      if (newState) {
+        // Add to library - MUST use non-library provider
+        String? actualProvider;
+        String? actualItemId;
+
+        if (widget.podcast.providerMappings != null && widget.podcast.providerMappings!.isNotEmpty) {
+          // For adding to library, we MUST use a non-library provider
+          final nonLibraryMapping = widget.podcast.providerMappings!.where(
+            (m) => m.providerInstance != 'library' && m.providerDomain != 'library',
+          ).firstOrNull;
+
+          if (nonLibraryMapping != null) {
+            actualProvider = nonLibraryMapping.providerDomain;
+            actualItemId = nonLibraryMapping.itemId;
+          }
+        }
+
+        // Fallback to item's own provider if no non-library mapping found
+        if (actualProvider == null || actualItemId == null) {
+          if (widget.podcast.provider != 'library') {
+            actualProvider = widget.podcast.provider;
+            actualItemId = widget.podcast.itemId;
+          } else {
+            // Item is library-only, can't add
+            _logger.log('Cannot add to library: podcast is library-only');
+            return;
+          }
+        }
+
+        _logger.log('Adding podcast to library: provider=$actualProvider, itemId=$actualItemId');
+        success = await maProvider.addToLibrary(
+          mediaType: 'podcast',
+          provider: actualProvider,
+          itemId: actualItemId,
+        );
+      } else {
+        // Remove from library
+        int? libraryItemId;
+        if (widget.podcast.provider == 'library') {
+          libraryItemId = int.tryParse(widget.podcast.itemId);
+        } else if (widget.podcast.providerMappings != null) {
+          final libraryMapping = widget.podcast.providerMappings!.firstWhere(
+            (m) => m.providerInstance == 'library',
+            orElse: () => widget.podcast.providerMappings!.first,
+          );
+          if (libraryMapping.providerInstance == 'library') {
+            libraryItemId = int.tryParse(libraryMapping.itemId);
+          }
+        }
+
+        if (libraryItemId == null) {
+          _logger.log('Cannot remove from library: no library ID found');
+          return;
+        }
+
+        success = await maProvider.removeFromLibrary(
+          mediaType: 'podcast',
+          libraryItemId: libraryItemId,
+        );
+      }
+
+      if (success) {
+        setState(() {
+          _isInLibrary = newState;
+        });
+
+        if (mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text(
+                _isInLibrary ? S.of(context)!.addedToLibrary : S.of(context)!.removedFromLibrary,
+              ),
+              duration: const Duration(seconds: 1),
+            ),
+          );
+        }
+      }
+    } catch (e) {
+      _logger.log('Error toggling podcast library: $e');
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text('Failed to update library: $e'),
+            duration: const Duration(seconds: 2),
+          ),
+        );
+      }
+    }
+  }
+
+  Future<void> _extractColors() async {
+    final maProvider = context.read<MusicAssistantProvider>();
+    // Use initialImageUrl first for consistency with hero animation
+    final imageUrl = widget.initialImageUrl ?? maProvider.getPodcastImageUrl(widget.podcast);
+
+    if (imageUrl != null) {
+      try {
+        final colorSchemes = await PaletteHelper.extractColorSchemes(
+          CachedNetworkImageProvider(imageUrl),
+        );
+        if (mounted && colorSchemes != null) {
+          setState(() {
+            _lightColorScheme = colorSchemes.$1;
+            _darkColorScheme = colorSchemes.$2;
+          });
+        }
+      } catch (e) {
+        _logger.log('🎙️ Error extracting colors: $e');
+      }
+    }
+  }
+
+  Future<void> _loadEpisodes() async {
+    if (_isLoadingEpisodes) return;
+
+    setState(() {
+      _isLoadingEpisodes = true;
+    });
+
+    try {
+      final maProvider = context.read<MusicAssistantProvider>();
+      if (maProvider.api != null) {
+        final episodes = await maProvider.api!.getPodcastEpisodes(
+          widget.podcast.itemId,
+          provider: widget.podcast.provider,
+        );
+
+        if (mounted) {
+          _logger.log('🎙️ Loaded ${episodes.length} episodes for ${widget.podcast.name}');
+          // Debug: Log first episode metadata to see available fields
+          if (episodes.isNotEmpty) {
+            final first = episodes.first;
+            _logger.log('🎙️ First episode metadata keys: ${first.metadata?.keys.toList()}');
+            _logger.log('🎙️ First episode metadata: ${first.metadata}');
+          }
+          setState(() {
+            _episodes = episodes;
+          });
+        }
+      }
+    } catch (e) {
+      _logger.log('🎙️ Error loading episodes: $e');
+    } finally {
+      if (mounted) {
+        setState(() {
+          _isLoadingEpisodes = false;
+        });
+      }
+    }
+  }
+
+  void _playEpisode(MediaItem episode) async {
+    final maProvider = context.read<MusicAssistantProvider>();
+    final selectedPlayer = maProvider.selectedPlayer;
+
+    if (selectedPlayer != null) {
+      try {
+        // Set podcast context before playing so player UI shows correct podcast name
+        maProvider.setCurrentPodcastName(widget.podcast.name);
+        await maProvider.api?.playPodcastEpisode(selectedPlayer.playerId, episode);
+        if (mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text('Playing: ${episode.name}'),
+              duration: const Duration(seconds: 1),
+            ),
+          );
+        }
+      } catch (e) {
+        _logger.log('🎙️ Error playing episode: $e');
+        if (mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(content: Text('Failed to play episode: $e')),
+          );
+        }
+      }
+    } else {
+      _showPlayOnMenu(context, episode);
+    }
+  }
+
+  void _showPlayOnMenu(BuildContext context, MediaItem episode) {
+    final maProvider = context.read<MusicAssistantProvider>();
+
+    GlobalPlayerOverlay.hidePlayer();
+
+    showPlayerPickerSheet(
+      context: context,
+      title: S.of(context)!.playOn,
+      players: maProvider.availablePlayers,
+      selectedPlayer: maProvider.selectedPlayer,
+      onPlayerSelected: (player) async {
+        maProvider.selectPlayer(player);
+        // Set podcast context before playing so player UI shows correct podcast name
+        maProvider.setCurrentPodcastName(widget.podcast.name);
+        await maProvider.api?.playPodcastEpisode(player.playerId, episode);
+      },
+    ).whenComplete(() {
+      GlobalPlayerOverlay.showPlayer();
+    });
+  }
+
+  String _formatDuration(Duration? duration) {
+    if (duration == null || duration == Duration.zero) return '';
+    final hours = duration.inHours;
+    final minutes = duration.inMinutes.remainder(60);
+
+    if (hours > 0) {
+      return '${hours}h ${minutes}m';
+    }
+    return '${minutes} min';
+  }
+
+  /// Format release date from episode metadata
+  /// Tries various common field names for publication date
+  String? _formatReleaseDate(Map<String, dynamic>? metadata) {
+    if (metadata == null) return null;
+
+    // Try various common field names for publication date
+    dynamic dateValue = metadata['published'] ??
+        metadata['pub_date'] ??
+        metadata['release_date'] ??
+        metadata['aired'] ??
+        metadata['timestamp'];
+
+    if (dateValue == null) return null;
+
+    try {
+      DateTime? date;
+      if (dateValue is String) {
+        date = DateTime.tryParse(dateValue);
+      } else if (dateValue is int) {
+        // Unix timestamp
+        date = DateTime.fromMillisecondsSinceEpoch(dateValue * 1000);
+      }
+
+      if (date != null) {
+        // Format as "Jan 15, 2024"
+        final months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+        return '${months[date.month - 1]} ${date.day}, ${date.year}';
+      }
+    } catch (e) {
+      _logger.log('🎙️ Error parsing release date: $e');
+    }
+
+    return null;
+  }
+
+  /// Add episode to queue on current player
+  Future<void> _addToQueue(MediaItem episode) async {
+    final maProvider = context.read<MusicAssistantProvider>();
+    final selectedPlayer = maProvider.selectedPlayer;
+
+    if (selectedPlayer == null) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text(S.of(context)!.noPlayerSelected)),
+      );
+      return;
+    }
+
+    try {
+      // Convert MediaItem to Track for queue addition
+      final track = Track(
+        itemId: episode.itemId,
+        provider: episode.provider,
+        name: episode.name,
+        uri: episode.uri,
+        duration: episode.duration,
+        metadata: episode.metadata,
+      );
+      await maProvider.addTrackToQueue(selectedPlayer.playerId, track);
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text(S.of(context)!.addedToQueue),
+            duration: const Duration(seconds: 1),
+          ),
+        );
+      }
+    } catch (e) {
+      _logger.log('🎙️ Error adding episode to queue: $e');
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text(S.of(context)!.failedToAddToQueue(e.toString()))),
+        );
+      }
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    // CRITICAL FIX: Use select() instead of watch() to prevent rebuilds during Hero animation
+    // watch() rebuilds on ANY provider change (library updates, etc.) causing animation jank
+    // select() only rebuilds when the specific podcast image URL changes
+    final providerImageUrl = context.select<MusicAssistantProvider, String?>(
+      (provider) => provider.getPodcastImageUrl(widget.podcast),
+    );
+    // Use initialImageUrl for seamless hero animation (same URL as source)
+    final imageUrl = widget.initialImageUrl ?? providerImageUrl;
+
+    final adaptiveTheme = context.select<ThemeProvider, bool>(
+      (provider) => provider.adaptiveTheme,
+    );
+    final adaptiveLightScheme = context.select<ThemeProvider, ColorScheme?>(
+      (provider) => provider.adaptiveLightScheme,
+    );
+    final adaptiveDarkScheme = context.select<ThemeProvider, ColorScheme?>(
+      (provider) => provider.adaptiveDarkScheme,
+    );
+
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+
+    ColorScheme? adaptiveScheme;
+    if (adaptiveTheme) {
+      adaptiveScheme = isDark
+          ? (_darkColorScheme ?? adaptiveDarkScheme)
+          : (_lightColorScheme ?? adaptiveLightScheme);
+    }
+    final colorScheme = adaptiveScheme ?? Theme.of(context).colorScheme;
+    final textTheme = Theme.of(context).textTheme;
+
+    final description = widget.podcast.metadata?['description'] as String?;
+    final author = widget.podcast.metadata?['author'] as String?;
+
+    return PopScope(
+      canPop: true,
+      onPopInvokedWithResult: (didPop, result) {
+        if (didPop) {
+          clearAdaptiveColorsOnBack(context);
+        }
+      },
+      child: Scaffold(
+        backgroundColor: colorScheme.surface,
+        body: LayoutBuilder(
+          builder: (context, constraints) {
+            final coverSize = (constraints.maxWidth * 0.7).clamp(200.0, 320.0);
+            final expandedHeight = coverSize + 70;
+
+            return CustomScrollView(
+              slivers: [
+                SliverAppBar(
+                  expandedHeight: expandedHeight,
+                  pinned: true,
+                  backgroundColor: colorScheme.surface,
+                  leading: IconButton(
+                    icon: const Icon(Icons.arrow_back_rounded),
+                    onPressed: () {
+                      clearAdaptiveColorsOnBack(context);
+                      Navigator.pop(context);
+                    },
+                    color: colorScheme.onSurface,
+                  ),
+                  flexibleSpace: FlexibleSpaceBar(
+                    background: Column(
+                      mainAxisAlignment: MainAxisAlignment.center,
+                      children: [
+                        const SizedBox(height: 60),
+                        Hero(
+                          tag: HeroTags.podcastCover + (widget.podcast.uri ?? widget.podcast.itemId) + _heroTagSuffix,
+                          // Match audiobook pattern: ClipRRect + CachedNetworkImage for smooth hero
+                          child: ClipRRect(
+                            borderRadius: BorderRadius.circular(16),
+                            child: Container(
+                              width: coverSize,
+                              height: coverSize,
+                              color: colorScheme.surfaceContainerHighest,
+                              child: imageUrl != null
+                                  ? CachedNetworkImage(
+                                      imageUrl: imageUrl,
+                                      fit: BoxFit.cover,
+                                      // Match source memCacheWidth for smooth Hero animation
+                                      memCacheWidth: 256,
+                                      memCacheHeight: 256,
+                                      fadeInDuration: Duration.zero,
+                                      fadeOutDuration: Duration.zero,
+                                      placeholder: (_, __) => Center(
+                                        child: Icon(
+                                          MdiIcons.podcast,
+                                          size: coverSize * 0.43,
+                                          color: colorScheme.onSurfaceVariant,
+                                        ),
+                                      ),
+                                      errorWidget: (_, __, ___) => Center(
+                                        child: Icon(
+                                          MdiIcons.podcast,
+                                          size: coverSize * 0.43,
+                                          color: colorScheme.onSurfaceVariant,
+                                        ),
+                                      ),
+                                    )
+                                  : Center(
+                                      child: Icon(
+                                        MdiIcons.podcast,
+                                        size: coverSize * 0.43,
+                                        color: colorScheme.onSurfaceVariant,
+                                      ),
+                                    ),
+                            ),
+                          ),
+                        ),
+                      ],
+                    ),
+                  ),
+                ),
+                SliverToBoxAdapter(
+                  child: Padding(
+                    padding: const EdgeInsets.all(16),
+                    child: Column(
+                      crossAxisAlignment: CrossAxisAlignment.center,
+                      children: [
+                        // Podcast title
+                        Text(
+                          widget.podcast.name,
+                          style: textTheme.headlineSmall?.copyWith(
+                            fontWeight: FontWeight.bold,
+                            color: colorScheme.onSurface,
+                          ),
+                          textAlign: TextAlign.center,
+                        ),
+                        if (author != null) ...[
+                          const SizedBox(height: 4),
+                          Text(
+                            author,
+                            style: textTheme.bodyLarge?.copyWith(
+                              color: colorScheme.onSurface.withOpacity(0.7),
+                            ),
+                            textAlign: TextAlign.center,
+                          ),
+                        ],
+                        const SizedBox(height: 16),
+
+                        // Action buttons row
+                        Padding(
+                          padding: const EdgeInsets.symmetric(horizontal: 16),
+                          child: Row(
+                            children: [
+                              // Main Play Latest Episode Button
+                              Expanded(
+                                flex: 2,
+                                child: SizedBox(
+                                  height: 50,
+                                  child: ElevatedButton.icon(
+                                    onPressed: _isLoadingEpisodes || _episodes.isEmpty
+                                        ? null
+                                        : () => _playEpisode(_episodes.first),
+                                    icon: const Icon(Icons.play_arrow_rounded),
+                                    label: Text(S.of(context)!.play),
+                                    style: ElevatedButton.styleFrom(
+                                      backgroundColor: colorScheme.primary,
+                                      foregroundColor: colorScheme.onPrimary,
+                                      disabledBackgroundColor: colorScheme.primary.withOpacity(0.38),
+                                      disabledForegroundColor: colorScheme.onPrimary.withOpacity(0.38),
+                                      shape: RoundedRectangleBorder(
+                                        borderRadius: BorderRadius.circular(12),
+                                      ),
+                                    ),
+                                  ),
+                                ),
+                              ),
+                              const SizedBox(width: 12),
+                              // "Play on..." Button
+                              SizedBox(
+                                height: 50,
+                                width: 50,
+                                child: FilledButton.tonal(
+                                  onPressed: _isLoadingEpisodes || _episodes.isEmpty
+                                      ? null
+                                      : () => _showPlayOnMenu(context, _episodes.first),
+                                  style: FilledButton.styleFrom(
+                                    padding: EdgeInsets.zero,
+                                    shape: RoundedRectangleBorder(
+                                      borderRadius: BorderRadius.circular(12),
+                                    ),
+                                  ),
+                                  child: const Icon(Icons.speaker_group_outlined),
+                                ),
+                              ),
+                              const SizedBox(width: 12),
+                              // Library button
+                              SizedBox(
+                                height: 50,
+                                width: 50,
+                                child: FilledButton.tonal(
+                                  onPressed: _toggleLibrary,
+                                  style: FilledButton.styleFrom(
+                                    padding: EdgeInsets.zero,
+                                    shape: RoundedRectangleBorder(
+                                      borderRadius: BorderRadius.circular(12),
+                                    ),
+                                  ),
+                                  child: Icon(
+                                    _isInLibrary ? Icons.library_add_check : Icons.library_add,
+                                    color: _isInLibrary
+                                        ? colorScheme.primary
+                                        : colorScheme.onSurfaceVariant,
+                                  ),
+                                ),
+                              ),
+                            ],
+                          ),
+                        ),
+                        const SizedBox(height: 16),
+
+                        // Description
+                        if (description != null && description.isNotEmpty) ...[
+                          GestureDetector(
+                            onTap: () {
+                              setState(() {
+                                _isDescriptionExpanded = !_isDescriptionExpanded;
+                              });
+                            },
+                            child: AnimatedCrossFade(
+                              firstChild: Text(
+                                description,
+                                maxLines: 3,
+                                overflow: TextOverflow.ellipsis,
+                                style: textTheme.bodyMedium?.copyWith(
+                                  color: colorScheme.onSurface.withOpacity(0.7),
+                                ),
+                              ),
+                              secondChild: Text(
+                                description,
+                                style: textTheme.bodyMedium?.copyWith(
+                                  color: colorScheme.onSurface.withOpacity(0.7),
+                                ),
+                              ),
+                              crossFadeState: _isDescriptionExpanded
+                                  ? CrossFadeState.showSecond
+                                  : CrossFadeState.showFirst,
+                              duration: const Duration(milliseconds: 200),
+                            ),
+                          ),
+                          const SizedBox(height: 16),
+                        ],
+
+                        // Episodes header
+                        Row(
+                          children: [
+                            Text(
+                              S.of(context)!.episodes,
+                              style: textTheme.titleLarge?.copyWith(
+                                fontWeight: FontWeight.bold,
+                                color: colorScheme.onSurface,
+                              ),
+                            ),
+                            const SizedBox(width: 8),
+                            if (_episodes.isNotEmpty)
+                              Text(
+                                '(${_episodes.length})',
+                                style: textTheme.bodyLarge?.copyWith(
+                                  color: colorScheme.onSurface.withOpacity(0.5),
+                                ),
+                              ),
+                          ],
+                        ),
+                      ],
+                    ),
+                  ),
+                ),
+
+                // Episodes list
+                if (_isLoadingEpisodes)
+                  SliverToBoxAdapter(
+                    child: Center(
+                      child: Padding(
+                        padding: const EdgeInsets.all(32),
+                        child: CircularProgressIndicator(color: colorScheme.primary),
+                      ),
+                    ),
+                  )
+                else if (_episodes.isEmpty)
+                  SliverToBoxAdapter(
+                    child: Center(
+                      child: Padding(
+                        padding: const EdgeInsets.all(32),
+                        child: Column(
+                          children: [
+                            Icon(
+                              MdiIcons.microphoneOff,
+                              size: 48,
+                              color: colorScheme.onSurface.withOpacity(0.3),
+                            ),
+                            const SizedBox(height: 16),
+                            Text(
+                              'No episodes found',
+                              style: textTheme.bodyLarge?.copyWith(
+                                color: colorScheme.onSurface.withOpacity(0.5),
+                              ),
+                            ),
+                          ],
+                        ),
+                      ),
+                    ),
+                  )
+                else
+                  SliverList(
+                    delegate: SliverChildBuilderDelegate(
+                      (context, index) {
+                        final episode = _episodes[index];
+                        final episodeDescription = episode.metadata?['description'] as String?;
+                        final duration = episode.duration;
+                        final episodeId = episode.uri ?? episode.itemId;
+                        final isExpanded = _expandedEpisodeId == episodeId;
+                        final episodeImageUrl = context.read<MusicAssistantProvider>().getImageUrl(episode, size: 256);
+
+                        // Try to get release date from metadata
+                        final releaseDate = _formatReleaseDate(episode.metadata);
+
+                        return Column(
+                          children: [
+                            InkWell(
+                              onTap: () => _playEpisode(episode),
+                              onLongPress: () {
+                                setState(() {
+                                  _expandedEpisodeId = isExpanded ? null : episodeId;
+                                });
+                              },
+                              child: Padding(
+                                padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+                                child: Row(
+                                  crossAxisAlignment: CrossAxisAlignment.start,
+                                  children: [
+                                    // Episode cover (bigger than before)
+                                    ClipRRect(
+                                      borderRadius: BorderRadius.circular(8),
+                                      child: Container(
+                                        width: 72,
+                                        height: 72,
+                                        color: colorScheme.surfaceContainerHighest,
+                                        child: episodeImageUrl != null
+                                            ? CachedNetworkImage(
+                                                imageUrl: episodeImageUrl,
+                                                fit: BoxFit.cover,
+                                                fadeInDuration: Duration.zero,
+                                                fadeOutDuration: Duration.zero,
+                                                placeholder: (_, __) => Icon(
+                                                  MdiIcons.podcast,
+                                                  size: 32,
+                                                  color: colorScheme.onSurfaceVariant,
+                                                ),
+                                                errorWidget: (_, __, ___) => Icon(
+                                                  MdiIcons.podcast,
+                                                  size: 32,
+                                                  color: colorScheme.onSurfaceVariant,
+                                                ),
+                                              )
+                                            : Icon(
+                                                MdiIcons.podcast,
+                                                size: 32,
+                                                color: colorScheme.onSurfaceVariant,
+                                              ),
+                                      ),
+                                    ),
+                                    const SizedBox(width: 12),
+                                    // Episode info
+                                    Expanded(
+                                      child: Column(
+                                        crossAxisAlignment: CrossAxisAlignment.start,
+                                        children: [
+                                          Text(
+                                            episode.name,
+                                            style: textTheme.titleSmall?.copyWith(
+                                              fontWeight: FontWeight.w500,
+                                            ),
+                                            maxLines: 2,
+                                            overflow: TextOverflow.ellipsis,
+                                          ),
+                                          if (episodeDescription != null && episodeDescription.isNotEmpty) ...[
+                                            const SizedBox(height: 4),
+                                            Text(
+                                              episodeDescription,
+                                              maxLines: isExpanded ? 100 : 2,
+                                              overflow: TextOverflow.ellipsis,
+                                              style: textTheme.bodySmall?.copyWith(
+                                                color: colorScheme.onSurface.withOpacity(0.6),
+                                              ),
+                                            ),
+                                          ],
+                                          const SizedBox(height: 6),
+                                          // Duration and release date row
+                                          Row(
+                                            children: [
+                                              if (duration != null && duration > Duration.zero) ...[
+                                                Icon(
+                                                  Icons.access_time,
+                                                  size: 14,
+                                                  color: colorScheme.onSurface.withOpacity(0.5),
+                                                ),
+                                                const SizedBox(width: 4),
+                                                Text(
+                                                  _formatDuration(duration),
+                                                  style: textTheme.bodySmall?.copyWith(
+                                                    color: colorScheme.onSurface.withOpacity(0.5),
+                                                  ),
+                                                ),
+                                              ],
+                                              if (duration != null && duration > Duration.zero && releaseDate != null)
+                                                Padding(
+                                                  padding: const EdgeInsets.symmetric(horizontal: 8),
+                                                  child: Text(
+                                                    '•',
+                                                    style: textTheme.bodySmall?.copyWith(
+                                                      color: colorScheme.onSurface.withOpacity(0.5),
+                                                    ),
+                                                  ),
+                                                ),
+                                              if (releaseDate != null)
+                                                Text(
+                                                  releaseDate,
+                                                  style: textTheme.bodySmall?.copyWith(
+                                                    color: colorScheme.onSurface.withOpacity(0.5),
+                                                  ),
+                                                ),
+                                            ],
+                                          ),
+                                        ],
+                                      ),
+                                    ),
+                                  ],
+                                ),
+                              ),
+                            ),
+                            // Expanded action buttons (matching album track style)
+                            AnimatedCrossFade(
+                              firstChild: const SizedBox.shrink(),
+                              secondChild: Padding(
+                                padding: const EdgeInsets.only(left: 100, right: 16, bottom: 12),
+                                child: Row(
+                                  children: [
+                                    // Play button
+                                    SizedBox(
+                                      height: 44,
+                                      width: 44,
+                                      child: FilledButton.tonal(
+                                        onPressed: () => _playEpisode(episode),
+                                        style: FilledButton.styleFrom(
+                                          padding: EdgeInsets.zero,
+                                          shape: RoundedRectangleBorder(
+                                            borderRadius: BorderRadius.circular(12),
+                                          ),
+                                        ),
+                                        child: const Icon(Icons.play_arrow, size: 20),
+                                      ),
+                                    ),
+                                    const SizedBox(width: 10),
+                                    // Play on... button
+                                    SizedBox(
+                                      height: 44,
+                                      width: 44,
+                                      child: FilledButton.tonal(
+                                        onPressed: () => _showPlayOnMenu(context, episode),
+                                        style: FilledButton.styleFrom(
+                                          padding: EdgeInsets.zero,
+                                          shape: RoundedRectangleBorder(
+                                            borderRadius: BorderRadius.circular(12),
+                                          ),
+                                        ),
+                                        child: const Icon(Icons.speaker_group_outlined, size: 20),
+                                      ),
+                                    ),
+                                    const SizedBox(width: 10),
+                                    // Add to queue button
+                                    SizedBox(
+                                      height: 44,
+                                      width: 44,
+                                      child: FilledButton.tonal(
+                                        onPressed: () => _addToQueue(episode),
+                                        style: FilledButton.styleFrom(
+                                          padding: EdgeInsets.zero,
+                                          shape: RoundedRectangleBorder(
+                                            borderRadius: BorderRadius.circular(12),
+                                          ),
+                                        ),
+                                        child: const Icon(Icons.playlist_add, size: 20),
+                                      ),
+                                    ),
+                                  ],
+                                ),
+                              ),
+                              crossFadeState: isExpanded
+                                  ? CrossFadeState.showSecond
+                                  : CrossFadeState.showFirst,
+                              duration: const Duration(milliseconds: 200),
+                            ),
+                          ],
+                        );
+                      },
+                      childCount: _episodes.length,
+                    ),
+                  ),
+
+                // Bottom padding for mini player
+                const SliverToBoxAdapter(
+                  child: SizedBox(height: 100),
+                ),
+              ],
+            );
+          },
+        ),
+      ),
+    );
+  }
+}

lib/screens/queue_screen.dart

@@ -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 '../l10n/app_localizations.dart';
 
 class QueueScreen extends StatefulWidget {
   const QueueScreen({super.key});
@@ -51,7 +52,7 @@ class _QueueScreenState extends State<QueueScreen> {
         if (mounted) {
           setState(() {
             _isLoading = false;
-            _error = 'No player selected';
+            _error = S.of(context)!.noPlayerSelected;
           });
         }
       }
@@ -77,7 +78,7 @@ class _QueueScreenState extends State<QueueScreen> {
         backgroundColor: Colors.transparent,
         elevation: 0,
         title: Text(
-          player != null ? '${player.name} Queue' : 'Queue',
+          player != null ? S.of(context)!.playerQueue(player.name) : S.of(context)!.queue,
           style: const TextStyle(
             color: Colors.white,
             fontSize: 20,
@@ -116,7 +117,7 @@ class _QueueScreenState extends State<QueueScreen> {
             const SizedBox(height: 16),
             ElevatedButton(
               onPressed: _loadQueue,
-              child: const Text('Retry'),
+              child: Text(S.of(context)!.retry),
             ),
           ],
         ),
@@ -131,7 +132,7 @@ class _QueueScreenState extends State<QueueScreen> {
             Icon(Icons.speaker_group, size: 64, color: Colors.grey[700]),
             const SizedBox(height: 16),
             Text(
-              'No player selected',
+              S.of(context)!.noPlayerSelected,
               style: TextStyle(color: Colors.grey[600], fontSize: 18),
             ),
           ],
@@ -140,7 +141,7 @@ class _QueueScreenState extends State<QueueScreen> {
     }
 
     if (_queue == null || _queue!.items.isEmpty) {
-      return EmptyState.queue();
+      return EmptyState.queue(context: context);
     }
 
     // Filter to show only current and upcoming items (not history)
@@ -148,9 +149,9 @@ class _QueueScreenState extends State<QueueScreen> {
     final upcomingItems = _queue!.items.sublist(currentIndex);
 
     if (upcomingItems.isEmpty) {
-      return const EmptyState(
+      return EmptyState(
         icon: Icons.queue_music,
-        message: 'No upcoming tracks',
+        message: S.of(context)!.noUpcomingTracks,
       );
     }
 
@@ -220,9 +221,9 @@ class _QueueScreenState extends State<QueueScreen> {
 
         ScaffoldMessenger.of(context).showSnackBar(
           SnackBar(
-            content: Text('Removed ${item.track.name}'),
+            content: Text(S.of(context)!.removedItem(item.track.name)),
             action: SnackBarAction(
-              label: 'Undo',
+              label: S.of(context)!.undo,
               onPressed: () {
                 setState(() {
                   _queue!.items.insert(index, item);

lib/services/audio/massiv_audio_handler.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'package:audio_service/audio_service.dart';
 import 'package:audio_session/audio_session.dart';
 import 'package:just_audio/just_audio.dart';
@@ -11,6 +12,12 @@ class MassivAudioHandler extends BaseAudioHandler with SeekHandler {
   final AuthManager authManager;
   final _logger = DebugLogger();
 
+  // Stream subscriptions for proper cleanup
+  StreamSubscription? _interruptionSubscription;
+  StreamSubscription? _becomingNoisySubscription;
+  StreamSubscription? _playbackEventSubscription;
+  StreamSubscription? _currentIndexSubscription;
+
   // Track current metadata separately from what's in the notification
   // This allows us to update the notification when metadata arrives late
   MediaItem? _currentMediaItem;
@@ -42,7 +49,7 @@ class MassivAudioHandler extends BaseAudioHandler with SeekHandler {
     await session.configure(const AudioSessionConfiguration.music());
 
     // Handle audio interruptions
-    session.interruptionEventStream.listen((event) {
+    _interruptionSubscription = session.interruptionEventStream.listen((event) {
       if (event.begin) {
         switch (event.type) {
           case AudioInterruptionType.duck:
@@ -68,15 +75,15 @@ class MassivAudioHandler extends BaseAudioHandler with SeekHandler {
     });
 
     // Handle becoming noisy (headphones unplugged)
-    session.becomingNoisyEventStream.listen((_) {
+    _becomingNoisySubscription = session.becomingNoisyEventStream.listen((_) {
       pause();
     });
 
     // Broadcast playback state changes
-    _player.playbackEventStream.listen(_broadcastState);
+    _playbackEventSubscription = _player.playbackEventStream.listen(_broadcastState);
 
     // Broadcast current media item changes
-    _player.currentIndexStream.listen((_) {
+    _currentIndexSubscription = _player.currentIndexStream.listen((_) {
       if (_currentMediaItem != null) {
         mediaItem.add(_currentMediaItem);
       }
@@ -293,4 +300,13 @@ class MassivAudioHandler extends BaseAudioHandler with SeekHandler {
   Stream<Duration?> get durationStream => _player.durationStream;
 
   MediaItem? get currentMediaItem => _currentMediaItem;
+
+  /// Dispose of resources and cancel all subscriptions
+  Future<void> dispose() async {
+    await _interruptionSubscription?.cancel();
+    await _becomingNoisySubscription?.cancel();
+    await _playbackEventSubscription?.cancel();
+    await _currentIndexSubscription?.cancel();
+    await _player.dispose();
+  }
 }

lib/services/auth/auth_manager.dart

@@ -1,4 +1,5 @@
 import 'dart:convert';
+import 'dart:io';
 import 'package:http/http.dart' as http;
 import 'auth_strategy.dart';
 import 'no_auth_strategy.dart';
@@ -31,11 +32,42 @@ class AuthManager {
 
   /// Auto-detect authentication requirements for a server
   /// Returns null if server is unreachable or auth method unknown
+  /// Also returns the final URL used (in case of HTTP fallback) via the callback
+  String? _lastSuccessfulUrl;
+  String? get lastSuccessfulUrl => _lastSuccessfulUrl;
+
   Future<AuthStrategy?> detectAuthStrategy(String serverUrl) async {
     _logger.log('🔍 Auto-detecting auth strategy for $serverUrl');
+    _lastSuccessfulUrl = null;
 
     // Normalize URL
-    var baseUrl = serverUrl;
+    var baseUrl = _normalizeUrl(serverUrl);
+    _logger.log('Normalized URL: $baseUrl');
+
+    // Try detection with the initial URL
+    var result = await _tryDetectAuth(baseUrl);
+
+    // If HTTPS failed and we haven't tried HTTP yet, try HTTP fallback
+    if (result == null && baseUrl.startsWith('https://')) {
+      final httpUrl = baseUrl.replaceFirst('https://', 'http://');
+      _logger.log('🔄 HTTPS failed, trying HTTP fallback: $httpUrl');
+      result = await _tryDetectAuth(httpUrl);
+      if (result != null) {
+        baseUrl = httpUrl;
+      }
+    }
+
+    if (result != null) {
+      _lastSuccessfulUrl = baseUrl;
+      _logger.log('✅ Auth detection successful with URL: $baseUrl');
+    }
+
+    return result;
+  }
+
+  /// Normalize a server URL with appropriate protocol
+  String _normalizeUrl(String url) {
+    var baseUrl = url;
     if (!baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {
       // Use http for local IPs, https for domains
       if (baseUrl.startsWith('192.') ||
@@ -44,13 +76,39 @@ class AuthManager {
           baseUrl == 'localhost' ||
           baseUrl.startsWith('127.')) {
         baseUrl = 'http://$baseUrl';
+      } else if (baseUrl.endsWith('.ts.net') || baseUrl.contains('.ts.net:')) {
+        // Tailscale URLs - default to http:// since VPN tunnel is already encrypted
+        baseUrl = 'http://$baseUrl';
+        _logger.log('🔗 Detected Tailscale URL, using HTTP');
       } else {
         baseUrl = 'https://$baseUrl';
       }
     }
+    return baseUrl;
+  }
 
+  /// Check if a hostname is a local/private IP address
+  bool _isLocalIpAddress(String host) {
+    return host.startsWith('192.168.') ||
+        host.startsWith('10.') ||
+        host.startsWith('172.16.') ||
+        host.startsWith('172.17.') ||
+        host.startsWith('172.18.') ||
+        host.startsWith('172.19.') ||
+        host.startsWith('172.2') ||
+        host.startsWith('172.30.') ||
+        host.startsWith('172.31.') ||
+        host == 'localhost' ||
+        host.startsWith('127.') ||
+        host.endsWith('.local') ||
+        host.endsWith('.ts.net');
+  }
+
+  /// Try to detect auth strategy for a given URL
+  /// Returns the strategy if successful, null if connection failed
+  Future<AuthStrategy?> _tryDetectAuth(String baseUrl) async {
     // First, check if this is a Music Assistant server with native auth
-    _logger.log('Checking for Music Assistant native auth...');
+    _logger.log('Checking for Music Assistant native auth at $baseUrl...');
     final maAuthResult = await _checkMusicAssistantAuth(baseUrl);
     if (maAuthResult != null) {
       if (maAuthResult == 'required') {
@@ -124,7 +182,7 @@ class AuthManager {
       }
     } catch (e) {
       _logger.log('✗ Auth detection error: $e');
-      return null; // Return null instead of rethrow to show generic error
+      return null; // Return null to trigger fallback
     }
 
     _logger.log('⚠️ Could not determine auth method');
@@ -136,24 +194,61 @@ class AuthManager {
   Future<String?> _checkMusicAssistantAuth(String baseUrl) async {
     try {
       final uri = Uri.parse(baseUrl);
+      // Use the port from URL if specified, otherwise use default ports (80/443)
+      // Don't default to 8095 here - that's only for direct connections without reverse proxy
       final apiUrl = Uri(
         scheme: uri.scheme,
         host: uri.host,
-        port: uri.hasPort ? uri.port : (uri.scheme == 'https' ? null : 8095),
+        port: uri.hasPort ? uri.port : null,
         path: '/api',
       );
 
       _logger.log('Checking MA API at: $apiUrl');
 
-      // Try to get server info - this tells us if auth is required
-      // Note: The command is just 'info', not 'server/info'
-      final response = await http.post(
-        apiUrl,
-        headers: {'Content-Type': 'application/json'},
-        body: jsonEncode({
-          'command': 'info',
-        }),
-      ).timeout(const Duration(seconds: 5));
+      // Use IOClient to control redirect behavior for local IPs
+      final isLocalIp = _isLocalIpAddress(uri.host);
+      http.Response response;
+
+      if (isLocalIp) {
+        // For local IPs, don't follow redirects - handle them explicitly
+        final client = HttpClient();
+        try {
+          final request = await client.postUrl(apiUrl);
+          request.followRedirects = false;
+          request.headers.set('Content-Type', 'application/json');
+          request.write(jsonEncode({'command': 'info'}));
+          final ioResponse = await request.close().timeout(const Duration(seconds: 5));
+
+          // Check for redirect to HTTPS
+          if (ioResponse.statusCode == 308 || ioResponse.statusCode == 301 || ioResponse.statusCode == 302) {
+            final location = ioResponse.headers.value('location');
+            _logger.log('Local IP redirects to: $location');
+            if (location != null && location.startsWith('https://')) {
+              _logger.log('⚠️ Server redirects HTTP to HTTPS - this may cause certificate issues for local IP');
+              // Don't follow the redirect - it will likely fail with cert error
+              // Instead, return null to trigger fallback logic
+              client.close();
+              return null;
+            }
+          }
+
+          final body = await ioResponse.transform(utf8.decoder).join();
+          response = http.Response(body, ioResponse.statusCode);
+          client.close();
+        } catch (e) {
+          client.close();
+          rethrow;
+        }
+      } else {
+        // For non-local URLs, use standard http.post which follows redirects
+        response = await http.post(
+          apiUrl,
+          headers: {'Content-Type': 'application/json'},
+          body: jsonEncode({
+            'command': 'info',
+          }),
+        ).timeout(const Duration(seconds: 5));
+      }
 
       _logger.log('MA API response: ${response.statusCode}');
       _logger.log('MA API body: ${response.body}');
@@ -213,21 +308,47 @@ class AuthManager {
   /// Test if server is accessible without authentication
   Future<bool> _canConnectWithoutAuth(String serverUrl) async {
     try {
-      // Test root endpoint - Music Assistant doesn't have /api/info
-      final testUrl = serverUrl;
-      _logger.log('No-auth test URL: $testUrl');
+      final uri = Uri.parse(serverUrl);
+      _logger.log('No-auth test URL: $serverUrl');
 
-      final response = await http.get(
-        Uri.parse(testUrl),
-        // Don't follow redirects - we want to see if server requires auth
-      ).timeout(const Duration(seconds: 10));
+      final isLocalIp = _isLocalIpAddress(uri.host);
+      int statusCode;
 
-      _logger.log('No-auth status: ${response.statusCode}');
+      if (isLocalIp) {
+        // For local IPs, don't follow redirects to avoid HTTPS cert issues
+        final client = HttpClient();
+        try {
+          final request = await client.getUrl(uri);
+          request.followRedirects = false;
+          final response = await request.close().timeout(const Duration(seconds: 10));
+          statusCode = response.statusCode;
+
+          // Check for redirect to HTTPS
+          if (statusCode == 308 || statusCode == 301 || statusCode == 302) {
+            final location = response.headers.value('location');
+            if (location != null && location.startsWith('https://')) {
+              _logger.log('⚠️ Local IP redirects to HTTPS: $location');
+              client.close();
+              return false; // Can't connect - would need HTTPS which has cert issues
+            }
+          }
+          client.close();
+        } catch (e) {
+          client.close();
+          rethrow;
+        }
+      } else {
+        // For non-local URLs, use standard http.get
+        final response = await http.get(uri).timeout(const Duration(seconds: 10));
+        statusCode = response.statusCode;
+      }
+
+      _logger.log('No-auth status: $statusCode');
 
       // 200 = no auth required
-      // 302/307 = redirect (probably to auth)
+      // 302/307/308 = redirect (probably to auth or HTTPS)
       // 401 = auth required
-      if (response.statusCode == 200) {
+      if (statusCode == 200) {
         return true;
       }
 

lib/services/cache_service.dart

@@ -1,19 +1,34 @@
+import 'dart:convert';
 import '../models/media_item.dart';
+import '../models/player.dart';
 import '../services/debug_logger.dart';
+import '../services/database_service.dart';
 import '../constants/timings.dart';
 
 /// Centralized cache service for all app data caching
 /// This is a non-notifying service - it just stores and retrieves cached data
 class CacheService {
   final DebugLogger _logger = DebugLogger();
+  bool _homeRowsLoaded = false;
+
+  // Cache size limits to prevent unbounded memory growth
+  static const int _maxDetailCacheSize = 50; // Max albums/playlists/artists cached
+  static const int _maxSearchCacheSize = 20; // Max search queries cached
+  static const int _maxPlayerTrackCacheSize = 30; // Max player track associations
 
   // Home screen row caching
   List<Album>? _cachedRecentAlbums;
   List<Artist>? _cachedDiscoverArtists;
   List<Album>? _cachedDiscoverAlbums;
+  List<Audiobook>? _cachedInProgressAudiobooks;
+  List<Audiobook>? _cachedDiscoverAudiobooks;
+  List<AudiobookSeries>? _cachedDiscoverSeries;
   DateTime? _recentAlbumsLastFetched;
   DateTime? _discoverArtistsLastFetched;
   DateTime? _discoverAlbumsLastFetched;
+  DateTime? _inProgressAudiobooksLastFetched;
+  DateTime? _discoverAudiobooksLastFetched;
+  DateTime? _discoverSeriesLastFetched;
 
   // Detail screen caching
   final Map<String, List<Track>> _albumTracksCache = {};
@@ -28,10 +43,13 @@ class CacheService {
   final Map<String, DateTime> _searchCacheTime = {};
 
   // Player list caching
+  List<Player>? _cachedPlayers;
+  Player? _cachedSelectedPlayer;
   DateTime? _playersLastFetched;
 
   // Player track cache (for smooth swipe transitions)
   final Map<String, Track?> _playerTrackCache = {};
+  final Map<String, DateTime> _playerTrackCacheTime = {};
 
   // ============================================================================
   // HOME SCREEN ROW CACHING
@@ -54,6 +72,8 @@ class CacheService {
     _cachedRecentAlbums = albums;
     _recentAlbumsLastFetched = DateTime.now();
     _logger.log('✅ Cached ${albums.length} recent albums');
+    // Persist to database for instant load on next launch
+    _persistHomeRowToDatabase('recent_albums', albums.map((a) => a.toJson()).toList());
   }
 
   /// Check if discover artists cache is valid
@@ -73,6 +93,8 @@ class CacheService {
     _cachedDiscoverArtists = artists;
     _discoverArtistsLastFetched = DateTime.now();
     _logger.log('✅ Cached ${artists.length} discover artists');
+    // Persist to database for instant load on next launch
+    _persistHomeRowToDatabase('discover_artists', artists.map((a) => a.toJson()).toList());
   }
 
   /// Check if discover albums cache is valid
@@ -92,6 +114,76 @@ class CacheService {
     _cachedDiscoverAlbums = albums;
     _discoverAlbumsLastFetched = DateTime.now();
     _logger.log('✅ Cached ${albums.length} discover albums');
+    // Persist to database for instant load on next launch
+    _persistHomeRowToDatabase('discover_albums', albums.map((a) => a.toJson()).toList());
+  }
+
+  /// Check if in-progress audiobooks cache is valid
+  bool isInProgressAudiobooksCacheValid({bool forceRefresh = false}) {
+    if (forceRefresh) return false;
+    final now = DateTime.now();
+    return _cachedInProgressAudiobooks != null &&
+        _inProgressAudiobooksLastFetched != null &&
+        now.difference(_inProgressAudiobooksLastFetched!) < Timings.homeRowCacheDuration;
+  }
+
+  /// Get cached in-progress audiobooks
+  List<Audiobook>? getCachedInProgressAudiobooks() => _cachedInProgressAudiobooks;
+
+  /// Set cached in-progress audiobooks
+  void setCachedInProgressAudiobooks(List<Audiobook> audiobooks) {
+    _cachedInProgressAudiobooks = audiobooks;
+    _inProgressAudiobooksLastFetched = DateTime.now();
+    _logger.log('✅ Cached ${audiobooks.length} in-progress audiobooks');
+  }
+
+  /// Check if discover audiobooks cache is valid
+  bool isDiscoverAudiobooksCacheValid({bool forceRefresh = false}) {
+    if (forceRefresh) return false;
+    final now = DateTime.now();
+    return _cachedDiscoverAudiobooks != null &&
+        _discoverAudiobooksLastFetched != null &&
+        now.difference(_discoverAudiobooksLastFetched!) < Timings.homeRowCacheDuration;
+  }
+
+  /// Get cached discover audiobooks
+  List<Audiobook>? getCachedDiscoverAudiobooks() => _cachedDiscoverAudiobooks;
+
+  /// Set cached discover audiobooks
+  void setCachedDiscoverAudiobooks(List<Audiobook> audiobooks) {
+    _cachedDiscoverAudiobooks = audiobooks;
+    _discoverAudiobooksLastFetched = DateTime.now();
+    _logger.log('✅ Cached ${audiobooks.length} discover audiobooks');
+  }
+
+  /// Check if discover series cache is valid
+  bool isDiscoverSeriesCacheValid({bool forceRefresh = false}) {
+    if (forceRefresh) return false;
+    final now = DateTime.now();
+    return _cachedDiscoverSeries != null &&
+        _discoverSeriesLastFetched != null &&
+        now.difference(_discoverSeriesLastFetched!) < Timings.homeRowCacheDuration;
+  }
+
+  /// Get cached discover series
+  List<AudiobookSeries>? getCachedDiscoverSeries() => _cachedDiscoverSeries;
+
+  /// Set cached discover series
+  void setCachedDiscoverSeries(List<AudiobookSeries> series) {
+    _cachedDiscoverSeries = series;
+    _discoverSeriesLastFetched = DateTime.now();
+    _logger.log('✅ Cached ${series.length} discover series');
+  }
+
+  /// Invalidate audiobook caches
+  void invalidateAudiobookCaches() {
+    _cachedInProgressAudiobooks = null;
+    _inProgressAudiobooksLastFetched = null;
+    _cachedDiscoverAudiobooks = null;
+    _discoverAudiobooksLastFetched = null;
+    _cachedDiscoverSeries = null;
+    _discoverSeriesLastFetched = null;
+    _logger.log('🗑️ Audiobook caches invalidated');
   }
 
   /// Invalidate home screen cache (call on pull-to-refresh)
@@ -99,9 +191,28 @@ class CacheService {
     _recentAlbumsLastFetched = null;
     _discoverArtistsLastFetched = null;
     _discoverAlbumsLastFetched = null;
+    _inProgressAudiobooksLastFetched = null;
+    _discoverAudiobooksLastFetched = null;
+    _discoverSeriesLastFetched = null;
     _logger.log('🗑️ Home screen cache invalidated');
   }
 
+  /// Invalidate home album caches (call when albums are added/removed from library)
+  void invalidateHomeAlbumCaches() {
+    _cachedRecentAlbums = null;
+    _recentAlbumsLastFetched = null;
+    _cachedDiscoverAlbums = null;
+    _discoverAlbumsLastFetched = null;
+    _logger.log('🗑️ Home album caches invalidated');
+  }
+
+  /// Invalidate home artist caches (call when artists are added/removed from library)
+  void invalidateHomeArtistCaches() {
+    _cachedDiscoverArtists = null;
+    _discoverArtistsLastFetched = null;
+    _logger.log('🗑️ Home artist caches invalidated');
+  }
+
   // ============================================================================
   // DETAIL SCREEN CACHING
   // ============================================================================
@@ -123,15 +234,23 @@ class CacheService {
   void setCachedAlbumTracks(String cacheKey, List<Track> tracks) {
     _albumTracksCache[cacheKey] = tracks;
     _albumTracksCacheTime[cacheKey] = DateTime.now();
+    _evictOldestEntries(_albumTracksCache, _albumTracksCacheTime, _maxDetailCacheSize);
     _logger.log('✅ Cached ${tracks.length} tracks for album $cacheKey');
   }
 
-  /// Invalidate album tracks cache
+  /// Invalidate album tracks cache for a specific album
   void invalidateAlbumTracksCache(String albumId) {
     _albumTracksCache.remove(albumId);
     _albumTracksCacheTime.remove(albumId);
   }
 
+  /// Invalidate all album tracks caches (call when tracks are added/removed from library)
+  void invalidateAllAlbumTracksCaches() {
+    _albumTracksCache.clear();
+    _albumTracksCacheTime.clear();
+    _logger.log('🗑️ All album tracks caches invalidated');
+  }
+
   /// Check if playlist tracks cache is valid
   bool isPlaylistTracksCacheValid(String cacheKey, {bool forceRefresh = false}) {
     if (forceRefresh) return false;
@@ -149,15 +268,23 @@ class CacheService {
   void setCachedPlaylistTracks(String cacheKey, List<Track> tracks) {
     _playlistTracksCache[cacheKey] = tracks;
     _playlistTracksCacheTime[cacheKey] = DateTime.now();
+    _evictOldestEntries(_playlistTracksCache, _playlistTracksCacheTime, _maxDetailCacheSize);
     _logger.log('✅ Cached ${tracks.length} tracks for playlist $cacheKey');
   }
 
-  /// Invalidate playlist tracks cache
+  /// Invalidate playlist tracks cache for a specific playlist
   void invalidatePlaylistTracksCache(String playlistId) {
     _playlistTracksCache.remove(playlistId);
     _playlistTracksCacheTime.remove(playlistId);
   }
 
+  /// Invalidate all playlist tracks caches (call when tracks are added/removed from library)
+  void invalidateAllPlaylistTracksCaches() {
+    _playlistTracksCache.clear();
+    _playlistTracksCacheTime.clear();
+    _logger.log('🗑️ All playlist tracks caches invalidated');
+  }
+
   /// Check if artist albums cache is valid
   bool isArtistAlbumsCacheValid(String cacheKey, {bool forceRefresh = false}) {
     if (forceRefresh) return false;
@@ -175,9 +302,17 @@ class CacheService {
   void setCachedArtistAlbums(String cacheKey, List<Album> albums) {
     _artistAlbumsCache[cacheKey] = albums;
     _artistAlbumsCacheTime[cacheKey] = DateTime.now();
+    _evictOldestEntries(_artistAlbumsCache, _artistAlbumsCacheTime, _maxDetailCacheSize);
     _logger.log('✅ Cached ${albums.length} albums for artist $cacheKey');
   }
 
+  /// Invalidate all artist albums caches (call when albums are added/removed from library)
+  void invalidateArtistAlbumsCache() {
+    _artistAlbumsCache.clear();
+    _artistAlbumsCacheTime.clear();
+    _logger.log('🗑️ Artist albums cache invalidated');
+  }
+
   // ============================================================================
   // SEARCH CACHING
   // ============================================================================
@@ -199,9 +334,17 @@ class CacheService {
   void setCachedSearchResults(String cacheKey, Map<String, List<MediaItem>> results) {
     _searchCache[cacheKey] = results;
     _searchCacheTime[cacheKey] = DateTime.now();
+    _evictOldestEntries(_searchCache, _searchCacheTime, _maxSearchCacheSize);
     _logger.log('✅ Cached search results for "$cacheKey"');
   }
 
+  /// Invalidate all search cache (call when library items change)
+  void invalidateSearchCache() {
+    _searchCache.clear();
+    _searchCacheTime.clear();
+    _logger.log('🗑️ Search cache invalidated');
+  }
+
   // ============================================================================
   // PLAYER CACHING
   // ============================================================================
@@ -219,12 +362,43 @@ class CacheService {
     _playersLastFetched = DateTime.now();
   }
 
+  /// Get cached players list
+  List<Player>? getCachedPlayers() => _cachedPlayers;
+
+  /// Set cached players list
+  void setCachedPlayers(List<Player> players) {
+    _cachedPlayers = players;
+    _playersLastFetched = DateTime.now();
+  }
+
+  /// Get cached selected player
+  Player? getCachedSelectedPlayer() => _cachedSelectedPlayer;
+
+  /// Set cached selected player
+  void setCachedSelectedPlayer(Player? player) {
+    _cachedSelectedPlayer = player;
+  }
+
+  /// Check if we have cached players (for instant UI display on app resume)
+  bool get hasCachedPlayers => _cachedPlayers != null && _cachedPlayers!.isNotEmpty;
+
   /// Get cached track for a player (used for smooth swipe transitions)
   Track? getCachedTrackForPlayer(String playerId) => _playerTrackCache[playerId];
 
+  /// Get all player IDs that have cached tracks
+  Iterable<String> getAllCachedPlayerIds() => _playerTrackCache.keys;
+
   /// Set cached track for a player
   void setCachedTrackForPlayer(String playerId, Track? track) {
     _playerTrackCache[playerId] = track;
+    _playerTrackCacheTime[playerId] = DateTime.now();
+    _evictOldestEntries(_playerTrackCache, _playerTrackCacheTime, _maxPlayerTrackCacheSize);
+  }
+
+  /// Clear cached track for a player (e.g., when external source is active)
+  void clearCachedTrackForPlayer(String playerId) {
+    _playerTrackCache.remove(playerId);
+    _playerTrackCacheTime.remove(playerId);
   }
 
   // ============================================================================
@@ -242,6 +416,7 @@ class CacheService {
     _searchCache.clear();
     _searchCacheTime.clear();
     _playerTrackCache.clear();
+    _playerTrackCacheTime.clear();
     _logger.log('🗑️ All detail caches cleared');
   }
 
@@ -249,6 +424,112 @@ class CacheService {
   void clearAll() {
     invalidateHomeCache();
     clearAllDetailCaches();
+    _cachedPlayers = null;
+    _cachedSelectedPlayer = null;
     _playersLastFetched = null;
   }
+
+  // ============================================================================
+  // DATABASE PERSISTENCE FOR HOME ROWS
+  // ============================================================================
+
+  /// Load home row data from database for instant display on startup
+  Future<void> loadHomeRowsFromDatabase() async {
+    if (_homeRowsLoaded) return;
+    _homeRowsLoaded = true;
+
+    try {
+      if (!DatabaseService.instance.isInitialized) return;
+
+      // Load recent albums
+      final recentData = await DatabaseService.instance.getHomeRowCache('recent_albums');
+      if (recentData != null) {
+        try {
+          final items = (jsonDecode(recentData.itemsJson) as List)
+              .map((json) => Album.fromJson(json as Map<String, dynamic>))
+              .toList();
+          _cachedRecentAlbums = items;
+          _recentAlbumsLastFetched = recentData.lastUpdated;
+          _logger.log('📦 Loaded ${items.length} recent albums from database');
+        } catch (e) {
+          _logger.log('⚠️ Failed to parse recent albums: $e');
+        }
+      }
+
+      // Load discover artists
+      final artistsData = await DatabaseService.instance.getHomeRowCache('discover_artists');
+      if (artistsData != null) {
+        try {
+          final items = (jsonDecode(artistsData.itemsJson) as List)
+              .map((json) => Artist.fromJson(json as Map<String, dynamic>))
+              .toList();
+          _cachedDiscoverArtists = items;
+          _discoverArtistsLastFetched = artistsData.lastUpdated;
+          _logger.log('📦 Loaded ${items.length} discover artists from database');
+        } catch (e) {
+          _logger.log('⚠️ Failed to parse discover artists: $e');
+        }
+      }
+
+      // Load discover albums
+      final albumsData = await DatabaseService.instance.getHomeRowCache('discover_albums');
+      if (albumsData != null) {
+        try {
+          final items = (jsonDecode(albumsData.itemsJson) as List)
+              .map((json) => Album.fromJson(json as Map<String, dynamic>))
+              .toList();
+          _cachedDiscoverAlbums = items;
+          _discoverAlbumsLastFetched = albumsData.lastUpdated;
+          _logger.log('📦 Loaded ${items.length} discover albums from database');
+        } catch (e) {
+          _logger.log('⚠️ Failed to parse discover albums: $e');
+        }
+      }
+    } catch (e) {
+      _logger.log('⚠️ Error loading home rows from database: $e');
+    }
+  }
+
+  /// Persist home row data to database (fire-and-forget)
+  void _persistHomeRowToDatabase(String rowType, List<Map<String, dynamic>> items) {
+    () async {
+      try {
+        if (!DatabaseService.instance.isInitialized) return;
+        await DatabaseService.instance.saveHomeRowCache(rowType, jsonEncode(items));
+        _logger.log('💾 Persisted $rowType to database');
+      } catch (e) {
+        _logger.log('⚠️ Failed to persist $rowType: $e');
+      }
+    }();
+  }
+
+  // ============================================================================
+  // LRU CACHE EVICTION
+  // ============================================================================
+
+  /// Evict oldest entries from cache maps to enforce size limit (LRU eviction)
+  /// Uses the timestamp map to determine which entries are oldest
+  void _evictOldestEntries<K, V>(
+    Map<K, V> cache,
+    Map<K, DateTime> cacheTime,
+    int maxSize,
+  ) {
+    if (cache.length <= maxSize) return;
+
+    // Sort keys by timestamp (oldest first)
+    final sortedKeys = cacheTime.keys.toList()
+      ..sort((a, b) => (cacheTime[a] ?? DateTime.now())
+          .compareTo(cacheTime[b] ?? DateTime.now()));
+
+    // Remove oldest entries until we're at maxSize
+    final keysToRemove = sortedKeys.take(cache.length - maxSize);
+    for (final key in keysToRemove) {
+      cache.remove(key);
+      cacheTime.remove(key);
+    }
+
+    if (keysToRemove.isNotEmpty) {
+      _logger.log('🗑️ LRU evicted ${keysToRemove.length} cache entries');
+    }
+  }
 }

lib/services/database_service.dart

@@ -0,0 +1,314 @@
+import 'dart:convert';
+import '../database/database.dart';
+import 'debug_logger.dart';
+
+/// Singleton service for database access throughout the app
+class DatabaseService {
+  static DatabaseService? _instance;
+  static AppDatabase? _database;
+  static final _logger = DebugLogger();
+
+  DatabaseService._();
+
+  /// Get the singleton instance
+  static DatabaseService get instance {
+    _instance ??= DatabaseService._();
+    return _instance!;
+  }
+
+  /// Get the database instance
+  AppDatabase get db {
+    if (_database == null) {
+      throw StateError('Database not initialized. Call initialize() first.');
+    }
+    return _database!;
+  }
+
+  /// Check if database is initialized
+  bool get isInitialized => _database != null;
+
+  /// Initialize the database
+  Future<void> initialize() async {
+    if (_database != null) {
+      _logger.log('Database already initialized');
+      return;
+    }
+
+    _logger.log('Initializing database...');
+    _database = AppDatabase();
+    _logger.log('Database initialized successfully');
+  }
+
+  /// Close the database (for cleanup)
+  Future<void> close() async {
+    await _database?.close();
+    _database = null;
+    _logger.log('Database closed');
+  }
+
+  // ============================================
+  // Profile Convenience Methods
+  // ============================================
+
+  /// Get the currently active profile
+  Future<Profile?> getActiveProfile() => db.getActiveProfile();
+
+  /// Set the active profile (creates if doesn't exist)
+  Future<Profile> setActiveProfile({
+    required String username,
+    String? displayName,
+    required String source,
+  }) {
+    _logger.log('Setting active profile: $username (source: $source)');
+    return db.setActiveProfile(
+      username: username,
+      displayName: displayName,
+      source: source,
+    );
+  }
+
+  /// Get all profiles
+  Future<List<Profile>> getAllProfiles() => db.getAllProfiles();
+
+  // ============================================
+  // Recently Played Convenience Methods
+  // ============================================
+
+  /// Add an item to recently played
+  Future<void> addRecentlyPlayed({
+    required String mediaId,
+    required String mediaType,
+    required String name,
+    String? artistName,
+    String? imageUrl,
+    Map<String, dynamic>? metadata,
+  }) {
+    _logger.log('Adding to recently played: $name ($mediaType)');
+    return db.addRecentlyPlayed(
+      mediaId: mediaId,
+      mediaType: mediaType,
+      name: name,
+      artistName: artistName,
+      imageUrl: imageUrl,
+      metadata: metadata != null ? jsonEncode(metadata) : null,
+    );
+  }
+
+  /// Get recently played items
+  Future<List<RecentlyPlayedData>> getRecentlyPlayed({int limit = 20}) {
+    return db.getRecentlyPlayed(limit: limit);
+  }
+
+  /// Clear recently played for current profile
+  Future<void> clearRecentlyPlayed() => db.clearRecentlyPlayed();
+
+  // ============================================
+  // Library Cache Convenience Methods
+  // ============================================
+
+  /// Cache an item with JSON serialization
+  Future<void> cacheItem<T>({
+    required String itemType,
+    required String itemId,
+    required Map<String, dynamic> data,
+  }) {
+    return db.cacheItem(
+      itemType: itemType,
+      itemId: itemId,
+      data: jsonEncode(data),
+    );
+  }
+
+  /// Get cached items with JSON deserialization
+  Future<List<Map<String, dynamic>>> getCachedItems(String itemType) async {
+    final items = await db.getCachedItems(itemType);
+    return items.map((item) {
+      try {
+        return jsonDecode(item.data) as Map<String, dynamic>;
+      } catch (e) {
+        _logger.log('Error decoding cached item: $e');
+        return <String, dynamic>{};
+      }
+    }).where((item) => item.isNotEmpty).toList();
+  }
+
+  /// Get a single cached item
+  Future<Map<String, dynamic>?> getCachedItem(String itemType, String itemId) async {
+    final item = await db.getCachedItem(itemType, itemId);
+    if (item == null) return null;
+    try {
+      return jsonDecode(item.data) as Map<String, dynamic>;
+    } catch (e) {
+      _logger.log('Error decoding cached item: $e');
+      return null;
+    }
+  }
+
+  /// Check if sync is needed
+  Future<bool> needsSync(String syncType, {Duration maxAge = const Duration(minutes: 5)}) {
+    return db.needsSync(syncType, maxAge);
+  }
+
+  /// Update sync timestamp
+  Future<void> updateSyncMetadata(String syncType, int itemCount) {
+    return db.updateSyncMetadata(syncType, itemCount);
+  }
+
+  /// Clear all cached data (useful for logout)
+  Future<void> clearAllCache() => db.clearAllCache();
+
+  /// Clear cached items of a specific type (e.g., 'album', 'artist')
+  /// Used before re-syncing to remove stale items
+  Future<void> clearCacheForType(String itemType) => db.clearCache(itemType);
+
+  /// Mark a specific cached item as deleted
+  /// Used when removing items from library for immediate database update
+  Future<void> markCachedItemDeleted(String itemType, String itemId) {
+    return db.markItemsDeleted(itemType, [itemId]);
+  }
+
+  // ============================================
+  // Player Cache Convenience Methods
+  // ============================================
+
+  /// Save playback state for instant resume
+  Future<void> savePlaybackState({
+    String? playerId,
+    String? playerName,
+    String? currentTrackJson,
+    double positionSeconds = 0.0,
+    bool isPlaying = false,
+  }) {
+    return db.savePlaybackState(
+      playerId: playerId,
+      playerName: playerName,
+      currentTrackJson: currentTrackJson,
+      positionSeconds: positionSeconds,
+      isPlaying: isPlaying,
+    );
+  }
+
+  /// Get saved playback state
+  Future<PlaybackStateData?> getPlaybackState() => db.getPlaybackState();
+
+  /// Cache a player with optional track info
+  Future<void> cachePlayer({
+    required String playerId,
+    required String playerJson,
+    String? currentTrackJson,
+  }) {
+    return db.cachePlayer(
+      playerId: playerId,
+      playerJson: playerJson,
+      currentTrackJson: currentTrackJson,
+    );
+  }
+
+  /// Cache multiple players at once
+  Future<void> cachePlayers(List<Map<String, dynamic>> players) {
+    return db.cachePlayers(players);
+  }
+
+  /// Get all cached players
+  Future<List<CachedPlayer>> getCachedPlayers() => db.getCachedPlayers();
+
+  /// Update cached track for a player
+  Future<void> updateCachedPlayerTrack(String playerId, String? trackJson) {
+    return db.updateCachedPlayerTrack(playerId, trackJson);
+  }
+
+  /// Clear all cached players
+  Future<void> clearCachedPlayers() => db.clearCachedPlayers();
+
+  /// Save queue for a player
+  Future<void> saveQueue(String playerId, List<String> itemJsonList) {
+    return db.saveQueue(playerId, itemJsonList);
+  }
+
+  /// Get cached queue for a player
+  Future<List<CachedQueueData>> getCachedQueue(String playerId) {
+    return db.getCachedQueue(playerId);
+  }
+
+  /// Clear queue for a player
+  Future<void> clearCachedQueue(String playerId) => db.clearCachedQueue(playerId);
+
+  // ============================================
+  // Home Row Cache Convenience Methods
+  // ============================================
+
+  /// Save home row data (recent albums, discover artists, etc.)
+  Future<void> saveHomeRowCache(String rowType, String itemsJson) {
+    return db.saveHomeRowCache(rowType, itemsJson);
+  }
+
+  /// Get cached home row data
+  Future<HomeRowCacheData?> getHomeRowCache(String rowType) {
+    return db.getHomeRowCache(rowType);
+  }
+
+  /// Clear all home row cache
+  Future<void> clearHomeRowCache() => db.clearHomeRowCache();
+
+  // ============================================
+  // Search History Convenience Methods
+  // ============================================
+
+  /// Save a search query to history
+  Future<void> saveSearchQuery(String query) => db.saveSearchQuery(query);
+
+  /// Get recent search queries (up to 10)
+  Future<List<String>> getRecentSearches() => db.getRecentSearches();
+
+  /// Clear all search history
+  Future<void> clearSearchHistory() => db.clearSearchHistory();
+
+  // ============================================
+  // Cast-to-Sendspin Mapping Methods
+  // ============================================
+
+  static const String _sendspinMappingType = 'cast_sendspin_mapping';
+
+  /// Save a Cast UUID to Sendspin ID mapping
+  Future<void> saveCastToSendspinMapping(String castId, String sendspinId) {
+    _logger.log('💾 Persisting Cast->Sendspin mapping: $castId -> $sendspinId');
+    return db.cacheItem(
+      itemType: _sendspinMappingType,
+      itemId: castId,
+      data: jsonEncode({'sendspinId': sendspinId}),
+    );
+  }
+
+  /// Get persisted Sendspin ID for a Cast UUID
+  Future<String?> getSendspinIdForCast(String castId) async {
+    final item = await db.getCachedItem(_sendspinMappingType, castId);
+    if (item == null) return null;
+    try {
+      final data = jsonDecode(item.data) as Map<String, dynamic>;
+      return data['sendspinId'] as String?;
+    } catch (e) {
+      _logger.log('Error decoding Sendspin mapping: $e');
+      return null;
+    }
+  }
+
+  /// Load all persisted Cast-to-Sendspin mappings
+  Future<Map<String, String>> getAllCastToSendspinMappings() async {
+    final items = await db.getCachedItems(_sendspinMappingType);
+    final mappings = <String, String>{};
+    for (final item in items) {
+      try {
+        final data = jsonDecode(item.data) as Map<String, dynamic>;
+        final sendspinId = data['sendspinId'] as String?;
+        if (sendspinId != null) {
+          // The itemId is the Cast UUID
+          mappings[item.itemId] = sendspinId;
+        }
+      } catch (e) {
+        _logger.log('Error decoding Sendspin mapping: $e');
+      }
+    }
+    _logger.log('📦 Loaded ${mappings.length} Cast->Sendspin mappings from database');
+    return mappings;
+  }
+}

lib/services/device_id_service.dart

@@ -1,36 +1,99 @@
+import 'dart:io';
+import 'dart:ui' as ui;
+import 'package:device_info_plus/device_info_plus.dart';
 import 'package:shared_preferences/shared_preferences.dart';
-import 'package:uuid/uuid.dart';
 import 'debug_logger.dart';
+import 'settings_service.dart';
 
-/// Service to generate unique per-installation player IDs
-/// Simplified to match KMP client pattern: single storage key, lazy generation
-/// This prevents the critical bug where multiple devices of the same model
-/// would share the same player ID and trigger playback on all devices
+/// Service to generate unique per-device player IDs
+/// Uses stable device identifiers (ANDROID_ID) combined with MA username
+/// to create persistent player IDs that survive storage wipes and support
+/// multiple devices per account
 class DeviceIdService {
   static const String _keyLocalPlayerId = 'local_player_id';
   static final _logger = DebugLogger();
-  static const _uuid = Uuid();
 
-  /// Get or generate a unique player ID for this installation
-  /// ID is generated once and persisted across app restarts
-  /// Format: ensemble_<uuid>
-  ///
-  /// This matches the KMP client pattern: generate on first access, store once
-  static Future<String> getOrCreateDevicePlayerId() async {
-    final prefs = await SharedPreferences.getInstance();
+  // Cache stable device ID to avoid repeated platform calls
+  static String? _cachedStableDeviceId;
 
-    // Single source of truth - no complex migration logic
-    final existingId = prefs.getString(_keyLocalPlayerId);
-    if (existingId != null && existingId.startsWith('ensemble_')) {
-      _logger.log('Using existing player ID: $existingId');
-      return existingId;
+  /// Get stable device identifier that persists across storage wipes
+  /// - Android: Uses ANDROID_ID (persists until factory reset)
+  /// - iOS: Uses identifierForVendor (persists until app reinstall)
+  static Future<String> _getStableDeviceId() async {
+    if (_cachedStableDeviceId != null) {
+      return _cachedStableDeviceId!;
     }
 
-    // Generate new ID on first access
-    final playerId = 'ensemble_${_uuid.v4()}';
-    await prefs.setString(_keyLocalPlayerId, playerId);
-    _logger.log('Generated new player ID: $playerId');
-    return playerId;
+    final deviceInfo = DeviceInfoPlugin();
+
+    if (Platform.isAndroid) {
+      final android = await deviceInfo.androidInfo;
+      // ANDROID_ID is unique per device+user combo, persists across storage wipes
+      // Only resets on factory reset
+      _cachedStableDeviceId = android.id;
+    } else if (Platform.isIOS) {
+      final ios = await deviceInfo.iosInfo;
+      // identifierForVendor persists across app updates but resets on reinstall
+      _cachedStableDeviceId = ios.identifierForVendor ?? 'unknown_ios';
+    } else {
+      // Fallback for other platforms (web, desktop)
+      _cachedStableDeviceId = 'unknown_platform';
+    }
+
+    return _cachedStableDeviceId!;
+  }
+
+  /// Detect if device is a tablet based on screen size
+  /// Uses the standard 600dp threshold (shortest side >= 600 = tablet)
+  static bool get isTablet {
+    try {
+      final view = ui.PlatformDispatcher.instance.views.first;
+      final size = view.physicalSize / view.devicePixelRatio;
+      return size.shortestSide >= 600;
+    } catch (e) {
+      _logger.log('Failed to detect device type: $e');
+      return false; // Default to phone if detection fails
+    }
+  }
+
+  /// Get or generate a unique player ID for this device
+  /// Format: ensemble_{username}_{deviceId} or ensemble_{deviceId}
+  ///
+  /// Key behaviors:
+  /// - Uses stable device ID that survives storage wipes
+  /// - Includes MA username to support multiple devices per account
+  /// - Regenerates if username changes (user logged in with different account)
+  static Future<String> getOrCreateDevicePlayerId() async {
+    final prefs = await SharedPreferences.getInstance();
+    final stableDeviceId = await _getStableDeviceId();
+    final maUsername = await SettingsService.getUsername();
+
+    // Generate expected ID based on current username and device
+    // Use shorter device ID suffix (first 8 chars) to keep ID reasonable length
+    final deviceIdSuffix = stableDeviceId.length > 8
+        ? stableDeviceId.substring(0, 8)
+        : stableDeviceId;
+
+    final expectedId = maUsername != null && maUsername.isNotEmpty
+        ? 'ensemble_${maUsername}_$deviceIdSuffix'
+        : 'ensemble_$deviceIdSuffix';
+
+    // Check if we already have the correct ID
+    final existingId = prefs.getString(_keyLocalPlayerId);
+    if (existingId == expectedId) {
+      _logger.log('Using existing player ID: $expectedId');
+      return expectedId;
+    }
+
+    // ID needs to be updated (first login, username changed, or migration)
+    if (existingId != null) {
+      _logger.log('Updating player ID from $existingId to $expectedId');
+    } else {
+      _logger.log('Generated new player ID: $expectedId');
+    }
+
+    await prefs.setString(_keyLocalPlayerId, expectedId);
+    return expectedId;
   }
 
   /// Adopt an existing player ID (used when claiming a ghost player)
@@ -45,4 +108,12 @@ class DeviceIdService {
     final prefs = await SharedPreferences.getInstance();
     return prefs.getString(_keyLocalPlayerId) == null;
   }
+
+  /// Force regeneration of player ID on next call
+  /// Useful after login/logout to ensure ID matches current user
+  static Future<void> invalidateCachedId() async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.remove(_keyLocalPlayerId);
+    _logger.log('Invalidated cached player ID');
+  }
 }

lib/services/hardware_volume_service.dart

@@ -82,5 +82,9 @@ class HardwareVolumeService {
     } catch (e) {
       _logger.error('Failed to stop volume button listening', context: 'VolumeService', error: e);
     }
+
+    // Close StreamControllers to prevent memory leaks
+    await _volumeUpController.close();
+    await _volumeDownController.close();
   }
 }

lib/services/metadata_service.dart

@@ -254,6 +254,9 @@ class MetadataService {
   // Cache for album images
   static final Map<String, String?> _albumImageCache = {};
 
+  // Cache for author images (audiobooks)
+  static final Map<String, String?> _authorImageCache = {};
+
   /// Fetches album cover URL from Deezer (free, no API key required)
   /// Returns the image URL if found, null otherwise
   static Future<String?> getAlbumImageUrl(String albumName, String? artistName) async {
@@ -323,10 +326,152 @@ 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];
+    }
+
+    // Try Audnexus (specifically for audiobook authors, uses Audible data)
+    try {
+      final audnexusUri = Uri.https(
+        'api.audnex.us',
+        '/authors',
+        {'name': authorName},
+      );
+
+      final audnexusResponse = await http.get(audnexusUri).timeout(const Duration(seconds: 5));
+
+      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;
+          }
+        }
+      }
+    } catch (e) {
+      _logger.warning('Audnexus author image error: $e', context: 'Metadata');
+    }
+
+    // Fall back to Open Library API
+    try {
+      final uri = Uri.https(
+        'openlibrary.org',
+        '/search/authors.json',
+        {
+          'q': authorName,
+          '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?;
+          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)
+            try {
+              final imageCheck = await http.head(Uri.parse(imageUrl)).timeout(const Duration(seconds: 3));
+              if (imageCheck.statusCode == 200) {
+                _authorImageCache[cacheKey] = imageUrl;
+                return imageUrl;
+              }
+            } catch (_) {
+              // Image doesn't exist, continue to cache null
+            }
+          }
+        }
+      }
+    } catch (e) {
+      _logger.warning('Open Library author image error: $e', context: 'Metadata');
+    }
+
+    // Fall back to Wikipedia API
+    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',
+        },
+      );
+
+      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?;
+          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 imageResponse = await http.get(imageUri).timeout(const Duration(seconds: 5));
+
+            if (imageResponse.statusCode == 200) {
+              final imageData = json.decode(imageResponse.body);
+              final pages = imageData['query']?['pages'] as Map<String, dynamic>?;
+              if (pages != null && pages.isNotEmpty) {
+                final page = pages.values.first as Map<String, dynamic>?;
+                final thumbnail = page?['thumbnail'] as Map<String, dynamic>?;
+                final imageUrl = thumbnail?['source'] as String?;
+                if (imageUrl != null && imageUrl.isNotEmpty) {
+                  _authorImageCache[cacheKey] = imageUrl;
+                  return imageUrl;
+                }
+              }
+            }
+          }
+        }
+      }
+    } catch (e) {
+      _logger.warning('Wikipedia author image error: $e', context: 'Metadata');
+    }
+
+    // Cache the null result to avoid repeated failed lookups
+    _authorImageCache[cacheKey] = null;
+    return null;
+  }
+
   /// Clears the metadata cache
   static void clearCache() {
     _cache.clear();
     _artistImageCache.clear();
     _albumImageCache.clear();
+    _authorImageCache.clear();
   }
 }

lib/services/offline_action_queue.dart

@@ -0,0 +1,138 @@
+import 'dart:convert';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'debug_logger.dart';
+
+/// Represents a queued action that will be executed when connection is restored
+class QueuedAction {
+  final String type;
+  final Map<String, dynamic> params;
+  final DateTime queuedAt;
+
+  QueuedAction({
+    required this.type,
+    required this.params,
+    required this.queuedAt,
+  });
+
+  Map<String, dynamic> toJson() => {
+    'type': type,
+    'params': params,
+    'queuedAt': queuedAt.toIso8601String(),
+  };
+
+  factory QueuedAction.fromJson(Map<String, dynamic> json) => QueuedAction(
+    type: json['type'] as String,
+    params: json['params'] as Map<String, dynamic>,
+    queuedAt: DateTime.parse(json['queuedAt'] as String),
+  );
+}
+
+/// Service for queuing actions when offline and executing them when back online
+class OfflineActionQueue {
+  static OfflineActionQueue? _instance;
+  static OfflineActionQueue get instance => _instance ??= OfflineActionQueue._();
+
+  OfflineActionQueue._();
+
+  final _logger = DebugLogger();
+  static const _prefsKey = 'offline_action_queue';
+
+  List<QueuedAction> _queue = [];
+  bool _isProcessing = false;
+
+  /// Get the current queue (for display)
+  List<QueuedAction> get queue => List.unmodifiable(_queue);
+
+  /// Check if there are pending actions
+  bool get hasPendingActions => _queue.isNotEmpty;
+
+  /// Number of pending actions
+  int get pendingCount => _queue.length;
+
+  /// Initialize and load persisted queue
+  Future<void> initialize() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      final queueJson = prefs.getString(_prefsKey);
+      if (queueJson != null) {
+        final List<dynamic> decoded = jsonDecode(queueJson);
+        _queue = decoded.map((j) => QueuedAction.fromJson(j as Map<String, dynamic>)).toList();
+        _logger.log('📋 Loaded ${_queue.length} offline actions from storage');
+      }
+    } catch (e) {
+      _logger.log('⚠️ Error loading offline action queue: $e');
+    }
+  }
+
+  /// Queue an action for later execution
+  Future<void> queueAction(String type, Map<String, dynamic> params) async {
+    final action = QueuedAction(
+      type: type,
+      params: params,
+      queuedAt: DateTime.now(),
+    );
+    _queue.add(action);
+    await _persistQueue();
+    _logger.log('📋 Queued offline action: $type');
+  }
+
+  /// Process all queued actions (call when connection is restored)
+  Future<void> processQueue(Future<bool> Function(QueuedAction action) executor) async {
+    if (_isProcessing || _queue.isEmpty) return;
+
+    _isProcessing = true;
+    _logger.log('🔄 Processing ${_queue.length} offline actions...');
+
+    final processed = <QueuedAction>[];
+
+    for (final action in _queue) {
+      try {
+        final success = await executor(action);
+        if (success) {
+          processed.add(action);
+          _logger.log('✅ Processed offline action: ${action.type}');
+        } else {
+          _logger.log('⚠️ Failed to process offline action: ${action.type}');
+        }
+      } catch (e) {
+        _logger.log('❌ Error processing offline action: $e');
+      }
+    }
+
+    // Remove processed actions
+    _queue.removeWhere((a) => processed.contains(a));
+    await _persistQueue();
+
+    _isProcessing = false;
+    _logger.log('📋 ${processed.length} actions processed, ${_queue.length} remaining');
+  }
+
+  /// Clear all queued actions
+  Future<void> clearQueue() async {
+    _queue.clear();
+    await _persistQueue();
+    _logger.log('🗑️ Offline action queue cleared');
+  }
+
+  /// Persist queue to storage
+  Future<void> _persistQueue() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      if (_queue.isEmpty) {
+        await prefs.remove(_prefsKey);
+      } else {
+        final queueJson = jsonEncode(_queue.map((a) => a.toJson()).toList());
+        await prefs.setString(_prefsKey, queueJson);
+      }
+    } catch (e) {
+      _logger.log('⚠️ Error persisting offline action queue: $e');
+    }
+  }
+}
+
+/// Action types for offline queuing
+class OfflineActionTypes {
+  static const String toggleFavorite = 'toggle_favorite';
+  static const String addToPlaylist = 'add_to_playlist';
+  static const String removeFromPlaylist = 'remove_from_playlist';
+}

lib/services/pcm_audio_player.dart

@@ -68,6 +68,7 @@ class PcmAudioPlayer {
   final List<Uint8List> _audioBuffer = [];
   bool _isFeeding = false;
   bool _isStarted = false;
+  bool _isAutoRecovering = false;  // Tracks auto-recovery from setup errors
   Completer<void>? _feedCompleter;  // Tracks when current feed operation completes
 
   // Error callback for operation failures
@@ -82,6 +83,11 @@ class PcmAudioPlayer {
   // Reduced from 8000 to 5000 frames (~104ms vs ~166ms) for faster response
   static const int _feedThreshold = 5000;
 
+  // Maximum buffer size to prevent memory overflow (~10 seconds of audio)
+  // At 48kHz stereo 16-bit: 192KB/sec, so ~2MB for 10 seconds
+  // Each chunk is ~4KB, so max ~500 chunks
+  static const int _maxBufferChunks = 500;
+
   // Stats
   int _framesPlayed = 0;
   int _bytesPlayed = 0;
@@ -200,33 +206,93 @@ class PcmAudioPlayer {
     return true;
   }
 
+  /// Safely add audio data to buffer with overflow protection
+  void _addToBuffer(Uint8List audioData) {
+    // If buffer is full, drop oldest chunks to make room
+    while (_audioBuffer.length >= _maxBufferChunks) {
+      _audioBuffer.removeAt(0);
+      _logger.log('⚠️ PcmAudioPlayer: Buffer overflow - dropping oldest chunk');
+    }
+    _audioBuffer.add(audioData);
+  }
+
   /// Handle incoming audio data from the stream
   void _onAudioData(Uint8List audioData) {
-    // Ignore data if in error state or if in transitional/paused state
+    // Ignore data if in error state
     if (_state == PcmPlayerState.error) return;
+
+    // Handle audio arriving during paused/transitional states
+    // This can happen when audio frames arrive before stream/start message (race condition)
+    // We need to auto-recover in this case
     if (_shouldBlockFeeding) {
-      // Silently ignore audio data when paused or transitioning
-      // This prevents buffer accumulation during pause and any race conditions
+      // If we're paused and audio is arriving, this is likely a new stream
+      // starting before the stream/start message. Queue for auto-recovery.
+      if (_state == PcmPlayerState.paused && !_isAutoRecovering) {
+        _logger.log('PcmAudioPlayer: Audio arriving while paused - initiating auto-recovery');
+        _isAutoRecovering = true;
+        _addToBuffer(audioData);
+
+        // Trigger async recovery
+        _autoRecoverFromPause();
+        return;
+      }
+
+      // If already recovering or in transitional state, buffer the data
+      if (_isAutoRecovering) {
+        _addToBuffer(audioData);
+        return;
+      }
+
+      // For other blocking states (pausing, stopping, resuming), ignore
       return;
     }
 
-    // Add to buffer
-    _audioBuffer.add(audioData);
+    // Add to buffer with overflow protection
+    _addToBuffer(audioData);
 
     // Start playback if not already started
     if (!_isStarted && _state == PcmPlayerState.ready) {
       _startPlayback();
     }
 
-    // NOTE: Auto-resume from paused state has been removed to prevent race conditions.
-    // The provider should explicitly call play() when ready to resume.
-
     // Feed data if not currently feeding
     if (!_isFeeding && _isStarted) {
       _feedNextChunk();
     }
   }
 
+  /// Auto-recover from paused state when audio arrives unexpectedly
+  Future<void> _autoRecoverFromPause() async {
+    _logger.log('PcmAudioPlayer: Auto-recovering from pause');
+
+    try {
+      // Re-initialize the native player
+      await pcm.FlutterPcmSound.setup(
+        sampleRate: _format.sampleRate,
+        channelCount: _format.channels,
+      );
+      await pcm.FlutterPcmSound.setFeedThreshold(_feedThreshold);
+      pcm.FlutterPcmSound.setFeedCallback(_onFeedRequested);
+      await pcm.FlutterPcmSound.start();
+
+      _isStarted = true;
+      _state = PcmPlayerState.playing;
+      _startElapsedTimeTimer();
+      _logger.log('PcmAudioPlayer: Auto-recovery from pause successful');
+
+      // Start feeding buffered data
+      _isAutoRecovering = false;
+      if (_audioBuffer.isNotEmpty && !_isFeeding) {
+        _feedNextChunk();
+      }
+    } catch (e) {
+      _logger.log('PcmAudioPlayer: Auto-recovery from pause failed: $e');
+      _isAutoRecovering = false;
+      _state = PcmPlayerState.error;
+      _emitError(PcmPlayerError.resumeFailed, e.toString());
+    }
+  }
+
   /// Start audio playback
   Future<void> _startPlayback() async {
     if (_isStarted) return;
@@ -298,7 +364,41 @@ class PcmAudioPlayer {
 
         // Check state again before the async feed call
         if (samples.isNotEmpty && !_shouldBlockFeeding) {
-          await pcm.FlutterPcmSound.feed(pcm.PcmArrayInt16.fromList(samples));
+          try {
+            await pcm.FlutterPcmSound.feed(pcm.PcmArrayInt16.fromList(samples));
+          } catch (feedError) {
+            // Auto-recover from "must call setup first" error
+            // This happens when audio frames arrive before stream/start message
+            if (feedError.toString().contains('must call setup first') && !_isAutoRecovering) {
+              _logger.log('PcmAudioPlayer: Auto-recovering from setup error');
+              _isAutoRecovering = true;
+
+              try {
+                // Re-initialize the native player
+                await pcm.FlutterPcmSound.setup(
+                  sampleRate: _format.sampleRate,
+                  channelCount: _format.channels,
+                );
+                await pcm.FlutterPcmSound.setFeedThreshold(_feedThreshold);
+                pcm.FlutterPcmSound.setFeedCallback(_onFeedRequested);
+                await pcm.FlutterPcmSound.start();
+                _isStarted = true;
+                _state = PcmPlayerState.playing;
+                _startElapsedTimeTimer();
+                _logger.log('PcmAudioPlayer: Auto-recovery successful');
+
+                // Retry the feed with the current chunk
+                await pcm.FlutterPcmSound.feed(pcm.PcmArrayInt16.fromList(samples));
+              } catch (recoveryError) {
+                _logger.log('PcmAudioPlayer: Auto-recovery failed: $recoveryError');
+                _isAutoRecovering = false;
+                rethrow;
+              }
+              _isAutoRecovering = false;
+            } else {
+              rethrow;
+            }
+          }
 
           // Don't update stats if we got paused during the feed
           if (!_shouldBlockFeeding) {

lib/services/position_tracker.dart

@@ -24,6 +24,10 @@ class PositionTracker {
   double _anchorPosition = 0.0;  // Position in seconds at anchor time
   DateTime _anchorTime = DateTime.now();  // When we set the anchor
 
+  // Maximum time to interpolate from a stale anchor before capping
+  // After this, we stop adding time to prevent indefinite drift
+  static const Duration _maxAnchorAge = Duration(seconds: 30);
+
   // Interpolation timer
   Timer? _interpolationTimer;
 
@@ -43,7 +47,13 @@ class PositionTracker {
     }
 
     final now = DateTime.now();
-    final elapsed = now.difference(_anchorTime).inMilliseconds / 1000.0;
+    final anchorAge = now.difference(_anchorTime);
+
+    // Cap interpolation at max anchor age to prevent indefinite drift
+    // If anchor is stale, return last known position (anchor + max age)
+    final elapsed = anchorAge > _maxAnchorAge
+        ? _maxAnchorAge.inMilliseconds / 1000.0
+        : anchorAge.inMilliseconds / 1000.0;
     final interpolated = _anchorPosition + elapsed;
 
     // Cap at duration to prevent overflow
@@ -61,7 +71,12 @@ class PositionTracker {
     }
 
     final now = DateTime.now();
-    final elapsed = now.difference(_anchorTime).inMilliseconds / 1000.0;
+    final anchorAge = now.difference(_anchorTime);
+
+    // Cap interpolation at max anchor age to prevent indefinite drift
+    final elapsed = anchorAge > _maxAnchorAge
+        ? _maxAnchorAge.inMilliseconds / 1000.0
+        : anchorAge.inMilliseconds / 1000.0;
     final interpolated = _anchorPosition + elapsed;
 
     // Cap at duration

lib/services/profile_service.dart

@@ -0,0 +1,110 @@
+import 'database_service.dart';
+import 'settings_service.dart';
+import 'debug_logger.dart';
+import '../database/database.dart';
+
+/// Service for managing user profiles
+/// Profiles are auto-created from MA authentication or manual name entry
+class ProfileService {
+  static ProfileService? _instance;
+  static final _logger = DebugLogger();
+
+  ProfileService._();
+
+  /// Get the singleton instance
+  static ProfileService get instance {
+    _instance ??= ProfileService._();
+    return _instance!;
+  }
+
+  DatabaseService get _db => DatabaseService.instance;
+
+  /// Get the currently active profile
+  Future<Profile?> getActiveProfile() async {
+    if (!_db.isInitialized) return null;
+    return _db.getActiveProfile();
+  }
+
+  /// Get the active profile's username/name
+  Future<String?> getActiveProfileName() async {
+    final profile = await getActiveProfile();
+    return profile?.displayName ?? profile?.username;
+  }
+
+  /// Called after successful MA authentication
+  /// Creates or activates profile based on MA user info
+  Future<Profile> onMaAuthenticated({
+    required String username,
+    String? displayName,
+  }) async {
+    _logger.log('MA authenticated: username=$username, displayName=$displayName');
+
+    final profile = await _db.setActiveProfile(
+      username: username,
+      displayName: displayName,
+      source: 'ma_auth',
+    );
+
+    _logger.log('Profile activated: ${profile.username} (${profile.displayName})');
+    return profile;
+  }
+
+  /// Called when user manually enters their name (no MA auth)
+  /// Creates or activates profile based on entered name
+  Future<Profile> onManualNameEntered(String name) async {
+    _logger.log('Manual name entered: $name');
+
+    // Use name as both username and display name for manual profiles
+    final profile = await _db.setActiveProfile(
+      username: name.toLowerCase().replaceAll(' ', '_'),
+      displayName: name,
+      source: 'manual',
+    );
+
+    _logger.log('Profile activated: ${profile.username} (${profile.displayName})');
+    return profile;
+  }
+
+  /// Migrate existing ownerName to profile (one-time migration)
+  Future<void> migrateFromOwnerName() async {
+    if (!_db.isInitialized) return;
+
+    // Check if we already have any profiles
+    final profiles = await _db.getAllProfiles();
+    if (profiles.isNotEmpty) {
+      _logger.log('Migration skipped - profiles already exist');
+      return;
+    }
+
+    // Check for existing ownerName in settings
+    final ownerName = await SettingsService.getOwnerName();
+    if (ownerName == null || ownerName.isEmpty) {
+      _logger.log('Migration skipped - no ownerName to migrate');
+      return;
+    }
+
+    _logger.log('Migrating ownerName "$ownerName" to profile...');
+
+    // Create profile from ownerName
+    // We don't know if it was MA auth or manual, so default to manual
+    await _db.setActiveProfile(
+      username: ownerName.toLowerCase().replaceAll(' ', '_'),
+      displayName: ownerName,
+      source: 'migrated',
+    );
+
+    _logger.log('Migration complete');
+  }
+
+  /// Get all profiles (for potential profile switcher UI)
+  Future<List<Profile>> getAllProfiles() async {
+    if (!_db.isInitialized) return [];
+    return _db.getAllProfiles();
+  }
+
+  /// Check if any profile exists
+  Future<bool> hasAnyProfile() async {
+    final profiles = await getAllProfiles();
+    return profiles.isNotEmpty;
+  }
+}

lib/services/recently_played_service.dart

@@ -0,0 +1,259 @@
+import 'dart:convert';
+import 'database_service.dart';
+import 'debug_logger.dart';
+import '../database/database.dart';
+import '../models/media_item.dart';
+
+/// Service for tracking recently played items locally, per-profile
+/// This supplements MA's server-side tracking with instant local data
+class RecentlyPlayedService {
+  static RecentlyPlayedService? _instance;
+  static final _logger = DebugLogger();
+
+  RecentlyPlayedService._();
+
+  /// Get the singleton instance
+  static RecentlyPlayedService get instance {
+    _instance ??= RecentlyPlayedService._();
+    return _instance!;
+  }
+
+  DatabaseService get _db => DatabaseService.instance;
+
+  /// Record an album being played
+  Future<void> recordAlbumPlayed(Album album) async {
+    if (!_db.isInitialized) return;
+
+    try {
+      // Store images metadata for instant artwork display
+      final images = album.metadata?['images'];
+      await _db.addRecentlyPlayed(
+        mediaId: album.itemId,
+        mediaType: 'album',
+        name: album.name,
+        artistName: album.artistsString,
+        metadata: {
+          'provider': album.provider,
+          'uri': album.uri,
+          if (images != null) 'images': images,
+        },
+      );
+      _logger.log('📝 Recorded album play: ${album.name}');
+    } catch (e) {
+      _logger.log('⚠️ Failed to record album play: $e');
+    }
+  }
+
+  /// Record an artist being played (e.g., artist radio)
+  Future<void> recordArtistPlayed(Artist artist) async {
+    if (!_db.isInitialized) return;
+
+    try {
+      await _db.addRecentlyPlayed(
+        mediaId: artist.itemId,
+        mediaType: 'artist',
+        name: artist.name,
+        metadata: {
+          'provider': artist.provider,
+          'uri': artist.uri,
+        },
+      );
+      _logger.log('📝 Recorded artist play: ${artist.name}');
+    } catch (e) {
+      _logger.log('⚠️ Failed to record artist play: $e');
+    }
+  }
+
+  /// Record a track being played
+  Future<void> recordTrackPlayed(Track track) async {
+    if (!_db.isInitialized) return;
+
+    try {
+      await _db.addRecentlyPlayed(
+        mediaId: track.itemId,
+        mediaType: 'track',
+        name: track.name,
+        artistName: track.artistsString,
+        metadata: {
+          'provider': track.provider,
+          'uri': track.uri,
+          'albumName': track.album?.name,
+        },
+      );
+      _logger.log('📝 Recorded track play: ${track.name}');
+    } catch (e) {
+      _logger.log('⚠️ Failed to record track play: $e');
+    }
+  }
+
+  /// Record a playlist being played
+  Future<void> recordPlaylistPlayed(Playlist playlist) async {
+    if (!_db.isInitialized) return;
+
+    try {
+      await _db.addRecentlyPlayed(
+        mediaId: playlist.itemId,
+        mediaType: 'playlist',
+        name: playlist.name,
+        metadata: {
+          'provider': playlist.provider,
+          'uri': playlist.uri,
+        },
+      );
+      _logger.log('📝 Recorded playlist play: ${playlist.name}');
+    } catch (e) {
+      _logger.log('⚠️ Failed to record playlist play: $e');
+    }
+  }
+
+  /// Record an audiobook being played
+  Future<void> recordAudiobookPlayed(Audiobook audiobook) async {
+    if (!_db.isInitialized) return;
+
+    try {
+      await _db.addRecentlyPlayed(
+        mediaId: audiobook.itemId,
+        mediaType: 'audiobook',
+        name: audiobook.name,
+        artistName: audiobook.authorsString,
+        metadata: {
+          'provider': audiobook.provider,
+          'uri': audiobook.uri,
+          'narrators': audiobook.narratorsString,
+          'duration': audiobook.duration?.inSeconds,
+          'resumePositionMs': audiobook.resumePositionMs,
+        },
+      );
+      _logger.log('📝 Recorded audiobook play: ${audiobook.name}');
+    } catch (e) {
+      _logger.log('⚠️ Failed to record audiobook play: $e');
+    }
+  }
+
+  /// Get recently played albums for the current profile
+  /// Returns Album objects reconstructed from local data
+  Future<List<Album>> getRecentAlbums({int limit = 20}) async {
+    if (!_db.isInitialized) return [];
+
+    try {
+      final items = await _db.getRecentlyPlayed(limit: limit * 2); // Get more to filter
+
+      // Filter for albums and convert to Album objects
+      final albums = <Album>[];
+      final seenIds = <String>{};
+
+      for (final item in items) {
+        if (item.mediaType != 'album') continue;
+        if (seenIds.contains(item.mediaId)) continue;
+        seenIds.add(item.mediaId);
+
+        Map<String, dynamic>? metadata;
+        if (item.metadata != null) {
+          try {
+            metadata = jsonDecode(item.metadata!) as Map<String, dynamic>;
+          } catch (e) {
+            // Corrupted metadata JSON - log and continue with null metadata
+            _logger.log('⚠️ Error parsing album metadata for ${item.mediaId}: $e');
+          }
+        }
+
+        // Build metadata with images if available (for instant artwork display)
+        Map<String, dynamic>? albumMetadata;
+        if (metadata?['images'] != null) {
+          albumMetadata = {'images': metadata!['images']};
+        }
+
+        albums.add(Album(
+          itemId: item.mediaId,
+          provider: metadata?['provider'] ?? 'library',
+          name: item.name,
+          uri: metadata?['uri'],
+          // Create minimal artist info from stored name
+          artists: item.artistName != null
+              ? [Artist(itemId: '', provider: '', name: item.artistName!)]
+              : null,
+          metadata: albumMetadata,
+        ));
+
+        if (albums.length >= limit) break;
+      }
+
+      return albums;
+    } catch (e) {
+      _logger.log('⚠️ Failed to get recent albums: $e');
+      return [];
+    }
+  }
+
+  /// Get recently played audiobooks for the current profile
+  /// Returns Audiobook objects reconstructed from local data
+  Future<List<Audiobook>> getRecentAudiobooks({int limit = 20}) async {
+    if (!_db.isInitialized) return [];
+
+    try {
+      final items = await _db.getRecentlyPlayed(limit: limit * 2); // Get more to filter
+
+      // Filter for audiobooks and convert to Audiobook objects
+      final audiobooks = <Audiobook>[];
+      final seenIds = <String>{};
+
+      for (final item in items) {
+        if (item.mediaType != 'audiobook') continue;
+        if (seenIds.contains(item.mediaId)) continue;
+        seenIds.add(item.mediaId);
+
+        Map<String, dynamic>? metadata;
+        if (item.metadata != null) {
+          try {
+            metadata = jsonDecode(item.metadata!) as Map<String, dynamic>;
+          } catch (e) {
+            // Corrupted metadata JSON - log and continue with null metadata
+            _logger.log('⚠️ Error parsing audiobook metadata for ${item.mediaId}: $e');
+          }
+        }
+
+        audiobooks.add(Audiobook(
+          itemId: item.mediaId,
+          provider: metadata?['provider'] ?? 'library',
+          name: item.name,
+          uri: metadata?['uri'],
+          // Create minimal author info from stored name
+          authors: item.artistName != null
+              ? [Artist(itemId: '', provider: '', name: item.artistName!)]
+              : null,
+          duration: metadata?['duration'] != null
+              ? Duration(seconds: metadata!['duration'] as int)
+              : null,
+          resumePositionMs: metadata?['resumePositionMs'] as int?,
+        ));
+
+        if (audiobooks.length >= limit) break;
+      }
+
+      return audiobooks;
+    } catch (e) {
+      _logger.log('⚠️ Failed to get recent audiobooks: $e');
+      return [];
+    }
+  }
+
+  /// Get all recently played items for the current profile
+  Future<List<RecentlyPlayedData>> getRecentlyPlayed({int limit = 20}) async {
+    if (!_db.isInitialized) return [];
+    return _db.getRecentlyPlayed(limit: limit);
+  }
+
+  /// Check if we have local recently played data
+  Future<bool> hasLocalData() async {
+    if (!_db.isInitialized) return false;
+    final items = await _db.getRecentlyPlayed(limit: 1);
+    return items.isNotEmpty;
+  }
+
+  /// Clear recently played for current profile
+  Future<void> clear() async {
+    if (!_db.isInitialized) return;
+    await _db.clearRecentlyPlayed();
+    _logger.log('🗑️ Cleared recently played');
+  }
+}

lib/services/secure_storage_service.dart

@@ -0,0 +1,148 @@
+import 'package:flutter_secure_storage/flutter_secure_storage.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'dart:convert';
+
+/// Service for securely storing sensitive data like passwords and tokens.
+/// Uses platform-specific secure storage (Keychain on iOS, EncryptedSharedPreferences on Android).
+class SecureStorageService {
+  static const _storage = FlutterSecureStorage(
+    aOptions: AndroidOptions(
+      encryptedSharedPreferences: true,
+    ),
+  );
+
+  // Keys for secure storage
+  static const String _keyAuthToken = 'secure_auth_token';
+  static const String _keyMaAuthToken = 'secure_ma_auth_token';
+  static const String _keyAuthCredentials = 'secure_auth_credentials';
+  static const String _keyPassword = 'secure_password';
+  static const String _keyAbsApiToken = 'secure_abs_api_token';
+
+  // Auth Token (for stream requests)
+  static Future<String?> getAuthToken() async {
+    return await _storage.read(key: _keyAuthToken);
+  }
+
+  static Future<void> setAuthToken(String? token) async {
+    if (token == null || token.isEmpty) {
+      await _storage.delete(key: _keyAuthToken);
+    } else {
+      await _storage.write(key: _keyAuthToken, value: token);
+    }
+  }
+
+  // Music Assistant Native Auth Token (long-lived token)
+  static Future<String?> getMaAuthToken() async {
+    return await _storage.read(key: _keyMaAuthToken);
+  }
+
+  static Future<void> setMaAuthToken(String? token) async {
+    if (token == null || token.isEmpty) {
+      await _storage.delete(key: _keyMaAuthToken);
+    } else {
+      await _storage.write(key: _keyMaAuthToken, value: token);
+    }
+  }
+
+  static Future<void> clearMaAuthToken() async {
+    await _storage.delete(key: _keyMaAuthToken);
+  }
+
+  // Auth Credentials (serialized auth strategy credentials)
+  static Future<Map<String, dynamic>?> getAuthCredentials() async {
+    final json = await _storage.read(key: _keyAuthCredentials);
+    if (json == null) return null;
+    try {
+      return jsonDecode(json) as Map<String, dynamic>;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  static Future<void> setAuthCredentials(Map<String, dynamic> credentials) async {
+    await _storage.write(key: _keyAuthCredentials, value: jsonEncode(credentials));
+  }
+
+  static Future<void> clearAuthCredentials() async {
+    await _storage.delete(key: _keyAuthCredentials);
+  }
+
+  // Password
+  static Future<String?> getPassword() async {
+    return await _storage.read(key: _keyPassword);
+  }
+
+  static Future<void> setPassword(String? password) async {
+    if (password == null || password.isEmpty) {
+      await _storage.delete(key: _keyPassword);
+    } else {
+      await _storage.write(key: _keyPassword, value: password);
+    }
+  }
+
+  // Audiobookshelf API Token
+  static Future<String?> getAbsApiToken() async {
+    return await _storage.read(key: _keyAbsApiToken);
+  }
+
+  static Future<void> setAbsApiToken(String? token) async {
+    if (token == null || token.isEmpty) {
+      await _storage.delete(key: _keyAbsApiToken);
+    } else {
+      await _storage.write(key: _keyAbsApiToken, value: token);
+    }
+  }
+
+  /// Clear all secure storage (used during logout)
+  static Future<void> clearAll() async {
+    await _storage.deleteAll();
+  }
+
+  /// Migrate credentials from SharedPreferences to secure storage.
+  /// Call this once during app upgrade to migrate existing users.
+  static Future<void> migrateFromSharedPreferences() async {
+    // Import SharedPreferences for migration
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+
+    // Migrate auth token
+    final authToken = prefs.getString('auth_token');
+    if (authToken != null && authToken.isNotEmpty) {
+      await setAuthToken(authToken);
+      await prefs.remove('auth_token');
+    }
+
+    // Migrate MA auth token
+    final maAuthToken = prefs.getString('ma_auth_token');
+    if (maAuthToken != null && maAuthToken.isNotEmpty) {
+      await setMaAuthToken(maAuthToken);
+      await prefs.remove('ma_auth_token');
+    }
+
+    // Migrate auth credentials
+    final authCredentials = prefs.getString('auth_credentials');
+    if (authCredentials != null && authCredentials.isNotEmpty) {
+      try {
+        final decoded = jsonDecode(authCredentials) as Map<String, dynamic>;
+        await setAuthCredentials(decoded);
+        await prefs.remove('auth_credentials');
+      } catch (_) {
+        // Invalid JSON, just remove it
+        await prefs.remove('auth_credentials');
+      }
+    }
+
+    // Migrate password
+    final password = prefs.getString('password');
+    if (password != null && password.isNotEmpty) {
+      await setPassword(password);
+      await prefs.remove('password');
+    }
+
+    // Migrate ABS API token
+    final absApiToken = prefs.getString('abs_api_token');
+    if (absApiToken != null && absApiToken.isNotEmpty) {
+      await setAbsApiToken(absApiToken);
+      await prefs.remove('abs_api_token');
+    }
+  }
+}

lib/services/sendspin_service.dart

@@ -84,14 +84,32 @@ class SendspinService {
 
   bool _isDisposed = false;
 
+  // Auth token for proxy authentication (MA 2.7.1+)
+  String? _authToken;
+
+  // Connection deduplication guard - prevents multiple concurrent auth attempts
+  Completer<bool>? _connectionInProgress;
+
   SendspinService(this.serverUrl);
 
+  /// Set the MA auth token for proxy authentication
+  void setAuthToken(String? token) {
+    _authToken = token;
+  }
+
   /// Initialize and connect to Sendspin server
   /// Uses persistent player ID and username-based naming
   Future<bool> connect() async {
     if (_isDisposed) return false;
     if (_state == SendspinConnectionState.connected) return true;
 
+    // Deduplicate concurrent connection attempts
+    if (_connectionInProgress != null) {
+      _logger.log('Sendspin: Connection already in progress, waiting...');
+      return _connectionInProgress!.future;
+    }
+    _connectionInProgress = Completer<bool>();
+
     _updateState(SendspinConnectionState.connecting);
 
     try {
@@ -105,26 +123,32 @@ class SendspinService {
       bool connected = false;
 
       // Strategy 1: If server is HTTPS, try external wss:// first
+      // Use proxy auth for MA 2.7.1+ - the proxy requires authentication before hello
       if (_isHttpsServer()) {
         final externalUrl = _buildExternalSendspinUrl();
         _logger.log('Sendspin: Trying external URL: $externalUrl');
-        connected = await _tryConnect(externalUrl, timeout: const Duration(seconds: 3));
+        connected = await _tryConnect(externalUrl, timeout: const Duration(seconds: 5), useProxyAuth: true);
       }
 
-      // Strategy 2: If external failed or server is HTTP, try local connection
-      // Note: We would need local_ws_url from getSendspinConnectionInfo API
-      // For now, skip this step and fall back to WebRTC (handled by provider)
+      // Note: Local network connections (ws://ip:8927/sendspin) are handled
+      // by the provider calling connectWithUrl() directly, not by this method.
 
       if (!connected) {
-        _logger.log('Sendspin: External connection failed, WebRTC fallback needed');
+        _logger.log('Sendspin: External proxy connection failed');
         _updateState(SendspinConnectionState.error);
+        _connectionInProgress?.complete(false);
+        _connectionInProgress = null;
         return false;
       }
 
+      _connectionInProgress?.complete(true);
+      _connectionInProgress = null;
       return true;
     } catch (e) {
       _logger.log('Sendspin: Connection error: $e');
       _updateState(SendspinConnectionState.error);
+      _connectionInProgress?.complete(false);
+      _connectionInProgress = null;
       return false;
     }
   }
@@ -134,6 +158,13 @@ class SendspinService {
     if (_isDisposed) return false;
     if (_state == SendspinConnectionState.connected) return true;
 
+    // Deduplicate concurrent connection attempts
+    if (_connectionInProgress != null) {
+      _logger.log('Sendspin: Connection already in progress, waiting...');
+      return _connectionInProgress!.future;
+    }
+    _connectionInProgress = Completer<bool>();
+
     _updateState(SendspinConnectionState.connecting);
 
     try {
@@ -146,22 +177,29 @@ class SendspinService {
 
       if (!connected) {
         _updateState(SendspinConnectionState.error);
+        _connectionInProgress?.complete(false);
+        _connectionInProgress = null;
         return false;
       }
 
+      _connectionInProgress?.complete(true);
+      _connectionInProgress = null;
       return true;
     } catch (e) {
       _logger.log('Sendspin: Connection error: $e');
       _updateState(SendspinConnectionState.error);
+      _connectionInProgress?.complete(false);
+      _connectionInProgress = null;
       return false;
     }
   }
 
   /// Attempt to connect to a specific WebSocket URL
-  Future<bool> _tryConnect(String url, {Duration timeout = const Duration(seconds: 5)}) async {
+  /// If useProxyAuth is true and we have an auth token, authenticate first (for MA 2.7.1+ proxy)
+  Future<bool> _tryConnect(String url, {Duration timeout = const Duration(seconds: 5), bool useProxyAuth = false}) async {
     try {
       // Connect to the base URL without query params - we send player info in hello message
-      _logger.log('Sendspin: Connecting to $url');
+      _logger.log('Sendspin: Connecting to $url${useProxyAuth ? ' (with proxy auth)' : ''}');
 
       // Create WebSocket connection
       final webSocket = await WebSocket.connect(url).timeout(timeout);
@@ -176,6 +214,29 @@ class SendspinService {
         onDone: _handleDone,
       );
 
+      // If using proxy auth (MA 2.7.1+), authenticate first
+      if (useProxyAuth && _authToken != null) {
+        _logger.log('Sendspin: Sending proxy auth with token');
+        _sendMessage({
+          'type': 'auth',
+          'token': _authToken,
+        }, allowDuringHandshake: true);
+
+        // Wait for auth_ok response
+        final authOk = await _waitForAuth().timeout(
+          const Duration(seconds: 5),
+          onTimeout: () => false,
+        );
+
+        if (!authOk) {
+          _logger.log('Sendspin: Proxy authentication failed or timed out');
+          await _channel?.sink.close();
+          _channel = null;
+          return false;
+        }
+        _logger.log('Sendspin: Proxy auth successful, proceeding with hello');
+      }
+
       // Send client/hello message immediately after connecting
       // This is required by the Sendspin protocol - server waits for this
       // Message format follows aiosendspin protocol spec
@@ -228,12 +289,18 @@ class SendspinService {
 
   /// Wait for server acknowledgment after connection
   Completer<bool>? _ackCompleter;
+  Completer<bool>? _authCompleter;
 
   Future<bool> _waitForAck() async {
     _ackCompleter = Completer<bool>();
     return _ackCompleter!.future;
   }
 
+  Future<bool> _waitForAuth() async {
+    _authCompleter = Completer<bool>();
+    return _authCompleter!.future;
+  }
+
   /// Handle incoming WebSocket messages
   /// WebSocket can send text frames (JSON control messages) or binary frames (PCM audio data)
   void _handleMessage(dynamic message) {
@@ -310,6 +377,14 @@ class SendspinService {
           onStreamEnd?.call();
           break;
 
+        case 'auth_ok':
+          // Proxy authentication successful (MA 2.7.1+)
+          _logger.log('Sendspin: Proxy authentication successful');
+          if (_authCompleter != null && !_authCompleter!.isCompleted) {
+            _authCompleter!.complete(true);
+          }
+          break;
+
         case 'ack':
         case 'connected':
         case 'registered':
@@ -472,8 +547,9 @@ class SendspinService {
     if (muted != null) _isMuted = muted;
 
     // Determine player state for Sendspin protocol
-    // 'synchronized' = ready/playing, 'idle' = not playing
-    final playerState = _isPlaying || _isPaused ? 'synchronized' : 'idle';
+    // Valid values: 'synchronized', 'error', 'external_source'
+    // When connected, we're always synchronized (ready to receive audio)
+    const playerState = 'synchronized';
 
     _sendMessage({
       'type': 'client/state',
@@ -534,7 +610,7 @@ class SendspinService {
     _sendMessage({
       'type': 'client/time',
       'payload': {
-        'timestamp': timestampMicroseconds,
+        'client_transmitted': timestampMicroseconds,
       },
     }, allowDuringHandshake: allowDuringHandshake);
   }

lib/services/settings_service.dart

@@ -1,5 +1,7 @@
 import 'package:shared_preferences/shared_preferences.dart';
 import 'dart:convert';
+import 'device_id_service.dart';
+import 'secure_storage_service.dart';
 
 class SettingsService {
   static const String _keyServerUrl = 'server_url';
@@ -15,18 +17,82 @@ class SettingsService {
   static const String _keyUseMaterialTheme = 'use_material_theme';
   static const String _keyAdaptiveTheme = 'adaptive_theme';
   static const String _keyCustomColor = 'custom_color';
+  static const String _keyLocale = 'locale';
   static const String _keyLastFmApiKey = 'lastfm_api_key';
   static const String _keyTheAudioDbApiKey = 'theaudiodb_api_key';
   static const String _keyEnableLocalPlayback = 'enable_local_playback';
   static const String _keyLocalPlayerName = 'local_player_name';
   static const String _keyOwnerName = 'owner_name';
   static const String _keyLastSelectedPlayerId = 'last_selected_player_id';
+  static const String _keyPreferLocalPlayer = 'prefer_local_player';
+  static const String _keySmartSortPlayers = 'smart_sort_players';
   static const String _keyShowRecentAlbums = 'show_recent_albums';
   static const String _keyShowDiscoverArtists = 'show_discover_artists';
   static const String _keyShowDiscoverAlbums = 'show_discover_albums';
+  static const String _keyShowContinueListeningAudiobooks = 'show_continue_listening_audiobooks';
+  static const String _keyShowDiscoverAudiobooks = 'show_discover_audiobooks';
+  static const String _keyShowDiscoverSeries = 'show_discover_series';
   static const String _keyShowFavoriteAlbums = 'show_favorite_albums';
   static const String _keyShowFavoriteArtists = 'show_favorite_artists';
   static const String _keyShowFavoriteTracks = 'show_favorite_tracks';
+  static const String _keyShowFavoritePlaylists = 'show_favorite_playlists';
+  static const String _keyShowFavoriteRadioStations = 'show_favorite_radio_stations';
+  static const String _keyShowOnlyArtistsWithAlbums = 'show_only_artists_with_albums'; // Library artists filter
+  static const String _keyHomeRowOrder = 'home_row_order'; // JSON list of row IDs
+
+  // Default row order
+  static const List<String> defaultHomeRowOrder = [
+    'recent-albums',
+    'discover-artists',
+    'discover-albums',
+    'continue-listening',
+    'discover-audiobooks',
+    'discover-series',
+    'favorite-albums',
+    'favorite-artists',
+    'favorite-tracks',
+    'favorite-playlists',
+    'favorite-radio-stations',
+  ];
+
+  // View Mode Settings
+  static const String _keyArtistAlbumsSortOrder = 'artist_albums_sort_order'; // 'alpha' or 'year'
+  static const String _keyArtistAlbumsViewMode = 'artist_albums_view_mode'; // 'grid2', 'grid3', 'list'
+  static const String _keyLibraryArtistsViewMode = 'library_artists_view_mode'; // 'grid2', 'grid3', 'list'
+  static const String _keyLibraryAlbumsViewMode = 'library_albums_view_mode'; // 'grid2', 'grid3', 'list'
+  static const String _keyLibraryPlaylistsViewMode = 'library_playlists_view_mode'; // 'grid2', 'grid3', 'list'
+
+  // Audiobook View Mode Settings
+  static const String _keyAuthorAudiobooksSortOrder = 'author_audiobooks_sort_order'; // 'alpha' or 'year'
+  static const String _keyAuthorAudiobooksViewMode = 'author_audiobooks_view_mode'; // 'grid2', 'grid3', 'list'
+  static const String _keyLibraryAuthorsViewMode = 'library_authors_view_mode'; // 'grid2', 'grid3', 'list'
+  static const String _keyLibraryAudiobooksViewMode = 'library_audiobooks_view_mode'; // 'grid2', 'grid3', 'list'
+  static const String _keyLibraryAudiobooksSortOrder = 'library_audiobooks_sort_order'; // 'alpha' or 'year'
+  static const String _keyLibrarySeriesViewMode = 'library_series_view_mode'; // 'grid2', 'grid3', 'list'
+  static const String _keySeriesAudiobooksSortOrder = 'series_audiobooks_sort_order'; // 'alpha' or 'year'
+  static const String _keySeriesAudiobooksViewMode = 'series_audiobooks_view_mode'; // 'grid2', 'grid3', 'list'
+  static const String _keyLibraryRadioViewMode = 'library_radio_view_mode'; // 'grid2', 'grid3', 'list'
+  static const String _keyLibraryPodcastsViewMode = 'library_podcasts_view_mode'; // 'grid2', 'grid3', 'list'
+
+  // Audiobookshelf Direct Integration Settings
+  static const String _keyAbsServerUrl = 'abs_server_url';
+  static const String _keyAbsApiToken = 'abs_api_token';
+  static const String _keyAbsEnabled = 'abs_enabled';
+
+  // Audiobookshelf Library Settings (via MA browse)
+  static const String _keyEnabledAbsLibraries = 'enabled_abs_libraries'; // JSON list of library paths
+  static const String _keyDiscoveredAbsLibraries = 'discovered_abs_libraries'; // JSON list of {path, name}
+
+  // Hint System Settings
+  static const String _keyShowHints = 'show_hints'; // Master toggle for hints
+  static const String _keyHasUsedPlayerReveal = 'has_used_player_reveal'; // Track if user has pulled to reveal players
+  static const String _keyHasCompletedOnboarding = 'has_completed_onboarding'; // Track if user has seen welcome screen
+
+  // Volume Precision Mode Settings
+  static const String _keyVolumePrecisionMode = 'volume_precision_mode'; // Enable hold-to-precision volume control
+
+  // Podcast Cover Cache (iTunes URLs for high-res artwork)
+  static const String _keyPodcastCoverCache = 'podcast_cover_cache';
 
   static Future<String?> getServerUrl() async {
     final prefs = await SharedPreferences.getInstance();
@@ -75,66 +141,44 @@ class SettingsService {
     }
   }
 
-  // Get authentication token for stream requests
+  // Get authentication token for stream requests (securely stored)
   static Future<String?> getAuthToken() async {
-    final prefs = await SharedPreferences.getInstance();
-    return prefs.getString(_keyAuthToken);
+    return await SecureStorageService.getAuthToken();
   }
 
-  // Set authentication token for stream requests
+  // Set authentication token for stream requests (securely stored)
   static Future<void> setAuthToken(String? token) async {
-    final prefs = await SharedPreferences.getInstance();
-    if (token == null || token.isEmpty) {
-      await prefs.remove(_keyAuthToken);
-    } else {
-      await prefs.setString(_keyAuthToken, token);
-    }
+    await SecureStorageService.setAuthToken(token);
   }
 
-  // Get Music Assistant native auth token (long-lived token)
+  // Get Music Assistant native auth token (long-lived token, securely stored)
   static Future<String?> getMaAuthToken() async {
-    final prefs = await SharedPreferences.getInstance();
-    return prefs.getString(_keyMaAuthToken);
+    return await SecureStorageService.getMaAuthToken();
   }
 
-  // Set Music Assistant native auth token (long-lived token)
+  // Set Music Assistant native auth token (long-lived token, securely stored)
   static Future<void> setMaAuthToken(String? token) async {
-    final prefs = await SharedPreferences.getInstance();
-    if (token == null || token.isEmpty) {
-      await prefs.remove(_keyMaAuthToken);
-    } else {
-      await prefs.setString(_keyMaAuthToken, token);
-    }
+    await SecureStorageService.setMaAuthToken(token);
   }
 
   // Clear Music Assistant native auth token
   static Future<void> clearMaAuthToken() async {
-    final prefs = await SharedPreferences.getInstance();
-    await prefs.remove(_keyMaAuthToken);
+    await SecureStorageService.clearMaAuthToken();
   }
 
-  // Get authentication credentials (serialized auth strategy credentials)
+  // Get authentication credentials (serialized auth strategy credentials, securely stored)
   static Future<Map<String, dynamic>?> getAuthCredentials() async {
-    final prefs = await SharedPreferences.getInstance();
-    final json = prefs.getString(_keyAuthCredentials);
-    if (json == null) return null;
-    try {
-      return jsonDecode(json) as Map<String, dynamic>;
-    } catch (e) {
-      return null;
-    }
+    return await SecureStorageService.getAuthCredentials();
   }
 
-  // Set authentication credentials (serialized auth strategy credentials)
+  // Set authentication credentials (serialized auth strategy credentials, securely stored)
   static Future<void> setAuthCredentials(Map<String, dynamic> credentials) async {
-    final prefs = await SharedPreferences.getInstance();
-    await prefs.setString(_keyAuthCredentials, jsonEncode(credentials));
+    await SecureStorageService.setAuthCredentials(credentials);
   }
 
   // Clear authentication credentials
   static Future<void> clearAuthCredentials() async {
-    final prefs = await SharedPreferences.getInstance();
-    await prefs.remove(_keyAuthCredentials);
+    await SecureStorageService.clearAuthCredentials();
   }
 
   // Get username for authentication
@@ -153,20 +197,14 @@ class SettingsService {
     }
   }
 
-  // Get password for authentication
+  // Get password for authentication (securely stored)
   static Future<String?> getPassword() async {
-    final prefs = await SharedPreferences.getInstance();
-    return prefs.getString(_keyPassword);
+    return await SecureStorageService.getPassword();
   }
 
-  // Set password for authentication
+  // Set password for authentication (securely stored)
   static Future<void> setPassword(String? password) async {
-    final prefs = await SharedPreferences.getInstance();
-    if (password == null || password.isEmpty) {
-      await prefs.remove(_keyPassword);
-    } else {
-      await prefs.setString(_keyPassword, password);
-    }
+    await SecureStorageService.setPassword(password);
   }
 
   // Get built-in player ID (persistent UUID for this device)
@@ -222,6 +260,21 @@ class SettingsService {
     await prefs.setString(_keyCustomColor, color);
   }
 
+  // Locale (null = system default)
+  static Future<String?> getLocale() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyLocale);
+  }
+
+  static Future<void> saveLocale(String? locale) async {
+    final prefs = await SharedPreferences.getInstance();
+    if (locale == null) {
+      await prefs.remove(_keyLocale);
+    } else {
+      await prefs.setString(_keyLocale, locale);
+    }
+  }
+
   // Metadata API Keys
   static Future<String?> getLastFmApiKey() async {
     final prefs = await SharedPreferences.getInstance();
@@ -305,19 +358,50 @@ class SettingsService {
     }
   }
 
+  // Prefer Local Player - always select local player first when available
+  static Future<bool> getPreferLocalPlayer() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyPreferLocalPlayer) ?? false;
+  }
+
+  static Future<void> setPreferLocalPlayer(bool prefer) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyPreferLocalPlayer, prefer);
+  }
+
+  // Smart Sort Players - sort by status (playing > on > off) instead of alphabetically
+  static Future<bool> getSmartSortPlayers() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keySmartSortPlayers) ?? false;
+  }
+
+  static Future<void> setSmartSortPlayers(bool smartSort) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keySmartSortPlayers, smartSort);
+  }
+
   // Helper to create player name with possessive apostrophe
+  // Automatically detects Phone vs Tablet based on screen size
   static String _makePlayerName(String ownerName) {
-    // Handle possessive: "Chris" -> "Chris' Phone", "Mom" -> "Mom's Phone"
+    final deviceType = DeviceIdService.isTablet ? 'Tablet' : 'Phone';
+    // Handle possessive: "Chris" -> "Chris' Tablet", "Mom" -> "Mom's Phone"
     if (ownerName.toLowerCase().endsWith('s')) {
-      return "$ownerName' Phone";
+      return "$ownerName' $deviceType";
     } else {
-      return "$ownerName's Phone";
+      return "$ownerName's $deviceType";
     }
   }
 
   static Future<void> clearSettings() async {
     final prefs = await SharedPreferences.getInstance();
     await prefs.clear();
+    await SecureStorageService.clearAll(); // Also clear secure storage
+  }
+
+  /// Migrate credentials from old SharedPreferences storage to secure storage.
+  /// Should be called once during app startup for existing users.
+  static Future<void> migrateToSecureStorage() async {
+    await SecureStorageService.migrateFromSharedPreferences();
   }
 
   // Home Screen Row Settings (Main rows - default on)
@@ -351,6 +435,37 @@ class SettingsService {
     await prefs.setBool(_keyShowDiscoverAlbums, show);
   }
 
+  // Home Screen Audiobook Rows (default off - optional)
+  static Future<bool> getShowContinueListeningAudiobooks() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyShowContinueListeningAudiobooks) ?? false;
+  }
+
+  static Future<void> setShowContinueListeningAudiobooks(bool show) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyShowContinueListeningAudiobooks, show);
+  }
+
+  static Future<bool> getShowDiscoverAudiobooks() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyShowDiscoverAudiobooks) ?? false;
+  }
+
+  static Future<void> setShowDiscoverAudiobooks(bool show) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyShowDiscoverAudiobooks, show);
+  }
+
+  static Future<bool> getShowDiscoverSeries() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyShowDiscoverSeries) ?? false;
+  }
+
+  static Future<void> setShowDiscoverSeries(bool show) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyShowDiscoverSeries, show);
+  }
+
   // Home Screen Favorites Settings (default off)
   static Future<bool> getShowFavoriteAlbums() async {
     final prefs = await SharedPreferences.getInstance();
@@ -381,4 +496,403 @@ class SettingsService {
     final prefs = await SharedPreferences.getInstance();
     await prefs.setBool(_keyShowFavoriteTracks, show);
   }
+
+  static Future<bool> getShowFavoritePlaylists() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyShowFavoritePlaylists) ?? false;
+  }
+
+  static Future<void> setShowFavoritePlaylists(bool show) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyShowFavoritePlaylists, show);
+  }
+
+  static Future<bool> getShowFavoriteRadioStations() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyShowFavoriteRadioStations) ?? false;
+  }
+
+  static Future<void> setShowFavoriteRadioStations(bool show) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyShowFavoriteRadioStations, show);
+  }
+
+  // Library Artists Filter - show only artists that have albums in library
+  static Future<bool> getShowOnlyArtistsWithAlbums() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyShowOnlyArtistsWithAlbums) ?? false;
+  }
+
+  static Future<void> setShowOnlyArtistsWithAlbums(bool show) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyShowOnlyArtistsWithAlbums, show);
+  }
+
+  // Home Row Order
+  static Future<List<String>> getHomeRowOrder() async {
+    final prefs = await SharedPreferences.getInstance();
+    final json = prefs.getString(_keyHomeRowOrder);
+    if (json != null) {
+      try {
+        final List<dynamic> decoded = jsonDecode(json);
+        return decoded.cast<String>();
+      } catch (_) {
+        return List.from(defaultHomeRowOrder);
+      }
+    }
+    return List.from(defaultHomeRowOrder);
+  }
+
+  static Future<void> setHomeRowOrder(List<String> order) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyHomeRowOrder, jsonEncode(order));
+  }
+
+  // View Mode Settings - Artist Albums
+  static Future<String> getArtistAlbumsSortOrder() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyArtistAlbumsSortOrder) ?? 'alpha';
+  }
+
+  static Future<void> setArtistAlbumsSortOrder(String order) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyArtistAlbumsSortOrder, order);
+  }
+
+  static Future<String> getArtistAlbumsViewMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyArtistAlbumsViewMode) ?? 'grid2';
+  }
+
+  static Future<void> setArtistAlbumsViewMode(String mode) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyArtistAlbumsViewMode, mode);
+  }
+
+  // View Mode Settings - Library Artists
+  static Future<String> getLibraryArtistsViewMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyLibraryArtistsViewMode) ?? 'list';
+  }
+
+  static Future<void> setLibraryArtistsViewMode(String mode) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyLibraryArtistsViewMode, mode);
+  }
+
+  // View Mode Settings - Library Albums
+  static Future<String> getLibraryAlbumsViewMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyLibraryAlbumsViewMode) ?? 'grid2';
+  }
+
+  static Future<void> setLibraryAlbumsViewMode(String mode) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyLibraryAlbumsViewMode, mode);
+  }
+
+  // View Mode Settings - Library Playlists
+  static Future<String> getLibraryPlaylistsViewMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyLibraryPlaylistsViewMode) ?? 'list';
+  }
+
+  static Future<void> setLibraryPlaylistsViewMode(String mode) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyLibraryPlaylistsViewMode, mode);
+  }
+
+  // View Mode Settings - Author Audiobooks (author detail screen)
+  static Future<String> getAuthorAudiobooksSortOrder() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyAuthorAudiobooksSortOrder) ?? 'alpha';
+  }
+
+  static Future<void> setAuthorAudiobooksSortOrder(String order) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyAuthorAudiobooksSortOrder, order);
+  }
+
+  static Future<String> getAuthorAudiobooksViewMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyAuthorAudiobooksViewMode) ?? 'grid2';
+  }
+
+  static Future<void> setAuthorAudiobooksViewMode(String mode) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyAuthorAudiobooksViewMode, mode);
+  }
+
+  // View Mode Settings - Library Authors
+  static Future<String> getLibraryAuthorsViewMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyLibraryAuthorsViewMode) ?? 'list';
+  }
+
+  static Future<void> setLibraryAuthorsViewMode(String mode) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyLibraryAuthorsViewMode, mode);
+  }
+
+  // View Mode Settings - Library Audiobooks
+  static Future<String> getLibraryAudiobooksViewMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyLibraryAudiobooksViewMode) ?? 'grid2';
+  }
+
+  static Future<void> setLibraryAudiobooksViewMode(String mode) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyLibraryAudiobooksViewMode, mode);
+  }
+
+  static Future<String> getLibraryAudiobooksSortOrder() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyLibraryAudiobooksSortOrder) ?? 'alpha';
+  }
+
+  static Future<void> setLibraryAudiobooksSortOrder(String order) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyLibraryAudiobooksSortOrder, order);
+  }
+
+  static Future<String> getLibrarySeriesViewMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyLibrarySeriesViewMode) ?? 'grid2';
+  }
+
+  static Future<void> setLibrarySeriesViewMode(String mode) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyLibrarySeriesViewMode, mode);
+  }
+
+  static Future<String> getLibraryRadioViewMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyLibraryRadioViewMode) ?? 'list';
+  }
+
+  static Future<void> setLibraryRadioViewMode(String mode) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyLibraryRadioViewMode, mode);
+  }
+
+  static Future<String> getLibraryPodcastsViewMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyLibraryPodcastsViewMode) ?? 'grid2';
+  }
+
+  static Future<void> setLibraryPodcastsViewMode(String mode) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyLibraryPodcastsViewMode, mode);
+  }
+
+  // View Mode Settings - Series Audiobooks (series detail screen)
+  static Future<String> getSeriesAudiobooksSortOrder() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keySeriesAudiobooksSortOrder) ?? 'series';
+  }
+
+  static Future<void> setSeriesAudiobooksSortOrder(String order) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keySeriesAudiobooksSortOrder, order);
+  }
+
+  static Future<String> getSeriesAudiobooksViewMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keySeriesAudiobooksViewMode) ?? 'grid2';
+  }
+
+  static Future<void> setSeriesAudiobooksViewMode(String mode) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keySeriesAudiobooksViewMode, mode);
+  }
+
+  // Audiobookshelf Settings
+  static Future<String?> getAbsServerUrl() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_keyAbsServerUrl);
+  }
+
+  static Future<void> setAbsServerUrl(String url) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyAbsServerUrl, url);
+  }
+
+  static Future<String?> getAbsApiToken() async {
+    return await SecureStorageService.getAbsApiToken();
+  }
+
+  static Future<void> setAbsApiToken(String token) async {
+    await SecureStorageService.setAbsApiToken(token);
+  }
+
+  static Future<bool> getAbsEnabled() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyAbsEnabled) ?? false;
+  }
+
+  static Future<void> setAbsEnabled(bool enabled) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyAbsEnabled, enabled);
+  }
+
+  static Future<void> clearAbsSettings() async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.remove(_keyAbsServerUrl);
+    await prefs.remove(_keyAbsEnabled);
+    await SecureStorageService.setAbsApiToken(null); // Clear from secure storage
+  }
+
+  // Audiobookshelf Library Settings (via MA browse API)
+
+  /// Get list of enabled library paths (all enabled by default if not set)
+  static Future<List<String>?> getEnabledAbsLibraries() async {
+    final prefs = await SharedPreferences.getInstance();
+    final json = prefs.getString(_keyEnabledAbsLibraries);
+    if (json == null) return null; // null means all libraries are enabled
+    try {
+      final list = jsonDecode(json) as List<dynamic>;
+      return list.cast<String>();
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /// Set list of enabled library paths
+  static Future<void> setEnabledAbsLibraries(List<String> paths) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyEnabledAbsLibraries, jsonEncode(paths));
+  }
+
+  /// Clear enabled libraries (reverts to all enabled)
+  static Future<void> clearEnabledAbsLibraries() async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.remove(_keyEnabledAbsLibraries);
+  }
+
+  /// Get discovered libraries [{path: String, name: String}]
+  static Future<List<Map<String, String>>?> getDiscoveredAbsLibraries() async {
+    final prefs = await SharedPreferences.getInstance();
+    final json = prefs.getString(_keyDiscoveredAbsLibraries);
+    if (json == null) return null;
+    try {
+      final list = jsonDecode(json) as List<dynamic>;
+      return list.map((e) => Map<String, String>.from(e as Map)).toList();
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /// Save discovered libraries
+  static Future<void> setDiscoveredAbsLibraries(List<Map<String, String>> libraries) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyDiscoveredAbsLibraries, jsonEncode(libraries));
+  }
+
+  /// Check if a specific library is enabled
+  static Future<bool> isAbsLibraryEnabled(String libraryPath) async {
+    final enabled = await getEnabledAbsLibraries();
+    if (enabled == null) return true; // All enabled by default
+    return enabled.contains(libraryPath);
+  }
+
+  /// Toggle a specific library
+  static Future<void> toggleAbsLibrary(String libraryPath, bool enable) async {
+    final discovered = await getDiscoveredAbsLibraries();
+    if (discovered == null) return;
+
+    var enabled = await getEnabledAbsLibraries();
+    // If null (all enabled), initialize with all library paths
+    enabled ??= discovered.map((lib) => lib['path']!).toList();
+
+    if (enable && !enabled.contains(libraryPath)) {
+      enabled.add(libraryPath);
+    } else if (!enable && enabled.contains(libraryPath)) {
+      enabled.remove(libraryPath);
+    }
+
+    await setEnabledAbsLibraries(enabled);
+  }
+
+  // Hint System Settings
+
+  /// Get whether hints are enabled (default: true)
+  static Future<bool> getShowHints() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyShowHints) ?? true;
+  }
+
+  /// Set whether hints are enabled
+  static Future<void> setShowHints(bool show) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyShowHints, show);
+  }
+
+  /// Check if user has ever used the player reveal gesture
+  static Future<bool> getHasUsedPlayerReveal() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyHasUsedPlayerReveal) ?? false;
+  }
+
+  /// Mark that user has used the player reveal gesture
+  static Future<void> setHasUsedPlayerReveal(bool hasUsed) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyHasUsedPlayerReveal, hasUsed);
+  }
+
+  /// Check if user has completed onboarding (seen welcome screen)
+  static Future<bool> getHasCompletedOnboarding() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyHasCompletedOnboarding) ?? false;
+  }
+
+  /// Mark that user has completed onboarding
+  static Future<void> setHasCompletedOnboarding(bool completed) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyHasCompletedOnboarding, completed);
+  }
+
+  // Volume Precision Mode Settings
+
+  /// Get whether volume precision mode is enabled (default: true)
+  /// When enabled, holding still while adjusting volume enters precision mode
+  /// for fine-grained control (10x more precise)
+  static Future<bool> getVolumePrecisionMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyVolumePrecisionMode) ?? true;
+  }
+
+  /// Set whether volume precision mode is enabled
+  static Future<void> setVolumePrecisionMode(bool enabled) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyVolumePrecisionMode, enabled);
+  }
+
+  // Podcast Cover Cache (iTunes URLs for high-res artwork)
+  // Stored as JSON: {"podcastId": "itunesUrl", ...}
+
+  /// Get cached podcast cover URLs (iTunes high-res)
+  static Future<Map<String, String>> getPodcastCoverCache() async {
+    final prefs = await SharedPreferences.getInstance();
+    final json = prefs.getString(_keyPodcastCoverCache);
+    if (json == null) return {};
+    try {
+      final decoded = jsonDecode(json) as Map<String, dynamic>;
+      return decoded.map((key, value) => MapEntry(key, value as String));
+    } catch (_) {
+      return {};
+    }
+  }
+
+  /// Save podcast cover cache
+  static Future<void> setPodcastCoverCache(Map<String, String> cache) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_keyPodcastCoverCache, jsonEncode(cache));
+  }
+
+  /// Add a single podcast cover to cache (for incremental updates)
+  static Future<void> addPodcastCoverToCache(String podcastId, String url) async {
+    final cache = await getPodcastCoverCache();
+    cache[podcastId] = url;
+    await setPodcastCoverCache(cache);
+  }
 }

lib/services/sync_service.dart

@@ -0,0 +1,310 @@
+import 'dart:async';
+import 'dart:convert';
+import 'package:flutter/foundation.dart';
+import '../models/media_item.dart';
+import 'database_service.dart';
+import 'debug_logger.dart';
+import 'music_assistant_api.dart';
+import 'settings_service.dart';
+
+/// Sync status for UI indicators
+enum SyncStatus {
+  idle,
+  syncing,
+  completed,
+  error,
+}
+
+/// Service for background library synchronization
+/// Loads from database cache first, then syncs from MA API in background
+class SyncService with ChangeNotifier {
+  static SyncService? _instance;
+  static final _logger = DebugLogger();
+
+  SyncService._();
+
+  static SyncService get instance {
+    _instance ??= SyncService._();
+    return _instance!;
+  }
+
+  DatabaseService get _db => DatabaseService.instance;
+
+  // Sync state
+  SyncStatus _status = SyncStatus.idle;
+  String? _lastError;
+  DateTime? _lastSyncTime;
+  bool _isSyncing = false;
+
+  // Cached data (loaded from DB, updated after sync)
+  List<Album> _cachedAlbums = [];
+  List<Artist> _cachedArtists = [];
+  List<Audiobook> _cachedAudiobooks = [];
+  List<Playlist> _cachedPlaylists = [];
+
+  // Getters
+  SyncStatus get status => _status;
+  String? get lastError => _lastError;
+  DateTime? get lastSyncTime => _lastSyncTime;
+  bool get isSyncing => _isSyncing;
+  List<Album> get cachedAlbums => _cachedAlbums;
+  List<Artist> get cachedArtists => _cachedArtists;
+  List<Audiobook> get cachedAudiobooks => _cachedAudiobooks;
+  List<Playlist> get cachedPlaylists => _cachedPlaylists;
+  bool get hasCache => _cachedAlbums.isNotEmpty || _cachedArtists.isNotEmpty ||
+                       _cachedAudiobooks.isNotEmpty || _cachedPlaylists.isNotEmpty;
+
+  /// Load library data from database cache (instant)
+  /// Call this on app startup for immediate data
+  Future<void> loadFromCache() async {
+    if (!_db.isInitialized) {
+      _logger.log('⚠️ Database not initialized, skipping cache load');
+      return;
+    }
+
+    try {
+      _logger.log('📦 Loading library from database cache...');
+
+      // Load albums from cache
+      final albumData = await _db.getCachedItems('album');
+      _cachedAlbums = albumData.map((data) {
+        try {
+          return Album.fromJson(data);
+        } 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) {
+        try {
+          return Artist.fromJson(data);
+        } 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) {
+        try {
+          return Audiobook.fromJson(data);
+        } 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) {
+        try {
+          return Playlist.fromJson(data);
+        } 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');
+      notifyListeners();
+    } catch (e) {
+      _logger.log('❌ Failed to load from cache: $e');
+    }
+  }
+
+  /// 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 {
+    if (_isSyncing) {
+      _logger.log('🔄 Sync already in progress, skipping');
+      return;
+    }
+
+    if (!_db.isInitialized) {
+      _logger.log('⚠️ Database not initialized, skipping sync');
+      return;
+    }
+
+    // Check if sync is needed (default: every 5 minutes)
+    if (!force) {
+      final albumsNeedSync = await _db.needsSync('albums', maxAge: const Duration(minutes: 5));
+      final artistsNeedSync = await _db.needsSync('artists', maxAge: const Duration(minutes: 5));
+      final audiobooksNeedSync = await _db.needsSync('audiobooks', maxAge: const Duration(minutes: 5));
+      final playlistsNeedSync = await _db.needsSync('playlists', maxAge: const Duration(minutes: 5));
+
+      if (!albumsNeedSync && !artistsNeedSync && !audiobooksNeedSync && !playlistsNeedSync) {
+        _logger.log('✅ Cache is fresh, skipping sync');
+        return;
+      }
+    }
+
+    _isSyncing = true;
+    _status = SyncStatus.syncing;
+    _lastError = null;
+    notifyListeners();
+
+    try {
+      _logger.log('🔄 Starting background library sync...');
+
+      // Read artist filter setting - when ON, only fetch artists that have albums
+      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),
+      ]);
+
+      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('📥 Fetched ${albums.length} albums, ${artists.length} artists, '
+                  '${audiobooks.length} audiobooks, ${playlists.length} playlists from MA');
+
+      // 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');
+
+      // Save to database cache
+      await _saveAlbumsToCache(albums);
+      await _saveArtistsToCache(artists);
+      await _saveAudiobooksToCache(audiobooks);
+      await _savePlaylistsToCache(playlists);
+
+      // Update sync metadata
+      await _db.updateSyncMetadata('albums', albums.length);
+      await _db.updateSyncMetadata('artists', artists.length);
+      await _db.updateSyncMetadata('audiobooks', audiobooks.length);
+      await _db.updateSyncMetadata('playlists', playlists.length);
+
+      // Update in-memory cache
+      _cachedAlbums = albums;
+      _cachedArtists = artists;
+      _cachedAudiobooks = audiobooks;
+      _cachedPlaylists = playlists;
+      _lastSyncTime = DateTime.now();
+      _status = SyncStatus.completed;
+
+      _logger.log('✅ Library sync complete');
+    } catch (e) {
+      _logger.log('❌ Library sync failed: $e');
+      _status = SyncStatus.error;
+      _lastError = e.toString();
+    } finally {
+      _isSyncing = false;
+      notifyListeners();
+    }
+  }
+
+  /// Save albums to database cache
+  Future<void> _saveAlbumsToCache(List<Album> albums) async {
+    for (final album in albums) {
+      try {
+        await _db.cacheItem(
+          itemType: 'album',
+          itemId: album.itemId,
+          data: album.toJson(),
+        );
+      } catch (e) {
+        _logger.log('⚠️ Failed to cache album ${album.name}: $e');
+      }
+    }
+    _logger.log('💾 Saved ${albums.length} albums to cache');
+  }
+
+  /// Save artists to database cache
+  Future<void> _saveArtistsToCache(List<Artist> artists) async {
+    for (final artist in artists) {
+      try {
+        await _db.cacheItem(
+          itemType: 'artist',
+          itemId: artist.itemId,
+          data: artist.toJson(),
+        );
+      } catch (e) {
+        _logger.log('⚠️ Failed to cache artist ${artist.name}: $e');
+      }
+    }
+    _logger.log('💾 Saved ${artists.length} artists to cache');
+  }
+
+  /// Save audiobooks to database cache
+  Future<void> _saveAudiobooksToCache(List<Audiobook> audiobooks) async {
+    for (final audiobook in audiobooks) {
+      try {
+        await _db.cacheItem(
+          itemType: 'audiobook',
+          itemId: audiobook.itemId,
+          data: audiobook.toJson(),
+        );
+      } catch (e) {
+        _logger.log('⚠️ Failed to cache audiobook ${audiobook.name}: $e');
+      }
+    }
+    _logger.log('💾 Saved ${audiobooks.length} audiobooks to cache');
+  }
+
+  /// Save playlists to database cache
+  Future<void> _savePlaylistsToCache(List<Playlist> playlists) async {
+    for (final playlist in playlists) {
+      try {
+        await _db.cacheItem(
+          itemType: 'playlist',
+          itemId: playlist.itemId,
+          data: playlist.toJson(),
+        );
+      } catch (e) {
+        _logger.log('⚠️ Failed to cache playlist ${playlist.name}: $e');
+      }
+    }
+    _logger.log('💾 Saved ${playlists.length} playlists to cache');
+  }
+
+  /// Force a fresh sync (for pull-to-refresh)
+  Future<void> forceSync(MusicAssistantAPI api) async {
+    await syncFromApi(api, force: true);
+  }
+
+  /// Clear all cached data
+  Future<void> clearCache() async {
+    if (!_db.isInitialized) return;
+
+    await _db.clearAllCache();
+    _cachedAlbums = [];
+    _cachedArtists = [];
+    _cachedAudiobooks = [];
+    _cachedPlaylists = [];
+    _lastSyncTime = null;
+    _status = SyncStatus.idle;
+    notifyListeners();
+    _logger.log('🗑️ Library cache cleared');
+  }
+
+  /// Get albums (from cache or empty if not loaded)
+  List<Album> getAlbums() => _cachedAlbums;
+
+  /// Get artists (from cache or empty if not loaded)
+  List<Artist> getArtists() => _cachedArtists;
+
+  /// Get audiobooks (from cache or empty if not loaded)
+  List<Audiobook> getAudiobooks() => _cachedAudiobooks;
+
+  /// Get playlists (from cache or empty if not loaded)
+  List<Playlist> getPlaylists() => _cachedPlaylists;
+
+  /// Check if we have data available (from cache or sync)
+  bool get hasData => _cachedAlbums.isNotEmpty || _cachedArtists.isNotEmpty ||
+                      _cachedAudiobooks.isNotEmpty || _cachedPlaylists.isNotEmpty;
+}

lib/theme/app_theme.dart

@@ -4,7 +4,17 @@ import 'package:flutter/material.dart';
 const Color brandPrimaryColor = Color(0xFF1a1a1a);
 const Color brandAccentColor = Color(0xFF604CEC);
 
-// Brand color schemes
+// Predefined accent colors for custom theme selection
+const List<Color> accentColorOptions = [
+  Color(0xFF604CEC), // Purple (default)
+  Color(0xFF2196F3), // Blue
+  Color(0xFF009688), // Teal
+  Color(0xFFFF5722), // Deep Orange
+  Color(0xFFE91E63), // Pink
+  Color(0xFF4CAF50), // Green
+];
+
+// Brand color schemes (default)
 final ColorScheme brandLightColorScheme = ColorScheme.fromSeed(
   seedColor: brandAccentColor,
   brightness: Brightness.light,
@@ -21,6 +31,27 @@ final ColorScheme brandDarkColorScheme = ColorScheme.fromSeed(
   background: const Color(0xFF1a1a1a),
 );
 
+// Generate color schemes from a custom seed color
+ColorScheme generateLightColorScheme(Color seedColor) {
+  return ColorScheme.fromSeed(
+    seedColor: seedColor,
+    brightness: Brightness.light,
+    background: const Color(0xFFFAFAFA),
+    onBackground: const Color(0xFF1a1a1a),
+    surface: const Color(0xFFFFFFFF),
+    onSurface: const Color(0xFF1a1a1a),
+  );
+}
+
+ColorScheme generateDarkColorScheme(Color seedColor) {
+  return ColorScheme.fromSeed(
+    seedColor: seedColor,
+    brightness: Brightness.dark,
+    surface: const Color(0xFF2a2a2a),
+    background: const Color(0xFF1a1a1a),
+  );
+}
+
 class AppTheme {
   // Generate light theme
   static ThemeData lightTheme({ColorScheme? colorScheme}) {

lib/theme/theme_provider.dart

@@ -9,6 +9,7 @@ final _themeLogger = DebugLogger();
 
 /// Global function to update adaptive colors from an image URL
 /// This can be called from anywhere in the app (e.g., when tapping an album/artist)
+/// Sets isOnDetailScreen=true so nav bar will also use adaptive colors
 Future<void> updateAdaptiveColorsFromImage(BuildContext context, String? imageUrl) async {
   if (imageUrl == null || imageUrl.isEmpty) return;
 
@@ -16,7 +17,7 @@ Future<void> updateAdaptiveColorsFromImage(BuildContext context, String? imageUr
     final colorSchemes = await PaletteHelper.extractColorSchemes(CachedNetworkImageProvider(imageUrl));
     if (colorSchemes != null && context.mounted) {
       final themeProvider = context.read<ThemeProvider>();
-      themeProvider.updateAdaptiveColors(colorSchemes.$1, colorSchemes.$2);
+      themeProvider.updateAdaptiveColors(colorSchemes.$1, colorSchemes.$2, isFromDetailScreen: true);
     }
   } catch (e) {
     // Silently fail - colors will update when track plays
@@ -42,6 +43,10 @@ class ThemeProvider extends ChangeNotifier {
   ColorScheme? _adaptiveLightScheme;
   ColorScheme? _adaptiveDarkScheme;
 
+  // Track if we're on a detail screen (vs just player-extracted colors)
+  // When true, nav bar should use adaptive colors even when player is collapsed
+  bool _isOnDetailScreen = false;
+
   ThemeProvider() {
     _loadSettings();
   }
@@ -55,12 +60,14 @@ class ThemeProvider extends ChangeNotifier {
   AdaptiveColors? get adaptiveColors => _adaptiveColors;
   ColorScheme? get adaptiveLightScheme => _adaptiveLightScheme;
   ColorScheme? get adaptiveDarkScheme => _adaptiveDarkScheme;
+  bool get isOnDetailScreen => _isOnDetailScreen;
 
   /// Get the current adaptive primary color (for bottom nav highlight, etc.)
   Color get adaptivePrimaryColor => _adaptiveColors?.primary ?? _customColor;
 
   /// Get the current adaptive surface color (for bottom nav background, etc.)
   /// Returns a subtle tinted surface based on the adaptive colors
+  /// NOTE: Prefer getAdaptiveSurfaceColorFor() which respects light/dark mode
   Color? get adaptiveSurfaceColor {
     if (_adaptiveColors == null) return null;
     // Use the miniPlayer color but darkened for a subtle tinted background
@@ -68,6 +75,20 @@ class ThemeProvider extends ChangeNotifier {
     return hsl.withLightness((hsl.lightness * 0.4).clamp(0.08, 0.15)).toColor();
   }
 
+  /// Get adaptive surface color for the given brightness (light/dark mode aware)
+  /// Returns the same color as the expanded player background (scheme.surface)
+  Color? getAdaptiveSurfaceColorFor(Brightness brightness) {
+    // Pick scheme based on current mode
+    final scheme = brightness == Brightness.dark
+        ? _adaptiveDarkScheme
+        : _adaptiveLightScheme;
+
+    if (scheme == null) return null;
+
+    // Use surface - same as expanded player background (line 1234 in expandable_player.dart)
+    return scheme.surface;
+  }
+
   Future<void> _loadSettings() async {
     final themeModeString = await SettingsService.getThemeMode();
     _themeMode = _parseThemeMode(themeModeString);
@@ -147,10 +168,18 @@ class ThemeProvider extends ChangeNotifier {
   }
 
   /// Update adaptive colors from album art
-  void updateAdaptiveColors(ColorScheme? lightScheme, ColorScheme? darkScheme) {
+  /// [isFromDetailScreen] - if true, this is from navigating to a detail screen
+  /// and the nav bar should use adaptive colors even when player is collapsed
+  void updateAdaptiveColors(ColorScheme? lightScheme, ColorScheme? darkScheme, {bool isFromDetailScreen = false}) {
     _adaptiveLightScheme = lightScheme;
     _adaptiveDarkScheme = darkScheme;
 
+    // Only set detail screen flag if explicitly from a detail screen navigation
+    // Player-extracted colors should NOT set this flag
+    if (isFromDetailScreen) {
+      _isOnDetailScreen = true;
+    }
+
     // Extract AdaptiveColors from the schemes
     if (darkScheme != null) {
       _adaptiveColors = AdaptiveColors(
@@ -166,11 +195,12 @@ class ThemeProvider extends ChangeNotifier {
     notifyListeners();
   }
 
-  /// Clear adaptive colors (when no track is playing)
+  /// Clear adaptive colors (when navigating back from detail screen or no track playing)
   void clearAdaptiveColors() {
     _adaptiveColors = null;
     _adaptiveLightScheme = null;
     _adaptiveDarkScheme = null;
+    _isOnDetailScreen = false;
     notifyListeners();
   }
 }

lib/utils/search/fuzzy_matcher.dart

@@ -0,0 +1,137 @@
+import 'dart:math';
+
+/// Fuzzy string matching using Jaro-Winkler similarity.
+///
+/// Jaro-Winkler is optimized for short strings like artist/song names
+/// and gives extra weight to matching prefixes (common typos occur mid-word).
+class FuzzyMatcher {
+  /// Calculate Jaro-Winkler similarity between two strings.
+  ///
+  /// Returns a value between 0.0 (no similarity) and 1.0 (exact match).
+  ///
+  /// Jaro-Winkler gives bonus weight to strings that match from the beginning,
+  /// which is useful for handling typos like "Beetles" vs "Beatles".
+  double jaroWinklerSimilarity(String s1, String s2) {
+    if (s1 == s2) return 1.0;
+    if (s1.isEmpty || s2.isEmpty) return 0.0;
+
+    final jaro = _jaroSimilarity(s1, s2);
+
+    // Winkler modification: boost score for common prefix
+    int prefixLength = 0;
+    const maxPrefix = 4; // Standard Winkler prefix length
+    final minLen = min(s1.length, s2.length);
+    final prefixLimit = min(maxPrefix, minLen);
+
+    for (int i = 0; i < prefixLimit; i++) {
+      if (s1[i] == s2[i]) {
+        prefixLength++;
+      } else {
+        break;
+      }
+    }
+
+    const scalingFactor = 0.1; // Standard Winkler scaling factor
+    return jaro + (prefixLength * scalingFactor * (1 - jaro));
+  }
+
+  /// Calculate base Jaro similarity.
+  double _jaroSimilarity(String s1, String s2) {
+    final s1Len = s1.length;
+    final s2Len = s2.length;
+
+    // Match window: characters within this distance can match
+    final matchWindow = (max(s1Len, s2Len) / 2 - 1).floor();
+    if (matchWindow < 0) return 0.0;
+
+    final s1Matches = List.filled(s1Len, false);
+    final s2Matches = List.filled(s2Len, false);
+
+    int matches = 0;
+    int transpositions = 0;
+
+    // Find matching characters
+    for (int i = 0; i < s1Len; i++) {
+      final start = max(0, i - matchWindow);
+      final end = min(s2Len, i + matchWindow + 1);
+
+      for (int j = start; j < end; j++) {
+        if (s2Matches[j] || s1[i] != s2[j]) continue;
+        s1Matches[i] = true;
+        s2Matches[j] = true;
+        matches++;
+        break;
+      }
+    }
+
+    if (matches == 0) return 0.0;
+
+    // Count transpositions
+    int k = 0;
+    for (int i = 0; i < s1Len; i++) {
+      if (!s1Matches[i]) continue;
+      while (!s2Matches[k]) {
+        k++;
+      }
+      if (s1[i] != s2[k]) transpositions++;
+      k++;
+    }
+
+    // Jaro similarity formula
+    return (matches / s1Len +
+            matches / s2Len +
+            (matches - transpositions / 2) / matches) /
+        3;
+  }
+
+  /// Find the best match score between query tokens and text tokens.
+  ///
+  /// Useful for matching individual words when full string matching fails.
+  /// Returns the highest similarity score found between any token pair.
+  double bestTokenMatch(List<String> queryTokens, List<String> textTokens) {
+    if (queryTokens.isEmpty || textTokens.isEmpty) return 0.0;
+
+    double bestScore = 0.0;
+
+    for (final queryToken in queryTokens) {
+      for (final textToken in textTokens) {
+        final score = jaroWinklerSimilarity(queryToken, textToken);
+        if (score > bestScore) {
+          bestScore = score;
+          // Early exit if we find a perfect match
+          if (score == 1.0) return 1.0;
+        }
+      }
+    }
+
+    return bestScore;
+  }
+
+  /// Check if two strings are a fuzzy match within a threshold.
+  bool isFuzzyMatch(String s1, String s2, {double threshold = 0.85}) {
+    return jaroWinklerSimilarity(s1, s2) >= threshold;
+  }
+
+  /// Calculate average token match score.
+  ///
+  /// For each query token, finds the best matching text token,
+  /// then averages all best matches. Useful for multi-word queries.
+  double averageTokenMatch(List<String> queryTokens, List<String> textTokens) {
+    if (queryTokens.isEmpty || textTokens.isEmpty) return 0.0;
+
+    double totalScore = 0.0;
+
+    for (final queryToken in queryTokens) {
+      double bestForToken = 0.0;
+      for (final textToken in textTokens) {
+        final score = jaroWinklerSimilarity(queryToken, textToken);
+        if (score > bestForToken) {
+          bestForToken = score;
+        }
+      }
+      totalScore += bestForToken;
+    }
+
+    return totalScore / queryTokens.length;
+  }
+}

lib/utils/search/ngram_matcher.dart

@@ -0,0 +1,96 @@
+/// N-gram based string matching for partial matches.
+///
+/// Uses character bigrams (2-grams) to find partial string matches
+/// when exact and fuzzy matching fail.
+class NgramMatcher {
+  /// Generate character bigrams from text.
+  ///
+  /// Example: "hello" -> ["he", "el", "ll", "lo"]
+  ///
+  /// For strings shorter than 2 characters, returns the string itself.
+  List<String> generateBigrams(String text) {
+    if (text.length < 2) return text.isNotEmpty ? [text] : [];
+
+    final bigrams = <String>[];
+    for (int i = 0; i < text.length - 1; i++) {
+      bigrams.add(text.substring(i, i + 2));
+    }
+    return bigrams;
+  }
+
+  /// Generate character trigrams from text.
+  ///
+  /// Example: "hello" -> ["hel", "ell", "llo"]
+  List<String> generateTrigrams(String text) {
+    if (text.length < 3) return text.isNotEmpty ? [text] : [];
+
+    final trigrams = <String>[];
+    for (int i = 0; i < text.length - 2; i++) {
+      trigrams.add(text.substring(i, i + 3));
+    }
+    return trigrams;
+  }
+
+  /// Calculate bigram similarity using Dice coefficient.
+  ///
+  /// Dice coefficient: 2 * |intersection| / (|set1| + |set2|)
+  /// Returns a value between 0.0 and 1.0.
+  double bigramSimilarity(String s1, String s2) {
+    final lower1 = s1.toLowerCase();
+    final lower2 = s2.toLowerCase();
+
+    final bigrams1 = generateBigrams(lower1);
+    final bigrams2 = generateBigrams(lower2);
+
+    if (bigrams1.isEmpty || bigrams2.isEmpty) return 0.0;
+
+    final set1 = bigrams1.toSet();
+    final set2 = bigrams2.toSet();
+
+    final intersection = set1.intersection(set2).length;
+
+    // Dice coefficient
+    return (2 * intersection) / (set1.length + set2.length);
+  }
+
+  /// Calculate Jaccard similarity between bigram sets.
+  ///
+  /// Jaccard: |intersection| / |union|
+  /// More conservative than Dice coefficient.
+  double jaccardSimilarity(String s1, String s2) {
+    final lower1 = s1.toLowerCase();
+    final lower2 = s2.toLowerCase();
+
+    final bigrams1 = generateBigrams(lower1).toSet();
+    final bigrams2 = generateBigrams(lower2).toSet();
+
+    if (bigrams1.isEmpty || bigrams2.isEmpty) return 0.0;
+
+    final intersection = bigrams1.intersection(bigrams2).length;
+    final union = bigrams1.union(bigrams2).length;
+
+    return intersection / union;
+  }
+
+  /// Check if query partially matches text via bigrams.
+  ///
+  /// Uses Dice coefficient with configurable threshold.
+  bool hasPartialMatch(String query, String text, {double threshold = 0.5}) {
+    return bigramSimilarity(query, text) >= threshold;
+  }
+
+  /// Calculate containment coefficient.
+  ///
+  /// Measures how many of the query's bigrams are in the text.
+  /// Useful when query is expected to be shorter than text.
+  /// Returns |intersection| / |query bigrams|
+  double containmentScore(String query, String text) {
+    final queryBigrams = generateBigrams(query.toLowerCase()).toSet();
+    final textBigrams = generateBigrams(text.toLowerCase()).toSet();
+
+    if (queryBigrams.isEmpty) return 0.0;
+
+    final intersection = queryBigrams.intersection(textBigrams).length;
+    return intersection / queryBigrams.length;
+  }
+}

lib/utils/search/scoring_config.dart

@@ -0,0 +1,86 @@
+/// Configuration for search scoring weights and thresholds.
+///
+/// All scores are designed to work with the existing sorting system
+/// where higher scores indicate better matches.
+class ScoringConfig {
+  // Base scores for match types (primary name matching)
+  final double exactMatch;
+  final double exactMatchNoStopwords;
+  final double startsWithMatch;
+  final double startsWithNoStopwords;
+  final double wordBoundaryMatch;
+  final double wordBoundaryNoStopwords;
+  final double reverseContainsMatch;
+  final double reverseContainsNoStopwords;
+  final double containsMatch;
+  final double containsNoStopwords;
+  final double fuzzyMatchHigh;
+  final double fuzzyMatchMedium;
+  final double ngramMatch;
+  final double baseline;
+
+  // Bonuses (additive)
+  final double libraryBonus;
+  final double favoriteBonus;
+  final double artistFieldExactBonus;
+  final double artistFieldPartialBonus;
+  final double albumFieldBonus;
+  final double authorFieldExactBonus;
+  final double authorFieldPartialBonus;
+  final double narratorFieldBonus;
+  final double creatorFieldExactBonus;
+  final double creatorFieldPartialBonus;
+  final double descriptionBonus;
+
+  // Thresholds
+  final double fuzzyHighThreshold;
+  final double fuzzyMediumThreshold;
+  final double ngramThreshold;
+
+  // Minimum lengths for matching
+  final int minReverseMatchLength;
+  final int minTokenLength;
+
+  const ScoringConfig({
+    // Primary match scores
+    this.exactMatch = 100,
+    this.exactMatchNoStopwords = 95,
+    this.startsWithMatch = 85,
+    this.startsWithNoStopwords = 80,
+    this.wordBoundaryMatch = 70,
+    this.wordBoundaryNoStopwords = 65,
+    this.reverseContainsMatch = 60,
+    this.reverseContainsNoStopwords = 55,
+    this.containsMatch = 50,
+    this.containsNoStopwords = 45,
+    this.fuzzyMatchHigh = 40,
+    this.fuzzyMatchMedium = 35,
+    this.ngramMatch = 25,
+    this.baseline = 20,
+
+    // Bonuses
+    this.libraryBonus = 10,
+    this.favoriteBonus = 5,
+    this.artistFieldExactBonus = 15,
+    this.artistFieldPartialBonus = 8,
+    this.albumFieldBonus = 5,
+    this.authorFieldExactBonus = 15,
+    this.authorFieldPartialBonus = 8,
+    this.narratorFieldBonus = 5,
+    this.creatorFieldExactBonus = 15,
+    this.creatorFieldPartialBonus = 8,
+    this.descriptionBonus = 5,
+
+    // Thresholds
+    this.fuzzyHighThreshold = 0.90,
+    this.fuzzyMediumThreshold = 0.85,
+    this.ngramThreshold = 0.5,
+
+    // Minimum lengths
+    this.minReverseMatchLength = 3,
+    this.minTokenLength = 3,
+  });
+
+  /// Default configuration
+  static const ScoringConfig defaults = ScoringConfig();
+}

lib/utils/search/search_scoring.dart

@@ -0,0 +1,333 @@
+/// Search scoring system for ranking search results.
+///
+/// Provides advanced text matching including:
+/// - Stopword removal ("the Ramones" finds "Ramones")
+/// - Fuzzy matching (typo tolerance)
+/// - N-gram matching (partial matches)
+/// - Reverse matching (query contains result)
+library;
+
+export 'scoring_config.dart';
+export 'text_normalizer.dart';
+export 'fuzzy_matcher.dart';
+export 'ngram_matcher.dart';
+
+import 'dart:math';
+
+import '../../models/media_item.dart';
+import 'scoring_config.dart';
+import 'text_normalizer.dart';
+import 'fuzzy_matcher.dart';
+import 'ngram_matcher.dart';
+
+/// Main search scorer that combines all matching strategies.
+///
+/// Usage:
+/// ```dart
+/// final scorer = SearchScorer();
+/// final score = scorer.scoreItem(mediaItem, query);
+/// ```
+class SearchScorer {
+  final TextNormalizer _normalizer;
+  final FuzzyMatcher _fuzzyMatcher;
+  final NgramMatcher _ngramMatcher;
+  final ScoringConfig _config;
+
+  // Cache for normalized query (reused across items in same search)
+  String? _cachedQueryString;
+  NormalizedQuery? _cachedQuery;
+
+  SearchScorer({ScoringConfig? config})
+      : _normalizer = TextNormalizer(),
+        _fuzzyMatcher = FuzzyMatcher(),
+        _ngramMatcher = NgramMatcher(),
+        _config = config ?? ScoringConfig.defaults;
+
+  /// Access to the normalizer for external use
+  TextNormalizer get normalizer => _normalizer;
+
+  /// Clear the query cache (call when starting a new search)
+  void clearCache() {
+    _cachedQueryString = null;
+    _cachedQuery = null;
+  }
+
+  /// Score a media item against a search query.
+  ///
+  /// Returns a score where higher values indicate better matches.
+  /// Score components:
+  /// - Primary name matching (0-100)
+  /// - Secondary field bonuses (0-20)
+  /// - Library/favorite bonuses (0-15)
+  double scoreItem(MediaItem item, String query) {
+    // Use cached normalized query if available
+    if (_cachedQueryString != query) {
+      _cachedQueryString = query;
+      _cachedQuery = _normalizer.normalizeQuery(query);
+    }
+
+    final nq = _cachedQuery!;
+    if (nq.isEmpty) return 0;
+
+    final nameLower = item.name.toLowerCase();
+    final nameNoStopwords = _normalizer.normalizeTextNoStopwords(item.name);
+
+    // Calculate primary score based on name matching
+    double score = _calculatePrimaryScore(nameLower, nameNoStopwords, nq);
+
+    // Add secondary field bonuses based on media type
+    score += _calculateSecondaryScore(item, nq);
+
+    // Add library/favorite bonuses
+    score += _calculateBonuses(item);
+
+    return score;
+  }
+
+  /// Calculate primary score based on name matching.
+  double _calculatePrimaryScore(
+    String nameLower,
+    String nameNoStopwords,
+    NormalizedQuery nq,
+  ) {
+    // Tier 1: Exact match (highest priority)
+    if (nameLower == nq.normalized) {
+      return _config.exactMatch;
+    }
+    if (nameNoStopwords == nq.withoutStopwords) {
+      return _config.exactMatchNoStopwords;
+    }
+
+    // Tier 2: Starts with
+    if (nameLower.startsWith(nq.normalized)) {
+      return _config.startsWithMatch;
+    }
+    if (nameNoStopwords.startsWith(nq.withoutStopwords)) {
+      return _config.startsWithNoStopwords;
+    }
+
+    // Tier 3: Word boundary match
+    if (_matchesWordBoundary(nameLower, nq.normalized)) {
+      return _config.wordBoundaryMatch;
+    }
+    if (_matchesWordBoundary(nameNoStopwords, nq.withoutStopwords)) {
+      return _config.wordBoundaryNoStopwords;
+    }
+
+    // Tier 4: Reverse contains (result name IN query)
+    // This solves "the ramones" finding "Ramones"
+    if (_reverseContains(nq.normalized, nameLower)) {
+      return _config.reverseContainsMatch;
+    }
+    if (_reverseContains(nq.withoutStopwords, nameNoStopwords)) {
+      return _config.reverseContainsNoStopwords;
+    }
+
+    // Tier 5: Contains anywhere
+    if (nameLower.contains(nq.normalized)) {
+      return _config.containsMatch;
+    }
+    if (nameNoStopwords.contains(nq.withoutStopwords)) {
+      return _config.containsNoStopwords;
+    }
+
+    // Tier 6: Fuzzy matching (typo tolerance)
+    final fuzzyScore = _fuzzyMatcher.jaroWinklerSimilarity(
+      nq.withoutStopwords,
+      nameNoStopwords,
+    );
+    if (fuzzyScore >= _config.fuzzyHighThreshold) {
+      // Scale score based on similarity (0.90-1.0 -> 40-45)
+      return _config.fuzzyMatchHigh +
+          ((fuzzyScore - _config.fuzzyHighThreshold) * 50);
+    }
+    if (fuzzyScore >= _config.fuzzyMediumThreshold) {
+      return _config.fuzzyMatchMedium;
+    }
+
+    // Tier 7: Token-level fuzzy (individual words)
+    final tokenFuzzy = _fuzzyMatcher.bestTokenMatch(
+      nq.tokensNoStop,
+      _normalizer.tokenize(nameNoStopwords),
+    );
+    if (tokenFuzzy >= _config.fuzzyHighThreshold) {
+      return _config.fuzzyMatchMedium;
+    }
+
+    // Tier 8: N-gram partial matching
+    final ngramScore = _ngramMatcher.bigramSimilarity(
+      nq.withoutStopwords,
+      nameNoStopwords,
+    );
+    if (ngramScore >= _config.ngramThreshold) {
+      // Scale: 0.5-1.0 -> 25-35
+      return _config.ngramMatch + (ngramScore * 10);
+    }
+
+    // Baseline: Music Assistant API returned it, so some relevance
+    return _config.baseline;
+  }
+
+  /// Check if query matches at word boundary in text.
+  bool _matchesWordBoundary(String text, String query) {
+    if (query.contains(' ')) {
+      // Multi-word query: check if at start or after space
+      if (text.startsWith(query)) return true;
+      if (text.contains(' $query')) return true;
+      return false;
+    }
+
+    // Single-word query: check if any word starts with query
+    final words = text.split(RegExp(r'\s+'));
+    for (final word in words) {
+      if (word.startsWith(query)) return true;
+    }
+    return false;
+  }
+
+  /// Check if text is contained within query (reverse matching).
+  ///
+  /// Solves: "the ramones" query finding "Ramones" artist
+  bool _reverseContains(String query, String text) {
+    if (text.length < _config.minReverseMatchLength) return false;
+
+    // Direct containment
+    if (query.contains(text)) return true;
+
+    // Token-level: any query token equals text
+    final queryTokens = query.split(RegExp(r'\s+'));
+    for (final token in queryTokens) {
+      if (token.length >= _config.minReverseMatchLength && text == token) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /// Calculate secondary field bonuses based on media type.
+  double _calculateSecondaryScore(MediaItem item, NormalizedQuery nq) {
+    double bonus = 0;
+
+    if (item is Album) {
+      bonus += _scoreArtistField(item.artistsString, nq);
+    } else if (item is Track) {
+      bonus += _scoreArtistField(item.artistsString, nq);
+      // Also check album name
+      if (item.album?.name != null) {
+        final albumLower = item.album!.name.toLowerCase();
+        if (albumLower.contains(nq.withoutStopwords)) {
+          bonus += _config.albumFieldBonus;
+        }
+      }
+    } else if (item is Audiobook) {
+      // Check authors
+      final authorLower = item.authorsString.toLowerCase();
+      if (authorLower == nq.withoutStopwords) {
+        bonus += _config.authorFieldExactBonus;
+      } else if (authorLower.contains(nq.withoutStopwords)) {
+        bonus += _config.authorFieldPartialBonus;
+      }
+      // Check narrators
+      final narratorLower = item.narratorsString.toLowerCase();
+      if (narratorLower.contains(nq.withoutStopwords)) {
+        bonus += _config.narratorFieldBonus;
+      }
+    } else if (item.mediaType == MediaType.podcast || item.mediaType == MediaType.podcastEpisode) {
+      bonus += _scorePodcastFields(item, nq);
+    }
+
+    return bonus;
+  }
+
+  /// Score artist field for albums and tracks.
+  double _scoreArtistField(String artistsString, NormalizedQuery nq) {
+    final artistLower = artistsString.toLowerCase();
+    if (artistLower == nq.withoutStopwords) {
+      return _config.artistFieldExactBonus;
+    }
+    if (artistLower.contains(nq.withoutStopwords)) {
+      return _config.artistFieldPartialBonus;
+    }
+    return 0;
+  }
+
+  /// Score podcast-specific fields (creator, description).
+  double _scorePodcastFields(MediaItem item, NormalizedQuery nq) {
+    double bonus = 0;
+    final metadata = item.metadata;
+
+    if (metadata != null) {
+      // Check creator fields
+      final creatorFields = [
+        metadata['author'] as String?,
+        metadata['publisher'] as String?,
+        metadata['owner'] as String?,
+        metadata['creator'] as String?,
+      ].where((s) => s != null && s.isNotEmpty).map((s) => s!.toLowerCase());
+
+      bool foundExact = false;
+      bool foundContains = false;
+      for (final field in creatorFields) {
+        if (field == nq.withoutStopwords) {
+          foundExact = true;
+          break;
+        } else if (field.contains(nq.withoutStopwords)) {
+          foundContains = true;
+        }
+      }
+
+      if (foundExact) {
+        bonus += _config.creatorFieldExactBonus;
+      } else if (foundContains) {
+        bonus += _config.creatorFieldPartialBonus;
+      }
+
+      // Check description
+      final description =
+          (metadata['description'] as String? ?? '').toLowerCase();
+      if (description.contains(nq.withoutStopwords)) {
+        bonus += _config.descriptionBonus;
+      }
+    }
+
+    // Fallback: podcast name prominence check
+    if (bonus == 0) {
+      final nameLower = item.name.toLowerCase();
+      if (nameLower.contains(nq.withoutStopwords)) {
+        if (nq.withoutStopwords.contains(' ')) {
+          // Multi-word query prominence
+          final prominence = nq.withoutStopwords.length / nameLower.length;
+          if (prominence >= 0.5) {
+            bonus += _config.creatorFieldExactBonus;
+          } else if (prominence >= 0.3) {
+            bonus += _config.creatorFieldPartialBonus + 4;
+          } else {
+            bonus += _config.creatorFieldPartialBonus;
+          }
+        } else {
+          bonus += _config.descriptionBonus;
+        }
+      }
+    }
+
+    return bonus;
+  }
+
+  /// Calculate library and favorite bonuses.
+  double _calculateBonuses(MediaItem item) {
+    double bonus = 0;
+
+    // Library bonus (Album has inLibrary property)
+    if (item is Album && item.inLibrary) {
+      bonus += _config.libraryBonus;
+    }
+
+    // Favorite bonus
+    if (item.favorite == true) {
+      bonus += _config.favoriteBonus;
+    }
+
+    return bonus;
+  }
+}

lib/utils/search/text_normalizer.dart

@@ -0,0 +1,114 @@
+/// Text normalization utilities for search scoring.
+///
+/// Handles query normalization, stopword removal, and tokenization.
+
+/// Represents a normalized search query with various forms for matching.
+class NormalizedQuery {
+  /// Original query as entered by user
+  final String original;
+
+  /// Lowercased and trimmed query
+  final String normalized;
+
+  /// Query with stopwords removed
+  final String withoutStopwords;
+
+  /// Individual tokens from normalized query
+  final List<String> tokens;
+
+  /// Tokens with stopwords removed
+  final List<String> tokensNoStop;
+
+  const NormalizedQuery({
+    required this.original,
+    required this.normalized,
+    required this.withoutStopwords,
+    required this.tokens,
+    required this.tokensNoStop,
+  });
+
+  /// Whether the query is empty after normalization
+  bool get isEmpty => normalized.isEmpty;
+
+  /// Whether stopword removal changed the query
+  bool get hasStopwordsRemoved => normalized != withoutStopwords;
+}
+
+/// Normalizes text and queries for search matching.
+class TextNormalizer {
+  /// Common English stopwords relevant to music/media searches.
+  ///
+  /// Intentionally minimal to avoid over-filtering:
+  /// - Articles that commonly prefix artist/album names
+  /// - Common prepositions that add noise
+  static const Set<String> _stopwords = {
+    // Articles
+    'the',
+    'a',
+    'an',
+    // Common prepositions in music/media context
+    'of',
+    'and',
+    'in',
+    'on',
+    'at',
+    'to',
+    'for',
+    'with',
+    'by',
+    // Common noise words
+    'is',
+    'are',
+    'was',
+    'be',
+  };
+
+  /// Normalize a search query into multiple forms for matching.
+  ///
+  /// Returns a [NormalizedQuery] containing:
+  /// - Original query
+  /// - Lowercased/trimmed version
+  /// - Version with stopwords removed
+  /// - Tokenized versions
+  NormalizedQuery normalizeQuery(String query) {
+    final normalized = query.toLowerCase().trim();
+    final tokens = tokenize(normalized);
+    final tokensNoStop = tokens.where((t) => !_stopwords.contains(t)).toList();
+
+    // If all tokens were stopwords, preserve original tokens
+    // e.g., "The The" (band name) shouldn't become empty
+    final effectiveTokensNoStop =
+        tokensNoStop.isEmpty ? tokens : tokensNoStop;
+    final withoutStopwords = effectiveTokensNoStop.join(' ');
+
+    return NormalizedQuery(
+      original: query,
+      normalized: normalized,
+      withoutStopwords: withoutStopwords,
+      tokens: tokens,
+      tokensNoStop: effectiveTokensNoStop,
+    );
+  }
+
+  /// Normalize text for comparison (lowercase, trim).
+  String normalizeText(String text) {
+    return text.toLowerCase().trim();
+  }
+
+  /// Normalize text with stopwords removed.
+  String normalizeTextNoStopwords(String text) {
+    final tokens = tokenize(text.toLowerCase().trim());
+    final filtered = tokens.where((t) => !_stopwords.contains(t)).toList();
+    return filtered.isEmpty ? text.toLowerCase().trim() : filtered.join(' ');
+  }
+
+  /// Split text into tokens on whitespace.
+  List<String> tokenize(String text) {
+    return text.split(RegExp(r'\s+')).where((t) => t.isNotEmpty).toList();
+  }
+
+  /// Check if a word is a stopword.
+  bool isStopword(String word) {
+    return _stopwords.contains(word.toLowerCase());
+  }
+}

lib/widgets/album_card.dart

@@ -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';
@@ -13,12 +14,16 @@ class AlbumCard extends StatefulWidget {
   final Album album;
   final VoidCallback? onTap;
   final String? heroTagSuffix;
+  /// Image decode size in pixels. Defaults to 256.
+  /// Use smaller values (e.g., 128) for list views, larger for grids.
+  final int? imageCacheSize;
 
   const AlbumCard({
     super.key,
     required this.album,
     this.onTap,
     this.heroTagSuffix,
+    this.imageCacheSize,
   });
 
   @override
@@ -30,6 +35,10 @@ class _AlbumCardState extends State<AlbumCard> {
   bool _triedFallback = false;
   bool _maImageFailed = false;
   String? _cachedMaImageUrl;
+  Timer? _fallbackTimer;
+
+  /// Delay before fetching fallback images to avoid requests during fast scroll
+  static const _fallbackDelay = Duration(milliseconds: 200);
 
   @override
   void initState() {
@@ -37,6 +46,12 @@ class _AlbumCardState extends State<AlbumCard> {
     _initFallbackImage();
   }
 
+  @override
+  void dispose() {
+    _fallbackTimer?.cancel();
+    super.dispose();
+  }
+
   void _initFallbackImage() {
     // Check if MA has an image after first build, then fetch fallback if needed
     WidgetsBinding.instance.addPostFrameCallback((_) {
@@ -47,6 +62,16 @@ class _AlbumCardState extends State<AlbumCard> {
 
       if (maImageUrl == null && !_triedFallback) {
         _triedFallback = true;
+        _scheduleFallbackFetch();
+      }
+    });
+  }
+
+  /// Schedule fallback fetch with delay to avoid requests during fast scroll
+  void _scheduleFallbackFetch() {
+    _fallbackTimer?.cancel();
+    _fallbackTimer = Timer(_fallbackDelay, () {
+      if (mounted) {
         _fetchFallbackImage();
       }
     });
@@ -69,7 +94,7 @@ class _AlbumCardState extends State<AlbumCard> {
     if (!_triedFallback && !_maImageFailed) {
       _maImageFailed = true;
       _triedFallback = true;
-      _fetchFallbackImage();
+      _scheduleFallbackFetch();
     }
   }
 
@@ -86,6 +111,9 @@ class _AlbumCardState extends State<AlbumCard> {
     // Use fallback if MA image failed or wasn't available
     final imageUrl = (_maImageFailed || maImageUrl == null) ? _fallbackImageUrl : maImageUrl;
 
+    // PERF: Use appropriate cache size based on display size
+    final cacheSize = widget.imageCacheSize ?? 256;
+
     return RepaintBoundary(
       child: GestureDetector(
         onTap: widget.onTap ?? () {
@@ -97,6 +125,7 @@ class _AlbumCardState extends State<AlbumCard> {
               child: AlbumDetailsScreen(
                 album: widget.album,
                 heroTagSuffix: widget.heroTagSuffix,
+                initialImageUrl: imageUrl,
               ),
             ),
           );
@@ -117,9 +146,10 @@ class _AlbumCardState extends State<AlbumCard> {
                         ? CachedNetworkImage(
                             imageUrl: imageUrl,
                             fit: BoxFit.cover,
-                            memCacheWidth: 256,
-                            memCacheHeight: 256,
-                            fadeInDuration: const Duration(milliseconds: 150),
+                            memCacheWidth: cacheSize,
+                            memCacheHeight: cacheSize,
+                            fadeInDuration: Duration.zero,
+                            fadeOutDuration: Duration.zero,
                             placeholder: (context, url) => const SizedBox(),
                             errorWidget: (context, url, error) {
                               // Try fallback on error (only for MA URLs, not fallback URLs)
@@ -147,13 +177,13 @@ class _AlbumCardState extends State<AlbumCard> {
               ),
             ),
           const SizedBox(height: 8),
-          // Album title
+          // Album title with year
           Hero(
             tag: HeroTags.albumTitle + (widget.album.uri ?? widget.album.itemId) + suffix,
             child: Material(
               color: Colors.transparent,
               child: Text(
-                widget.album.name,
+                widget.album.nameWithYear,
                 maxLines: 1,
                 overflow: TextOverflow.ellipsis,
                 style: textTheme.titleSmall?.copyWith(

lib/widgets/album_row.dart

@@ -1,5 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
+import 'package:cached_network_image/cached_network_image.dart';
 import '../models/media_item.dart';
 import '../providers/music_assistant_provider.dart';
 import '../services/debug_logger.dart';
@@ -10,6 +11,8 @@ class AlbumRow extends StatefulWidget {
   final Future<List<Album>> Function() loadAlbums;
   final String? heroTagSuffix;
   final double? rowHeight;
+  /// Optional: synchronous getter for cached data (for instant display)
+  final List<Album>? Function()? getCachedAlbums;
 
   const AlbumRow({
     super.key,
@@ -17,6 +20,7 @@ class AlbumRow extends StatefulWidget {
     required this.loadAlbums,
     this.heroTagSuffix,
     this.rowHeight,
+    this.getCachedAlbums,
   });
 
   @override
@@ -24,8 +28,8 @@ class AlbumRow extends StatefulWidget {
 }
 
 class _AlbumRowState extends State<AlbumRow> with AutomaticKeepAliveClientMixin {
-  late Future<List<Album>> _albumsFuture;
-  List<Album>? _cachedAlbums; // Keep last loaded data to prevent flash
+  List<Album> _albums = [];
+  bool _isLoading = true;
   bool _hasLoaded = false;
 
   @override
@@ -34,21 +38,116 @@ class _AlbumRowState extends State<AlbumRow> with AutomaticKeepAliveClientMixin
   @override
   void initState() {
     super.initState();
-    _loadAlbumsOnce();
+    // Get cached data synchronously BEFORE first build (no spinner flash)
+    final cached = widget.getCachedAlbums?.call();
+    if (cached != null && cached.isNotEmpty) {
+      _albums = cached;
+      _isLoading = false;
+    }
+    _loadAlbums();
   }
 
-  void _loadAlbumsOnce() {
-    if (!_hasLoaded) {
-      _albumsFuture = widget.loadAlbums().then((albums) {
-        _cachedAlbums = albums;
-        return albums;
-      });
-      _hasLoaded = true;
+  Future<void> _loadAlbums() async {
+    if (_hasLoaded) return;
+    _hasLoaded = true;
+
+    // Load fresh data (always update - fresh data may have images that cached data lacks)
+    try {
+      final freshAlbums = await widget.loadAlbums();
+      if (mounted && freshAlbums.isNotEmpty) {
+        setState(() {
+          _albums = freshAlbums;
+          _isLoading = false;
+        });
+        // Pre-cache images for smooth hero animations
+        _precacheAlbumImages(freshAlbums);
+      }
+    } catch (e) {
+      // Silent failure - keep showing cached data
+    }
+
+    if (mounted && _isLoading) {
+      setState(() => _isLoading = false);
+    }
+  }
+
+  /// Pre-cache album images so hero animations are smooth on first tap
+  void _precacheAlbumImages(List<Album> albums) {
+    if (!mounted) return;
+    final maProvider = context.read<MusicAssistantProvider>();
+
+    // Only precache first ~10 visible items to avoid excessive network/memory use
+    final albumsToCache = albums.take(10);
+
+    for (final album in albumsToCache) {
+      final imageUrl = maProvider.api?.getImageUrl(album, size: 256);
+      if (imageUrl != null) {
+        // Use CachedNetworkImageProvider to warm the cache
+        precacheImage(
+          CachedNetworkImageProvider(imageUrl),
+          context,
+        ).catchError((_) {
+          // Silently ignore precache errors
+          return false;
+        });
+      }
     }
   }
 
   static final _logger = DebugLogger();
 
+  Widget _buildContent(double contentHeight, ColorScheme colorScheme) {
+    // Only show loading if we have no data at all
+    if (_albums.isEmpty && _isLoading) {
+      return const Center(child: CircularProgressIndicator());
+    }
+
+    if (_albums.isEmpty) {
+      return Center(
+        child: Text(
+          'No albums found',
+          style: TextStyle(color: colorScheme.onSurface.withOpacity(0.5)),
+        ),
+      );
+    }
+
+    // Card layout: square artwork + text below
+    // Text area: 8px gap + ~18px title + ~18px artist = ~44px
+    const textAreaHeight = 44.0;
+    final artworkSize = contentHeight - textAreaHeight;
+    final cardWidth = artworkSize; // Card width = artwork width (square)
+    final itemExtent = cardWidth + 12; // width + horizontal margins
+
+    return ScrollConfiguration(
+      behavior: const _StretchScrollBehavior(),
+      child: ListView.builder(
+        clipBehavior: Clip.none,
+        scrollDirection: Axis.horizontal,
+        padding: const EdgeInsets.symmetric(horizontal: 12.0),
+        itemCount: _albums.length,
+        itemExtent: itemExtent,
+        cacheExtent: 500, // Preload ~3 items ahead for smoother scrolling
+        addAutomaticKeepAlives: false, // Row already uses AutomaticKeepAliveClientMixin
+        addRepaintBoundaries: false, // Cards already have RepaintBoundary
+        itemBuilder: (context, index) {
+          final album = _albums[index];
+          return Padding(
+            padding: const EdgeInsets.only(bottom: 4.0),
+            child: Container(
+              key: ValueKey(album.uri ?? album.itemId),
+              width: cardWidth,
+              margin: const EdgeInsets.symmetric(horizontal: 6.0),
+              child: AlbumCard(
+                album: album,
+                heroTagSuffix: widget.heroTagSuffix,
+              ),
+            ),
+          );
+        },
+      ),
+    );
+  }
+
   @override
   Widget build(BuildContext context) {
     _logger.startBuild('AlbumRow:${widget.title}');
@@ -78,65 +177,7 @@ class _AlbumRowState extends State<AlbumRow> with AutomaticKeepAliveClientMixin
             ),
           ),
           Expanded(
-            child: FutureBuilder<List<Album>>(
-              future: _albumsFuture,
-              builder: (context, snapshot) {
-                // Use cached data immediately if available (prevents flash on rebuild)
-                final albums = snapshot.data ?? _cachedAlbums;
-
-                // Only show loading if we have no data at all
-                if (albums == null && snapshot.connectionState == ConnectionState.waiting) {
-                  return const Center(child: CircularProgressIndicator());
-                }
-
-                if (snapshot.hasError && albums == null) {
-                  return Center(
-                    child: Text('Error: ${snapshot.error}'),
-                  );
-                }
-
-                if (albums == null || albums.isEmpty) {
-                  return Center(
-                    child: Text(
-                      'No albums found',
-                      style: TextStyle(color: colorScheme.onSurface.withOpacity(0.5)),
-                    ),
-                  );
-                }
-
-                // Card layout: square artwork + text below
-                // Text area: 8px gap + ~18px title + ~18px artist = ~44px
-                const textAreaHeight = 44.0;
-                final artworkSize = contentHeight - textAreaHeight;
-                final cardWidth = artworkSize; // Card width = artwork width (square)
-                final itemExtent = cardWidth + 12; // width + horizontal margins
-
-                return ScrollConfiguration(
-                  behavior: const _StretchScrollBehavior(),
-                  child: ListView.builder(
-                    scrollDirection: Axis.horizontal,
-                    padding: const EdgeInsets.symmetric(horizontal: 12.0),
-                    itemCount: albums.length,
-                    itemExtent: itemExtent,
-                    cacheExtent: 500, // Preload ~3 items ahead for smoother scrolling
-                    addAutomaticKeepAlives: false, // Row already uses AutomaticKeepAliveClientMixin
-                    addRepaintBoundaries: false, // Cards already have RepaintBoundary
-                    itemBuilder: (context, index) {
-                      final album = albums[index];
-                      return Container(
-                        key: ValueKey(album.uri ?? album.itemId),
-                        width: cardWidth,
-                        margin: const EdgeInsets.symmetric(horizontal: 6.0),
-                        child: AlbumCard(
-                          album: album,
-                          heroTagSuffix: widget.heroTagSuffix,
-                        ),
-                      );
-                    },
-                  ),
-                );
-              },
-            ),
+            child: _buildContent(contentHeight, colorScheme),
           ),
           ],
         ),

lib/widgets/artist_avatar.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:cached_network_image/cached_network_image.dart';
 import 'package:provider/provider.dart';
@@ -32,6 +33,10 @@ class _ArtistAvatarState extends State<ArtistAvatar> {
   String? _fallbackImageUrl;
   bool _triedFallback = false;
   bool _maImageFailed = false;
+  Timer? _fallbackTimer;
+
+  /// Delay before fetching fallback images to avoid requests during fast scroll
+  static const _fallbackDelay = Duration(milliseconds: 200);
 
   @override
   void initState() {
@@ -39,6 +44,12 @@ class _ArtistAvatarState extends State<ArtistAvatar> {
     _loadImage();
   }
 
+  @override
+  void dispose() {
+    _fallbackTimer?.cancel();
+    super.dispose();
+  }
+
   Future<void> _loadImage() async {
     final provider = context.read<MusicAssistantProvider>();
 
@@ -56,14 +67,23 @@ class _ArtistAvatarState extends State<ArtistAvatar> {
       return;
     }
 
-    // Fallback to external sources (MA returned null)
-    _fetchFallbackImage();
+    // Fallback to external sources (MA returned null) - with delay
+    _scheduleFallbackFetch();
+  }
+
+  /// Schedule fallback fetch with delay to avoid requests during fast scroll
+  void _scheduleFallbackFetch() {
+    if (_triedFallback) return;
+    _triedFallback = true;
+    _fallbackTimer?.cancel();
+    _fallbackTimer = Timer(_fallbackDelay, () {
+      if (mounted) {
+        _fetchFallbackImage();
+      }
+    });
   }
 
   Future<void> _fetchFallbackImage() async {
-    if (_triedFallback) return;
-    _triedFallback = true;
-
     final fallbackUrl = await MetadataService.getArtistImageUrl(widget.artist.name);
     _fallbackImageUrl = fallbackUrl;
 
@@ -79,7 +99,7 @@ class _ArtistAvatarState extends State<ArtistAvatar> {
     // When MA image fails to load, try Deezer fallback
     if (!_maImageFailed) {
       _maImageFailed = true;
-      _fetchFallbackImage();
+      _scheduleFallbackFetch();
     }
   }
 
@@ -100,6 +120,11 @@ class _ArtistAvatarState extends State<ArtistAvatar> {
           width: widget.radius * 2,
           height: widget.radius * 2,
           fit: BoxFit.cover,
+          // PERF: Use imageSize for memory cache to reduce decode overhead
+          memCacheWidth: widget.imageSize,
+          memCacheHeight: widget.imageSize,
+          fadeInDuration: Duration.zero,
+          fadeOutDuration: Duration.zero,
           placeholder: (context, url) => Container(
             color: colorScheme.surfaceVariant,
             child: Icon(Icons.person_rounded, color: colorScheme.onSurfaceVariant),

lib/widgets/artist_card.dart

@@ -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';
@@ -14,14 +15,16 @@ class ArtistCard extends StatefulWidget {
   final Artist artist;
   final VoidCallback? onTap;
   final String? heroTagSuffix;
-  final double? imageSize;
+  /// Image decode size in pixels. Defaults to 256.
+  /// Use smaller values (e.g., 128) for list views, larger for grids.
+  final int? imageCacheSize;
 
   const ArtistCard({
     super.key,
     required this.artist,
     this.onTap,
     this.heroTagSuffix,
-    this.imageSize,
+    this.imageCacheSize,
   });
 
   @override
@@ -34,6 +37,10 @@ class _ArtistCardState extends State<ArtistCard> {
   bool _triedFallback = false;
   bool _maImageFailed = false;
   String? _cachedMaImageUrl;
+  Timer? _fallbackTimer;
+
+  /// Delay before fetching fallback images to avoid requests during fast scroll
+  static const _fallbackDelay = Duration(milliseconds: 200);
 
   @override
   void initState() {
@@ -42,6 +49,12 @@ class _ArtistCardState extends State<ArtistCard> {
     _initFallbackImage();
   }
 
+  @override
+  void dispose() {
+    _fallbackTimer?.cancel();
+    super.dispose();
+  }
+
   void _initFallbackImage() {
     // We'll check if MA has an image after first build, then fetch fallback if needed
     WidgetsBinding.instance.addPostFrameCallback((_) {
@@ -52,7 +65,17 @@ class _ArtistCardState extends State<ArtistCard> {
 
       if (maImageUrl == null && !_triedFallback) {
         _triedFallback = true;
-        _logger.debug('No MA image for "${widget.artist.name}", trying fallback', context: 'ArtistCard');
+        _logger.debug('No MA image for "${widget.artist.name}", scheduling fallback', context: 'ArtistCard');
+        _scheduleFallbackFetch();
+      }
+    });
+  }
+
+  /// Schedule fallback fetch with delay to avoid requests during fast scroll
+  void _scheduleFallbackFetch() {
+    _fallbackTimer?.cancel();
+    _fallbackTimer = Timer(_fallbackDelay, () {
+      if (mounted) {
         _fetchFallbackImage();
       }
     });
@@ -63,8 +86,8 @@ class _ArtistCardState extends State<ArtistCard> {
     if (!_triedFallback && !_maImageFailed) {
       _maImageFailed = true;
       _triedFallback = true;
-      _logger.debug('MA image failed for "${widget.artist.name}", trying fallback', context: 'ArtistCard');
-      _fetchFallbackImage();
+      _logger.debug('MA image failed for "${widget.artist.name}", scheduling fallback', context: 'ArtistCard');
+      _scheduleFallbackFetch();
     }
   }
 
@@ -81,6 +104,9 @@ class _ArtistCardState extends State<ArtistCard> {
     // Use fallback if MA image failed or wasn't available
     final imageUrl = (_maImageFailed || maImageUrl == null) ? _fallbackImageUrl : maImageUrl;
 
+    // PERF: Use appropriate cache size based on display size
+    final cacheSize = widget.imageCacheSize ?? 256;
+
     return RepaintBoundary(
       child: GestureDetector(
         onTap: widget.onTap ?? () {
@@ -100,49 +126,50 @@ class _ArtistCardState extends State<ArtistCard> {
         child: Column(
           crossAxisAlignment: CrossAxisAlignment.center,
           children: [
-            // Artist image - circular, constrained to be a proper circle
-            Expanded(
-              child: Center(
-                child: LayoutBuilder(
-                  builder: (context, constraints) {
-                    // Use the smaller dimension to ensure a circle
-                    final size = constraints.maxWidth < constraints.maxHeight
-                        ? constraints.maxWidth
-                        : constraints.maxHeight;
-                    return Hero(
-                      tag: HeroTags.artistImage + (widget.artist.uri ?? widget.artist.itemId) + suffix,
-                      child: ClipOval(
-                        child: Container(
-                          width: size,
-                          height: size,
-                          color: colorScheme.surfaceVariant,
-                          child: imageUrl != null
-                              ? CachedNetworkImage(
-                                  imageUrl: imageUrl,
-                                  fit: BoxFit.cover,
-                                  memCacheWidth: 256,
-                                  memCacheHeight: 256,
-                                  fadeInDuration: const Duration(milliseconds: 150),
-                                  placeholder: (context, url) => const SizedBox(),
-                                  errorWidget: (context, url, error) {
-                                    // Try fallback on error (only for MA URLs, not fallback URLs)
-                                    if (!_maImageFailed && url == maImageUrl) {
-                                      WidgetsBinding.instance.addPostFrameCallback((_) {
-                                        _onImageError();
-                                      });
-                                    }
-                                    return Icon(
-                                      Icons.person_rounded,
-                                      size: size * 0.55,
-                                      color: colorScheme.onSurfaceVariant,
-                                    );
-                                  },
-                                )
-                              : Icon(Icons.person_rounded, size: size * 0.55, color: colorScheme.onSurfaceVariant),
-                        ),
-                      ),
-                    );
-                  },
+            // Artist image - circular
+            // PERF: Use AspectRatio instead of LayoutBuilder to provide fixed geometry
+            // before Hero animation starts. This prevents grey icon flash caused by
+            // dynamic sizing inside the Hero widget.
+            AspectRatio(
+              aspectRatio: 1.0,
+              child: Hero(
+                tag: HeroTags.artistImage + (widget.artist.uri ?? widget.artist.itemId) + suffix,
+                child: ClipOval(
+                  child: Container(
+                    color: colorScheme.surfaceVariant,
+                    child: imageUrl != null
+                        ? CachedNetworkImage(
+                            imageUrl: imageUrl,
+                            fit: BoxFit.cover,
+                            memCacheWidth: cacheSize,
+                            memCacheHeight: cacheSize,
+                            fadeInDuration: Duration.zero,
+                            fadeOutDuration: Duration.zero,
+                            placeholder: (context, url) => const SizedBox(),
+                            errorWidget: (context, url, error) {
+                              // Try fallback on error (only for MA URLs, not fallback URLs)
+                              if (!_maImageFailed && url == maImageUrl) {
+                                WidgetsBinding.instance.addPostFrameCallback((_) {
+                                  _onImageError();
+                                });
+                              }
+                              return Center(
+                                child: Icon(
+                                  Icons.person_rounded,
+                                  size: 64,
+                                  color: colorScheme.onSurfaceVariant,
+                                ),
+                              );
+                            },
+                          )
+                        : Center(
+                            child: Icon(
+                              Icons.person_rounded,
+                              size: 64,
+                              color: colorScheme.onSurfaceVariant,
+                            ),
+                          ),
+                  ),
                 ),
               ),
             ),
@@ -162,6 +189,7 @@ class _ArtistCardState extends State<ArtistCard> {
                   style: textTheme.titleSmall?.copyWith(
                     color: colorScheme.onSurface,
                     fontWeight: FontWeight.w500,
+                    height: 1.15,
                   ),
                 ),
               ),

lib/widgets/artist_row.dart

@@ -1,5 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
+import 'package:cached_network_image/cached_network_image.dart';
 import '../models/media_item.dart';
 import '../providers/music_assistant_provider.dart';
 import '../services/debug_logger.dart';
@@ -10,6 +11,8 @@ class ArtistRow extends StatefulWidget {
   final Future<List<Artist>> Function() loadArtists;
   final String? heroTagSuffix;
   final double? rowHeight;
+  /// Optional: synchronous getter for cached data (for instant display)
+  final List<Artist>? Function()? getCachedArtists;
 
   const ArtistRow({
     super.key,
@@ -17,6 +20,7 @@ class ArtistRow extends StatefulWidget {
     required this.loadArtists,
     this.heroTagSuffix,
     this.rowHeight,
+    this.getCachedArtists,
   });
 
   @override
@@ -24,8 +28,8 @@ class ArtistRow extends StatefulWidget {
 }
 
 class _ArtistRowState extends State<ArtistRow> with AutomaticKeepAliveClientMixin {
-  late Future<List<Artist>> _artistsFuture;
-  List<Artist>? _cachedArtists; // Keep last loaded data to prevent flash
+  List<Artist> _artists = [];
+  bool _isLoading = true;
   bool _hasLoaded = false;
 
   @override
@@ -34,21 +38,112 @@ class _ArtistRowState extends State<ArtistRow> with AutomaticKeepAliveClientMixi
   @override
   void initState() {
     super.initState();
-    _loadArtistsOnce();
+    // Get cached data synchronously BEFORE first build (no spinner flash)
+    final cached = widget.getCachedArtists?.call();
+    if (cached != null && cached.isNotEmpty) {
+      _artists = cached;
+      _isLoading = false;
+    }
+    _loadArtists();
   }
 
-  void _loadArtistsOnce() {
-    if (!_hasLoaded) {
-      _artistsFuture = widget.loadArtists().then((artists) {
-        _cachedArtists = artists;
-        return artists;
-      });
-      _hasLoaded = true;
+  Future<void> _loadArtists() async {
+    if (_hasLoaded) return;
+    _hasLoaded = true;
+
+    // Load fresh data (always update - fresh data may have images that cached data lacks)
+    try {
+      final freshArtists = await widget.loadArtists();
+      if (mounted && freshArtists.isNotEmpty) {
+        setState(() {
+          _artists = freshArtists;
+          _isLoading = false;
+        });
+        // Pre-cache images for smooth hero animations
+        _precacheArtistImages(freshArtists);
+      }
+    } catch (e) {
+      // Silent failure - keep showing cached data
+    }
+
+    if (mounted && _isLoading) {
+      setState(() => _isLoading = false);
+    }
+  }
+
+  /// Pre-cache artist images so hero animations are smooth on first tap
+  void _precacheArtistImages(List<Artist> artists) {
+    if (!mounted) return;
+    final maProvider = context.read<MusicAssistantProvider>();
+
+    // Only precache first ~10 visible items to avoid excessive network/memory use
+    final artistsToCache = artists.take(10);
+
+    for (final artist in artistsToCache) {
+      final imageUrl = maProvider.api?.getImageUrl(artist, size: 256);
+      if (imageUrl != null) {
+        // Use CachedNetworkImageProvider to warm the cache
+        precacheImage(
+          CachedNetworkImageProvider(imageUrl),
+          context,
+        ).catchError((_) {
+          // Silently ignore precache errors
+          return false;
+        });
+      }
     }
   }
 
   static final _logger = DebugLogger();
 
+  Widget _buildContent(double contentHeight, ColorScheme colorScheme) {
+    // Only show loading if we have no data at all
+    if (_artists.isEmpty && _isLoading) {
+      return const Center(child: CircularProgressIndicator());
+    }
+
+    if (_artists.isEmpty) {
+      return Center(
+        child: Text(
+          'No artists found',
+          style: TextStyle(color: colorScheme.onSurface.withOpacity(0.5)),
+        ),
+      );
+    }
+
+    // Card layout: circle image + name below
+    // Text area: 8px gap + ~36px for 2-line name = ~44px
+    const textAreaHeight = 44.0;
+    final imageSize = contentHeight - textAreaHeight;
+    final cardWidth = imageSize; // Card width = image width (circle)
+    final itemExtent = cardWidth + 16; // width + horizontal margins
+
+    return ScrollConfiguration(
+      behavior: const _StretchScrollBehavior(),
+      child: ListView.builder(
+        scrollDirection: Axis.horizontal,
+        padding: const EdgeInsets.symmetric(horizontal: 12.0),
+        itemCount: _artists.length,
+        itemExtent: itemExtent,
+        cacheExtent: 500, // Preload ~3 items ahead for smoother scrolling
+        addAutomaticKeepAlives: false, // Row already uses AutomaticKeepAliveClientMixin
+        addRepaintBoundaries: false, // Cards already have RepaintBoundary
+        itemBuilder: (context, index) {
+          final artist = _artists[index];
+          return Container(
+            key: ValueKey(artist.uri ?? artist.itemId),
+            width: cardWidth,
+            margin: const EdgeInsets.symmetric(horizontal: 8.0),
+            child: ArtistCard(
+              artist: artist,
+              heroTagSuffix: widget.heroTagSuffix,
+            ),
+          );
+        },
+      ),
+    );
+  }
+
   @override
   Widget build(BuildContext context) {
     _logger.startBuild('ArtistRow:${widget.title}');
@@ -78,65 +173,7 @@ class _ArtistRowState extends State<ArtistRow> with AutomaticKeepAliveClientMixi
             ),
           ),
           Expanded(
-            child: FutureBuilder<List<Artist>>(
-              future: _artistsFuture,
-              builder: (context, snapshot) {
-                // Use cached data immediately if available (prevents flash on rebuild)
-                final artists = snapshot.data ?? _cachedArtists;
-
-                // Only show loading if we have no data at all
-                if (artists == null && snapshot.connectionState == ConnectionState.waiting) {
-                  return const Center(child: CircularProgressIndicator());
-                }
-
-                if (snapshot.hasError && artists == null) {
-                  return Center(
-                    child: Text('Error: ${snapshot.error}'),
-                  );
-                }
-
-                if (artists == null || artists.isEmpty) {
-                  return Center(
-                    child: Text(
-                      'No artists found',
-                      style: TextStyle(color: colorScheme.onSurface.withOpacity(0.5)),
-                    ),
-                  );
-                }
-
-                // Card layout: circle image + name below
-                // Text area: 8px gap + ~36px for 2-line name = ~44px
-                const textAreaHeight = 44.0;
-                final imageSize = contentHeight - textAreaHeight;
-                final cardWidth = imageSize; // Card width = image width (circle)
-                final itemExtent = cardWidth + 16; // width + horizontal margins
-
-                return ScrollConfiguration(
-                  behavior: const _StretchScrollBehavior(),
-                  child: ListView.builder(
-                    scrollDirection: Axis.horizontal,
-                    padding: const EdgeInsets.symmetric(horizontal: 12.0),
-                    itemCount: artists.length,
-                    itemExtent: itemExtent,
-                    cacheExtent: 500, // Preload ~3 items ahead for smoother scrolling
-                    addAutomaticKeepAlives: false, // Row already uses AutomaticKeepAliveClientMixin
-                    addRepaintBoundaries: false, // Cards already have RepaintBoundary
-                    itemBuilder: (context, index) {
-                      final artist = artists[index];
-                      return Container(
-                        key: ValueKey(artist.uri ?? artist.itemId),
-                        width: cardWidth,
-                        margin: const EdgeInsets.symmetric(horizontal: 8.0),
-                        child: ArtistCard(
-                          artist: artist,
-                          heroTagSuffix: widget.heroTagSuffix,
-                        ),
-                      );
-                    },
-                  ),
-                );
-              },
-            ),
+            child: _buildContent(contentHeight, colorScheme),
           ),
           ],
         ),

lib/widgets/audiobook_row.dart

@@ -0,0 +1,331 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:material_design_icons_flutter/material_design_icons_flutter.dart';
+import '../models/media_item.dart';
+import '../providers/music_assistant_provider.dart';
+import '../services/debug_logger.dart';
+import '../utils/page_transitions.dart';
+import '../screens/audiobook_detail_screen.dart';
+import '../constants/hero_tags.dart';
+
+class AudiobookRow extends StatefulWidget {
+  final String title;
+  final Future<List<Audiobook>> Function() loadAudiobooks;
+  final String? heroTagSuffix;
+  final double? rowHeight;
+  /// Optional: synchronous getter for cached data (for instant display)
+  final List<Audiobook>? Function()? getCachedAudiobooks;
+
+  const AudiobookRow({
+    super.key,
+    required this.title,
+    required this.loadAudiobooks,
+    this.heroTagSuffix,
+    this.rowHeight,
+    this.getCachedAudiobooks,
+  });
+
+  @override
+  State<AudiobookRow> createState() => _AudiobookRowState();
+}
+
+class _AudiobookRowState extends State<AudiobookRow> with AutomaticKeepAliveClientMixin {
+  List<Audiobook> _audiobooks = [];
+  bool _isLoading = true;
+  bool _hasLoaded = false;
+  bool _hasPrecachedAudiobooks = false;
+
+  @override
+  bool get wantKeepAlive => true;
+
+  @override
+  void initState() {
+    super.initState();
+    // Get cached data synchronously BEFORE first build (no spinner flash)
+    final cached = widget.getCachedAudiobooks?.call();
+    if (cached != null && cached.isNotEmpty) {
+      _audiobooks = cached;
+      _isLoading = false;
+    }
+    _loadAudiobooks();
+  }
+
+  Future<void> _loadAudiobooks() async {
+    if (_hasLoaded) return;
+    _hasLoaded = true;
+
+    // Load fresh data (always update - fresh data may have updated progress)
+    try {
+      final freshAudiobooks = await widget.loadAudiobooks();
+      if (mounted && freshAudiobooks.isNotEmpty) {
+        setState(() {
+          _audiobooks = freshAudiobooks;
+          _isLoading = false;
+        });
+        // Pre-cache images for smooth hero animations
+        _precacheAudiobookImages(freshAudiobooks);
+      }
+    } catch (e) {
+      // Silent failure - keep showing cached data
+    }
+
+    if (mounted && _isLoading) {
+      setState(() => _isLoading = false);
+    }
+  }
+
+  /// Pre-cache audiobook images so Hero animations are smooth on first tap
+  void _precacheAudiobookImages(List<Audiobook> audiobooks) {
+    if (!mounted || _hasPrecachedAudiobooks) return;
+    _hasPrecachedAudiobooks = true;
+
+    final maProvider = context.read<MusicAssistantProvider>();
+
+    // Only precache first ~10 visible items
+    final audiobooksToCache = audiobooks.take(10);
+
+    for (final audiobook in audiobooksToCache) {
+      final imageUrl = maProvider.api?.getImageUrl(audiobook, size: 256);
+      if (imageUrl != null) {
+        precacheImage(
+          CachedNetworkImageProvider(imageUrl),
+          context,
+        ).catchError((_) {
+          // Silently ignore precache errors
+          return false;
+        });
+      }
+    }
+  }
+
+  static final _logger = DebugLogger();
+
+  Widget _buildContent(double contentHeight, ColorScheme colorScheme, MusicAssistantProvider maProvider) {
+    // Only show loading if we have no data at all
+    if (_audiobooks.isEmpty && _isLoading) {
+      return const Center(child: CircularProgressIndicator());
+    }
+
+    if (_audiobooks.isEmpty) {
+      return Center(
+        child: Text(
+          'No audiobooks found',
+          style: TextStyle(color: colorScheme.onSurface.withOpacity(0.5)),
+        ),
+      );
+    }
+
+    const textAreaHeight = 44.0;
+    final artworkSize = contentHeight - textAreaHeight;
+    final cardWidth = artworkSize;
+    final itemExtent = cardWidth + 12;
+
+    return ScrollConfiguration(
+      behavior: const _StretchScrollBehavior(),
+      child: ListView.builder(
+        scrollDirection: Axis.horizontal,
+        padding: const EdgeInsets.symmetric(horizontal: 12.0),
+        itemCount: _audiobooks.length,
+        itemExtent: itemExtent,
+        cacheExtent: 500,
+        addAutomaticKeepAlives: false,
+        addRepaintBoundaries: false,
+        itemBuilder: (context, index) {
+          final audiobook = _audiobooks[index];
+          return Container(
+            key: ValueKey(audiobook.uri ?? audiobook.itemId),
+            width: cardWidth,
+            margin: const EdgeInsets.symmetric(horizontal: 6.0),
+            child: _AudiobookCard(
+              audiobook: audiobook,
+              heroTagSuffix: widget.heroTagSuffix ?? 'home_${widget.title.replaceAll(' ', '_').toLowerCase()}',
+              maProvider: maProvider,
+            ),
+          );
+        },
+      ),
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    _logger.startBuild('AudiobookRow:${widget.title}');
+    super.build(context); // Required for AutomaticKeepAliveClientMixin
+    final textTheme = Theme.of(context).textTheme;
+    final colorScheme = Theme.of(context).colorScheme;
+    final maProvider = context.read<MusicAssistantProvider>();
+
+    final totalHeight = widget.rowHeight ?? 237.0;
+    const titleHeight = 44.0;
+    final contentHeight = totalHeight - titleHeight;
+
+    final result = RepaintBoundary(
+      child: SizedBox(
+        height: totalHeight,
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Padding(
+              padding: const EdgeInsets.fromLTRB(16.0, 12.0, 16.0, 8.0),
+              child: Text(
+                widget.title,
+                style: textTheme.titleLarge?.copyWith(
+                  fontWeight: FontWeight.bold,
+                  color: colorScheme.onBackground,
+                ),
+              ),
+            ),
+            Expanded(
+              child: _buildContent(contentHeight, colorScheme, maProvider),
+            ),
+          ],
+        ),
+      ),
+    );
+    _logger.endBuild('AudiobookRow:${widget.title}');
+    return result;
+  }
+}
+
+class _AudiobookCard extends StatelessWidget {
+  final Audiobook audiobook;
+  final String heroTagSuffix;
+  final MusicAssistantProvider maProvider;
+
+  const _AudiobookCard({
+    required this.audiobook,
+    required this.heroTagSuffix,
+    required this.maProvider,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    final textTheme = Theme.of(context).textTheme;
+    final imageUrl = maProvider.getImageUrl(audiobook, size: 256);
+
+    return GestureDetector(
+      onTap: () {
+        Navigator.push(
+          context,
+          FadeSlidePageRoute(
+            child: AudiobookDetailScreen(
+              audiobook: audiobook,
+              heroTagSuffix: heroTagSuffix,
+              initialImageUrl: imageUrl,
+            ),
+          ),
+        );
+      },
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Expanded(
+            child: Stack(
+              children: [
+                Hero(
+                  tag: HeroTags.audiobookCover + (audiobook.uri ?? audiobook.itemId) + '_$heroTagSuffix',
+                  child: ClipRRect(
+                    borderRadius: BorderRadius.circular(8),
+                    child: Container(
+                      width: double.infinity,
+                      height: double.infinity,
+                      color: colorScheme.surfaceContainerHighest,
+                      child: imageUrl != null
+                          ? CachedNetworkImage(
+                              imageUrl: imageUrl,
+                              fit: BoxFit.cover,
+                              // PERF: Duration.zero for hero-wrapped images
+                              fadeInDuration: Duration.zero,
+                              fadeOutDuration: Duration.zero,
+                              memCacheWidth: 256,
+                              memCacheHeight: 256,
+                              placeholder: (_, __) => Center(
+                                child: Icon(
+                                  MdiIcons.bookOutline,
+                                  size: 48,
+                                  color: colorScheme.onSurfaceVariant,
+                                ),
+                              ),
+                              errorWidget: (_, __, ___) => Center(
+                                child: Icon(
+                                  MdiIcons.bookOutline,
+                                  size: 48,
+                                  color: colorScheme.onSurfaceVariant,
+                                ),
+                              ),
+                            )
+                          : Center(
+                              child: Icon(
+                                MdiIcons.bookOutline,
+                                size: 48,
+                                color: colorScheme.onSurfaceVariant,
+                              ),
+                            ),
+                    ),
+                  ),
+                ),
+                // Progress indicator
+                if (audiobook.progress > 0)
+                  Positioned(
+                    bottom: 0,
+                    left: 0,
+                    right: 0,
+                    child: ClipRRect(
+                      borderRadius: const BorderRadius.only(
+                        bottomLeft: Radius.circular(8),
+                        bottomRight: Radius.circular(8),
+                      ),
+                      child: LinearProgressIndicator(
+                        value: audiobook.progress,
+                        backgroundColor: Colors.black54,
+                        valueColor: AlwaysStoppedAnimation<Color>(colorScheme.primary),
+                        minHeight: 4,
+                      ),
+                    ),
+                  ),
+              ],
+            ),
+          ),
+          const SizedBox(height: 8),
+          Hero(
+            tag: HeroTags.audiobookTitle + (audiobook.uri ?? audiobook.itemId) + '_$heroTagSuffix',
+            child: Material(
+              color: Colors.transparent,
+              child: Text(
+                audiobook.name,
+                style: textTheme.bodyMedium?.copyWith(
+                  fontWeight: FontWeight.w500,
+                ),
+                maxLines: 1,
+                overflow: TextOverflow.ellipsis,
+              ),
+            ),
+          ),
+          Text(
+            audiobook.authorsString,
+            style: textTheme.bodySmall?.copyWith(
+              color: colorScheme.onSurface.withOpacity(0.6),
+            ),
+            maxLines: 1,
+            overflow: TextOverflow.ellipsis,
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+class _StretchScrollBehavior extends ScrollBehavior {
+  const _StretchScrollBehavior();
+
+  @override
+  Widget buildOverscrollIndicator(
+      BuildContext context, Widget child, ScrollableDetails details) {
+    return StretchingOverscrollIndicator(
+      axisDirection: details.direction,
+      child: child,
+    );
+  }
+}

lib/widgets/common/disconnected_state.dart

@@ -1,4 +1,5 @@
 import 'package:flutter/material.dart';
+import '../../l10n/app_localizations.dart';
 import '../../theme/design_tokens.dart';
 
 /// A reusable widget for displaying disconnected/offline state.
@@ -21,29 +22,31 @@ class DisconnectedState extends StatelessWidget {
   });
 
   /// Simple disconnected state without action button
-  factory DisconnectedState.simple() => const DisconnectedState(
-        title: 'Not connected to Music Assistant',
+  factory DisconnectedState.simple(BuildContext context) => DisconnectedState(
+        title: S.of(context)!.notConnected,
       );
 
   /// Disconnected state with settings button for navigation
   factory DisconnectedState.withSettingsAction({
+    required BuildContext context,
     required VoidCallback onSettings,
   }) =>
       DisconnectedState(
-        title: 'Not connected to Music Assistant',
-        actionLabel: 'Configure Server',
+        title: S.of(context)!.notConnected,
+        actionLabel: S.of(context)!.configureServer,
         actionIcon: Icons.settings_rounded,
         onAction: onSettings,
       );
 
   /// Full disconnected state with title, subtitle, and action (for home screen)
   factory DisconnectedState.full({
+    required BuildContext context,
     required VoidCallback onSettings,
   }) =>
       DisconnectedState(
-        title: 'Not Connected',
-        subtitle: 'Connect to your Music Assistant server to start listening',
-        actionLabel: 'Configure Server',
+        title: S.of(context)!.notConnectedTitle,
+        subtitle: S.of(context)!.connectHint,
+        actionLabel: S.of(context)!.configureServer,
         actionIcon: Icons.settings_rounded,
         onAction: onSettings,
         iconSize: 80,

lib/widgets/common/empty_state.dart

@@ -1,4 +1,5 @@
 import 'package:flutter/material.dart';
+import '../../l10n/app_localizations.dart';
 import '../../theme/design_tokens.dart';
 
 /// A reusable empty state widget for displaying when no data is available.
@@ -21,48 +22,66 @@ class EmptyState extends StatelessWidget {
   });
 
   /// Creates an empty state for artists
-  factory EmptyState.artists({VoidCallback? onRefresh}) => EmptyState(
-        icon: Icons.person_outline_rounded,
-        message: 'No artists found',
-        actionLabel: onRefresh != null ? 'Refresh' : null,
-        onAction: onRefresh,
-      );
+  factory EmptyState.artists({VoidCallback? onRefresh, required BuildContext context}) {
+    final s = S.of(context)!;
+    return EmptyState(
+      icon: Icons.person_outline_rounded,
+      message: s.noArtistsFound,
+      actionLabel: onRefresh != null ? s.refresh : null,
+      onAction: onRefresh,
+    );
+  }
 
   /// Creates an empty state for albums
-  factory EmptyState.albums({VoidCallback? onRefresh}) => EmptyState(
-        icon: Icons.album_outlined,
-        message: 'No albums found',
-        actionLabel: onRefresh != null ? 'Refresh' : null,
-        onAction: onRefresh,
-      );
+  factory EmptyState.albums({VoidCallback? onRefresh, required BuildContext context}) {
+    final s = S.of(context)!;
+    return EmptyState(
+      icon: Icons.album_outlined,
+      message: s.noAlbumsFound,
+      actionLabel: onRefresh != null ? s.refresh : null,
+      onAction: onRefresh,
+    );
+  }
 
   /// Creates an empty state for tracks
-  factory EmptyState.tracks({VoidCallback? onRefresh}) => EmptyState(
-        icon: Icons.music_note_outlined,
-        message: 'No tracks found',
-        actionLabel: onRefresh != null ? 'Refresh' : null,
-        onAction: onRefresh,
-      );
+  factory EmptyState.tracks({VoidCallback? onRefresh, required BuildContext context}) {
+    final s = S.of(context)!;
+    return EmptyState(
+      icon: Icons.music_note_outlined,
+      message: s.noTracksFound,
+      actionLabel: onRefresh != null ? s.refresh : null,
+      onAction: onRefresh,
+    );
+  }
 
   /// Creates an empty state for playlists
-  factory EmptyState.playlists({VoidCallback? onRefresh}) => EmptyState(
-        icon: Icons.playlist_play_rounded,
-        message: 'No playlists found',
-        actionLabel: onRefresh != null ? 'Refresh' : null,
-        onAction: onRefresh,
-      );
+  factory EmptyState.playlists({VoidCallback? onRefresh, required BuildContext context}) {
+    final s = S.of(context)!;
+    return EmptyState(
+      icon: Icons.playlist_play_rounded,
+      message: s.noPlaylistsFound,
+      actionLabel: onRefresh != null ? s.refresh : null,
+      onAction: onRefresh,
+    );
+  }
 
   /// Creates an empty state for queue
-  factory EmptyState.queue() => const EmptyState(
-        icon: Icons.queue_music,
-        message: 'Queue is empty',
-      );
+  factory EmptyState.queue({required BuildContext context}) {
+    final s = S.of(context)!;
+    return EmptyState(
+      icon: Icons.queue_music,
+      message: s.queueIsEmpty,
+    );
+  }
 
   /// Creates an empty state for search results
-  factory EmptyState.search() => const EmptyState(
-        icon: Icons.search_off_rounded,
-        message: 'No results found',
-      );
+  factory EmptyState.search({required BuildContext context}) {
+    final s = S.of(context)!;
+    return EmptyState(
+      icon: Icons.search_off_rounded,
+      message: s.noResultsFound,
+    );
+  }
 
   /// Creates a custom empty state with title and subtitle
   factory EmptyState.custom({
@@ -70,12 +89,14 @@ class EmptyState extends StatelessWidget {
     required String title,
     String? subtitle,
     VoidCallback? onRefresh,
+    required BuildContext context,
   }) =>
       _CustomEmptyState(
         icon: icon,
         title: title,
         subtitle: subtitle,
         onRefresh: onRefresh,
+        context: context,
       );
 
   @override
@@ -126,17 +147,20 @@ class _CustomEmptyState extends EmptyState {
   final String title;
   final String? subtitle;
   final VoidCallback? onRefresh;
+  final BuildContext context;
 
   const _CustomEmptyState({
     required super.icon,
     required this.title,
     this.subtitle,
     this.onRefresh,
+    required this.context,
   }) : super(message: title);
 
   @override
   Widget build(BuildContext context) {
     final colorScheme = Theme.of(context).colorScheme;
+    final s = S.of(context)!;
 
     return Center(
       child: Padding(
@@ -175,7 +199,7 @@ class _CustomEmptyState extends EmptyState {
               ElevatedButton.icon(
                 onPressed: onRefresh,
                 icon: const Icon(Icons.refresh_rounded),
-                label: const Text('Refresh'),
+                label: Text(s.refresh),
                 style: ElevatedButton.styleFrom(
                   backgroundColor: colorScheme.surfaceVariant,
                   foregroundColor: colorScheme.onSurfaceVariant,

lib/widgets/global_player_overlay.dart

@@ -1,9 +1,17 @@
+import 'dart:async';
+import 'dart:ui';
 import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
 import 'package:provider/provider.dart';
+import '../l10n/app_localizations.dart';
 import '../providers/music_assistant_provider.dart';
 import '../providers/navigation_provider.dart';
+import '../services/settings_service.dart';
 import '../theme/theme_provider.dart';
+
 import 'expandable_player.dart';
+import 'player/mini_player_content.dart' show MiniPlayerLayout;
+import 'player/player_reveal_overlay.dart';
 
 /// Cached color with contrast adjustment
 /// Avoids expensive HSL conversions during scroll
@@ -50,23 +58,24 @@ class BottomSpacing {
   /// Height of the bottom navigation bar
   static const double navBarHeight = 56.0;
 
-  /// Height of mini player when visible (64px height + 12px margin)
-  static const double miniPlayerHeight = 76.0;
+  /// Height of mini player when visible (height + 12px margin)
+  static double get miniPlayerHeight => MiniPlayerLayout.height + 12.0;
 
   /// Space needed when only nav bar is visible (with some extra padding)
   static const double navBarOnly = navBarHeight + 16.0;
 
   /// Space needed when mini player is also visible
-  static const double withMiniPlayer = navBarHeight + miniPlayerHeight + 22.0;
+  static double get withMiniPlayer => navBarHeight + miniPlayerHeight + 22.0;
 }
 
-/// ValueNotifier for player expansion progress (0.0 to 1.0) and background color
+/// ValueNotifier for player expansion progress (0.0 to 1.0) and colors
 class PlayerExpansionState {
   final double progress;
   final Color? backgroundColor;
-  PlayerExpansionState(this.progress, this.backgroundColor);
+  final Color? primaryColor;
+  PlayerExpansionState(this.progress, this.backgroundColor, this.primaryColor);
 }
-final playerExpansionNotifier = ValueNotifier<PlayerExpansionState>(PlayerExpansionState(0.0, null));
+final playerExpansionNotifier = ValueNotifier<PlayerExpansionState>(PlayerExpansionState(0.0, null, null));
 
 /// Wrapper widget that provides a global player overlay above all navigation.
 ///
@@ -92,6 +101,21 @@ class GlobalPlayerOverlay extends StatefulWidget {
   static bool get isPlayerExpanded =>
       globalPlayerKey.currentState?.isExpanded ?? false;
 
+  /// Check if the queue panel is currently open (animation value > 0.5)
+  static bool get isQueuePanelOpen =>
+      globalPlayerKey.currentState?.isQueuePanelOpen ?? false;
+
+  /// Check if the queue panel is intended to be open (target state)
+  /// Use this for back gesture handling to avoid timing issues during animations
+  static bool get isQueuePanelTargetOpen =>
+      globalPlayerKey.currentState?.isQueuePanelTargetOpen ?? false;
+
+  /// Close the queue panel if open
+  /// [withHaptic]: Set to false for Android back gesture (system provides haptic)
+  static void closeQueuePanel({bool withHaptic = true}) {
+    globalPlayerKey.currentState?.closeQueuePanel(withHaptic: withHaptic);
+  }
+
   /// Get the current expansion progress (0.0 to 1.0)
   static double get expansionProgress =>
       globalPlayerKey.currentState?.expansionProgress ?? 0.0;
@@ -110,13 +134,74 @@ class GlobalPlayerOverlay extends StatefulWidget {
   static void showPlayer() {
     _overlayStateKey.currentState?._setHidden(false);
   }
+
+  /// Show the player reveal overlay with bounce animation
+  static void showPlayerReveal() {
+    _overlayStateKey.currentState?._showPlayerReveal();
+  }
+
+  /// Hide the player reveal overlay (no animation - used as callback from overlay)
+  static void hidePlayerReveal() {
+    _overlayStateKey.currentState?._hidePlayerReveal();
+  }
+
+  /// Dismiss the player reveal overlay with animation (for back gesture)
+  static void dismissPlayerReveal() {
+    _overlayStateKey.currentState?._dismissPlayerReveal();
+  }
+
+  /// Trigger single bounce on mini player (called when device selector collapses)
+  static void triggerBounce() {
+    _overlayStateKey.currentState?._triggerBounce();
+  }
+
+  /// Check if the player reveal is currently visible
+  static bool get isPlayerRevealVisible =>
+      _overlayStateKey.currentState?._isRevealVisible ?? false;
 }
 
 class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
-    with SingleTickerProviderStateMixin {
+    with TickerProviderStateMixin {
   late AnimationController _slideController;
   late Animation<double> _slideAnimation;
 
+  // Single bounce controller for device selector expand/collapse
+  late AnimationController _singleBounceController;
+
+  // Double bounce controller for hint
+  late AnimationController _doubleBounceController;
+
+  // State for player reveal overlay
+  bool _isRevealVisible = false;
+
+  // State for interactive hint mode (blur backdrop + wait for user action)
+  bool _isHintModeActive = false;
+  Timer? _hintBounceTimer;
+
+  // Track if player reveal was triggered from onboarding (for showing extra hints)
+  bool _isOnboardingReveal = false;
+
+  // Bounce offset for mini player (used by both single and double bounce)
+  final _bounceOffsetNotifier = ValueNotifier<double>(0.0);
+
+  // Hint system state
+  // NOTE: AppStartup now handles the settings loading gate. It waits for:
+  // - First-time users: connected + player selected before showing HomeScreen
+  // - Returning users: connected before showing HomeScreen
+  // This eliminates the race condition that caused home screen flash.
+  bool _showHints = true;
+  bool _hasCompletedOnboarding = false; // First-use welcome screen
+  bool _hintTriggered = false; // Prevent multiple triggers per session
+  bool _settingsLoaded = false; // True once settings have been loaded from storage
+  bool _miniPlayerHintsReady = false; // True once connected with player (can show hints)
+  final _hintOpacityNotifier = ValueNotifier<double>(0.0);
+
+  // Welcome content fade-in animation
+  late AnimationController _welcomeFadeController;
+
+  // Key for the reveal overlay
+  final _revealKey = GlobalKey<PlayerRevealOverlayState>();
+
   @override
   void initState() {
     super.initState();
@@ -129,11 +214,135 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
       curve: Curves.easeOutCubic,
       reverseCurve: Curves.easeInCubic,
     );
+
+    // Single bounce for device selector expand/collapse
+    _singleBounceController = AnimationController(
+      duration: const Duration(milliseconds: 400),
+      vsync: this,
+    );
+    _singleBounceController.addListener(() {
+      final t = Curves.easeOut.transform(_singleBounceController.value);
+      // Single bounce: up to 10px then back to 0
+      if (t < 0.5) {
+        _bounceOffsetNotifier.value = 10.0 * (t * 2);           // 0 -> 10
+      } else {
+        _bounceOffsetNotifier.value = 10.0 * ((1.0 - t) * 2);   // 10 -> 0
+      }
+    });
+
+    // Hint bounce - single gentle bounce to draw attention
+    _doubleBounceController = AnimationController(
+      duration: const Duration(milliseconds: 600),
+      vsync: this,
+    );
+    _doubleBounceController.addListener(() {
+      final t = Curves.easeOut.transform(_doubleBounceController.value);
+      // Single bounce: up 20px then back down
+      if (t < 0.5) {
+        _bounceOffsetNotifier.value = 20.0 * (t * 2);           // 0 -> 20
+      } else {
+        _bounceOffsetNotifier.value = 20.0 * ((1.0 - t) * 2);   // 20 -> 0
+      }
+    });
+
+    // Welcome content fade-in
+    _welcomeFadeController = AnimationController(
+      duration: const Duration(milliseconds: 800),
+      vsync: this,
+    );
+
+    // Load hint settings and start welcome immediately if needed
+    _loadHintSettings();
+  }
+
+  Future<void> _loadHintSettings() async {
+    _showHints = await SettingsService.getShowHints();
+    _hasCompletedOnboarding = await SettingsService.getHasCompletedOnboarding();
+    if (!mounted) return;
+
+    setState(() {
+      _settingsLoaded = true;
+    });
+
+    // If first-time user and already connected (AppStartup waited for us),
+    // start welcome screen immediately - no race condition possible
+    if (!_hasCompletedOnboarding && !_hintTriggered) {
+      final provider = context.read<MusicAssistantProvider>();
+      if (provider.isConnected && provider.selectedPlayer != null) {
+        _miniPlayerHintsReady = true;
+        _startWelcomeScreen();
+        _startMiniPlayerBounce();
+      }
+    }
+  }
+
+  @override
+  void didChangeDependencies() {
+    super.didChangeDependencies();
+    // Check if we should enable mini player hints now that we have connection
+    _checkConnectionForMiniPlayerHints();
+  }
+
+  /// Check connection state and start welcome screen if appropriate.
+  /// This is called from multiple places:
+  /// 1. didChangeDependencies() - when widget first builds
+  /// 2. _loadHintSettings() - when settings finish loading
+  /// 3. build() - when provider state changes (via post-frame callback)
+  void _checkConnectionForMiniPlayerHints() {
+    if (_hintTriggered || !mounted || !_settingsLoaded) return;
+    if (_hasCompletedOnboarding) return; // Not first-time user
+
+    final provider = context.read<MusicAssistantProvider>();
+    if (provider.isConnected && provider.selectedPlayer != null) {
+      // Connected with a player - start welcome screen now
+      _miniPlayerHintsReady = true;
+      _startWelcomeScreen();
+      // Start the bounce animation now that mini player is visible
+      _startMiniPlayerBounce();
+    }
+  }
+
+  /// Start the bounce animation for mini player hints
+  void _startMiniPlayerBounce() {
+    if (!_isHintModeActive || !mounted) return;
+    _doubleBounceController.reset();
+    _doubleBounceController.forward();
+
+    // Repeat bounce every 2 seconds
+    _hintBounceTimer?.cancel();
+    _hintBounceTimer = Timer.periodic(const Duration(seconds: 2), (_) {
+      if (_isHintModeActive && mounted) {
+        _doubleBounceController.reset();
+        _doubleBounceController.forward();
+      }
+    });
+  }
+
+  /// Start the welcome screen with fade-in animation
+  void _startWelcomeScreen() {
+    if (_hintTriggered) return;
+    _hintTriggered = true;
+
+    // Activate hint mode immediately (blur backdrop visible)
+    setState(() {
+      _isHintModeActive = true;
+    });
+
+    // Fade in welcome content (logo + title)
+    _welcomeFadeController.forward();
+
+    // Mini player bounce is started separately once connected via _startMiniPlayerBounce()
   }
 
   @override
   void dispose() {
+    _hintBounceTimer?.cancel();
     _slideController.dispose();
+    _singleBounceController.dispose();
+    _doubleBounceController.dispose();
+    _welcomeFadeController.dispose();
+    _bounceOffsetNotifier.dispose();
+    _hintOpacityNotifier.dispose();
     super.dispose();
   }
 
@@ -145,12 +354,121 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
     }
   }
 
+  void _showPlayerReveal() {
+    if (_isRevealVisible) return;
+    if (GlobalPlayerOverlay.isPlayerExpanded) {
+      GlobalPlayerOverlay.collapsePlayer();
+    }
+    HapticFeedback.mediumImpact();
+
+    // Track if coming from hint mode (for onboarding hints in player selector)
+    final wasInHintMode = _isHintModeActive;
+
+    // End hint mode if active (user learned the gesture!)
+    _hintBounceTimer?.cancel();
+    _hintBounceTimer = null;
+    _hintOpacityNotifier.value = 0.0;
+    _isHintModeActive = false;
+
+    // Mark onboarding as completed if coming from welcome screen
+    if (wasInHintMode) {
+      SettingsService.setHasCompletedOnboarding(true);
+    }
+
+    // Trigger single bounce on expand
+    _singleBounceController.reset();
+    _singleBounceController.forward();
+
+    setState(() {
+      _isRevealVisible = true;
+      _isOnboardingReveal = wasInHintMode;
+    });
+  }
+
+  void _hidePlayerReveal() {
+    if (!_isRevealVisible) return;
+    _bounceOffsetNotifier.value = 0;
+    setState(() {
+      _isRevealVisible = false;
+      _isOnboardingReveal = false;
+    });
+  }
+
+  /// Dismiss with animation (for back gesture) - calls overlay's dismiss method
+  void _dismissPlayerReveal() {
+    if (!_isRevealVisible) return;
+    // Call the overlay's dismiss method which has the slide animation
+    _revealKey.currentState?.dismiss();
+  }
+
+  /// Trigger single bounce on mini player (called when device selector collapses)
+  void _triggerBounce() {
+    _singleBounceController.reset();
+    _singleBounceController.forward();
+  }
+
+  /// End hint mode (called when user taps skip button)
+  void _endHintMode() {
+    if (!_isHintModeActive) return;
+    _hintBounceTimer?.cancel();
+    _hintBounceTimer = null;
+    _hintOpacityNotifier.value = 0.0;
+    _bounceOffsetNotifier.value = 0.0;
+    // Mark onboarding as completed (first use only)
+    SettingsService.setHasCompletedOnboarding(true);
+    setState(() {
+      _isHintModeActive = false;
+    });
+  }
+
   @override
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
 
-    return Stack(
+    // Watch provider to trigger rebuilds when connection state changes
+    final provider = context.watch<MusicAssistantProvider>();
+
+    // 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;
+
+    // Show welcome backdrop if:
+    // 1. Already in hint mode (_isHintModeActive), OR
+    // 2. First-time user ready but hint mode not started yet (!_hintTriggered)
+    // This ensures backdrop appears IMMEDIATELY when HomeScreen renders,
+    // preventing the flash. Welcome content fades in after via animation.
+    final shouldShowWelcomeBackdrop = _isHintModeActive ||
+        (isFirstTimeUserReady && !_hintTriggered);
+
+    // Trigger hint mode if conditions are met (for animations, bounce, etc)
+    if (isFirstTimeUserReady && !_hintTriggered) {
+      // Schedule for post-frame to avoid setState during build
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        if (mounted && !_hintTriggered) {
+          _miniPlayerHintsReady = true;
+          _startWelcomeScreen();
+          _startMiniPlayerBounce();
+        }
+      });
+    }
+
+    // Handle back gesture at top level - dismiss hint mode or device list if visible
+    return PopScope(
+      canPop: !_isRevealVisible && !_isHintModeActive,
+      onPopInvokedWithResult: (didPop, result) {
+        if (!didPop) {
+          if (_isHintModeActive) {
+            _endHintMode();
+          } else if (_isRevealVisible) {
+            _dismissPlayerReveal();
+          }
+        }
+      },
+      child: Stack(
       children: [
         // The main app content (Navigator, screens, etc.)
         // Add bottom padding to account for bottom nav + mini player
@@ -159,83 +477,57 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
           child: widget.child,
         ),
         // Global persistent bottom navigation bar - positioned at bottom
-        Positioned(
-          left: 0,
-          right: 0,
-          bottom: 0,
-          child: ListenableBuilder(
-            listenable: navigationProvider,
-            builder: (context, _) {
-              return Consumer<ThemeProvider>(
+        // 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)
+          Positioned(
+            left: 0,
+            right: 0,
+            bottom: 0,
+            child: ListenableBuilder(
+              listenable: navigationProvider,
+              builder: (context, _) {
+                return Consumer<ThemeProvider>(
                 builder: (context, themeProvider, _) {
-                  // Use adaptive primary color for bottom nav when adaptive theme is enabled
-                  final sourceColor = themeProvider.adaptiveTheme
-                      ? themeProvider.adaptivePrimaryColor
-                      : colorScheme.primary;
-
-                  // Use cached color computation to avoid expensive HSL operations during scroll
                   final isDark = Theme.of(context).brightness == Brightness.dark;
-                  final navSelectedColor = _cachedNavColor.getAdjustedColor(sourceColor, isDark);
-
-                  // Base background: use adaptive surface color if available, otherwise default surface
-                  final baseBgColor = (themeProvider.adaptiveTheme && themeProvider.adaptiveSurfaceColor != null)
-                      ? themeProvider.adaptiveSurfaceColor!
-                      : colorScheme.surface;
 
                   return ValueListenableBuilder<PlayerExpansionState>(
                     valueListenable: playerExpansionNotifier,
-                    // Pass BottomNavigationBar as child to avoid rebuilding it every frame
-                    child: BottomNavigationBar(
-                      currentIndex: navigationProvider.selectedIndex,
-                      onTap: (index) {
-                        if (GlobalPlayerOverlay.isPlayerExpanded) {
-                          GlobalPlayerOverlay.collapsePlayer();
-                        }
-                        navigationProvider.navigatorKey.currentState?.popUntil((route) => route.isFirst);
-                        if (index == 3) {
-                          GlobalPlayerOverlay.hidePlayer();
-                        } else if (navigationProvider.selectedIndex == 3) {
-                          GlobalPlayerOverlay.showPlayer();
-                        }
-                        navigationProvider.setSelectedIndex(index);
-                      },
-                      backgroundColor: Colors.transparent,
-                      selectedItemColor: navSelectedColor,
-                      unselectedItemColor: colorScheme.onSurface.withOpacity(0.54),
-                      elevation: 0,
-                      type: BottomNavigationBarType.fixed,
-                      selectedFontSize: 12,
-                      unselectedFontSize: 12,
-                      items: const [
-                        BottomNavigationBarItem(
-                          icon: Icon(Icons.home_outlined),
-                          activeIcon: Icon(Icons.home_rounded),
-                          label: 'Home',
-                        ),
-                        BottomNavigationBarItem(
-                          icon: Icon(Icons.library_music_outlined),
-                          activeIcon: Icon(Icons.library_music_rounded),
-                          label: 'Library',
-                        ),
-                        BottomNavigationBarItem(
-                          icon: Icon(Icons.search_rounded),
-                          activeIcon: Icon(Icons.search_rounded),
-                          label: 'Search',
-                        ),
-                        BottomNavigationBarItem(
-                          icon: Icon(Icons.settings_outlined),
-                          activeIcon: Icon(Icons.settings_rounded),
-                          label: 'Settings',
-                        ),
-                      ],
-                    ),
-                    builder: (context, expansionState, navBar) {
-                      // Only compute colors during animation - this is the hot path
-                      final navBgColor = expansionState.progress > 0 && expansionState.backgroundColor != null
-                          ? Color.lerp(baseBgColor, expansionState.backgroundColor, expansionState.progress)!
-                          : baseBgColor;
+                    builder: (context, expansionState, _) {
+                      // Nav bar color logic - only use adaptive colors when:
+                      // 1. Player is expanding/expanded, OR
+                      // 2. On a detail screen (isOnDetailScreen)
+                      // On home screen with collapsed player: always use default theme colors
+                      final bool useAdaptiveColors = themeProvider.adaptiveTheme &&
+                          (expansionState.progress > 0 || themeProvider.isOnDetailScreen);
+
+                      // Nav bar background color
+                      final Color navBgColor;
+                      if (expansionState.progress > 0 && expansionState.backgroundColor != null) {
+                        // Player is expanding - blend from surface to player's adaptive color
+                        navBgColor = Color.lerp(colorScheme.surface, expansionState.backgroundColor, expansionState.progress)!;
+                      } else if (useAdaptiveColors) {
+                        // On a detail screen - use adaptive surface color for nav bar
+                        final adaptiveBg = themeProvider.getAdaptiveSurfaceColorFor(Theme.of(context).brightness);
+                        navBgColor = adaptiveBg ?? colorScheme.surface;
+                      } else {
+                        // Home screen with collapsed player - use default surface color
+                        navBgColor = colorScheme.surface;
+                      }
+
+                      // Icon color - only use adaptive colors when appropriate
+                      final Color baseSourceColor = (useAdaptiveColors && themeProvider.adaptiveColors != null)
+                          ? themeProvider.adaptiveColors!.primary
+                          : colorScheme.primary;
+
+                      // Blend icon color with player's primary color during expansion
+                      Color sourceColor = baseSourceColor;
+                      if (themeProvider.adaptiveTheme && expansionState.progress > 0 && expansionState.primaryColor != null) {
+                        sourceColor = Color.lerp(baseSourceColor, expansionState.primaryColor!, expansionState.progress)!;
+                      }
+                      final navSelectedColor = _cachedNavColor.getAdjustedColor(sourceColor, isDark);
 
-                      // Use AnimatedContainer for smoother transitions instead of rebuilding
                       return Container(
                         decoration: BoxDecoration(
                           color: navBgColor,
@@ -249,41 +541,229 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
                                 ]
                               : null,
                         ),
-                        child: navBar, // Reuse pre-built navigation bar
+                        child: BottomNavigationBar(
+                          currentIndex: navigationProvider.selectedIndex,
+                          onTap: (index) {
+                            if (GlobalPlayerOverlay.isPlayerExpanded) {
+                              GlobalPlayerOverlay.collapsePlayer();
+                            }
+                            navigationProvider.navigatorKey.currentState?.popUntil((route) => route.isFirst);
+                            if (index == 3) {
+                              GlobalPlayerOverlay.hidePlayer();
+                            } else if (navigationProvider.selectedIndex == 3) {
+                              GlobalPlayerOverlay.showPlayer();
+                            }
+                            navigationProvider.setSelectedIndex(index);
+                          },
+                          backgroundColor: Colors.transparent,
+                          selectedItemColor: navSelectedColor,
+                          unselectedItemColor: colorScheme.onSurface.withOpacity(0.54),
+                          elevation: 0,
+                          type: BottomNavigationBarType.fixed,
+                          selectedFontSize: 12,
+                          unselectedFontSize: 12,
+                          items: [
+                            BottomNavigationBarItem(
+                              icon: const Icon(Icons.home_outlined),
+                              activeIcon: const Icon(Icons.home_rounded),
+                              label: S.of(context)!.home,
+                            ),
+                            BottomNavigationBarItem(
+                              icon: const Icon(Icons.library_music_outlined),
+                              activeIcon: const Icon(Icons.library_music_rounded),
+                              label: S.of(context)!.library,
+                            ),
+                            BottomNavigationBarItem(
+                              icon: const Icon(Icons.search_rounded),
+                              activeIcon: const Icon(Icons.search_rounded),
+                              label: S.of(context)!.search,
+                            ),
+                            BottomNavigationBarItem(
+                              icon: const Icon(Icons.settings_outlined),
+                              activeIcon: const Icon(Icons.settings_rounded),
+                              label: S.of(context)!.settings,
+                            ),
+                          ],
+                        ),
                       );
                     },
                   );
                 },
               );
-            },
+              },
+            ),
           ),
-        ),
-        // Global player overlay - slides down when hidden, renders ON TOP of bottom nav
+        // Blur backdrop for device selector (reveal mode) - static, no animation
+        if (_isRevealVisible && !_isHintModeActive)
+          Positioned.fill(
+            child: GestureDetector(
+              behavior: HitTestBehavior.opaque,
+              onTap: _dismissPlayerReveal,
+              child: BackdropFilter(
+                filter: ImageFilter.blur(sigmaX: 8.0, sigmaY: 8.0),
+                child: Container(
+                  color: colorScheme.surface.withOpacity(0.5),
+                ),
+              ),
+            ),
+          ),
+
+        // Welcome/hint backdrop - shows IMMEDIATELY when first-time user is ready.
+        // Uses computed `shouldShowWelcomeBackdrop` which is true BEFORE _isHintModeActive,
+        // preventing the 1-frame gap where home screen would be visible.
+        if (shouldShowWelcomeBackdrop)
+          Positioned.fill(
+            child: TweenAnimationBuilder<double>(
+              // Hold solid for 2s, then fade to 0.5 over 1s
+              tween: Tween<double>(begin: 1.0, end: 0.5),
+              duration: const Duration(seconds: 3),
+              curve: const Interval(0.67, 1.0, curve: Curves.easeOut),
+              builder: (context, opacity, child) {
+                return BackdropFilter(
+                  filter: ImageFilter.blur(sigmaX: 8.0, sigmaY: 8.0),
+                  child: Container(
+                    // Use same dark color as connection screen for seamless transition
+                    color: const Color(0xFF1a1a1a).withOpacity(opacity),
+                  ),
+                );
+              },
+            ),
+          ),
+
+        // Welcome message during hint mode - two positioned sections with fade-in
+        // Top section: Logo and Welcome title (stays fixed at top area)
+        if (_isHintModeActive)
+          Positioned(
+            left: 24,
+            right: 24,
+            // Position logo section high up - about 1/3 from top
+            top: MediaQuery.of(context).size.height * 0.15,
+            child: FadeTransition(
+              opacity: CurvedAnimation(
+                parent: _welcomeFadeController,
+                curve: Curves.easeOut,
+              ),
+              child: Column(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  // Ensemble logo - same as settings screen
+                  Image.asset(
+                    'assets/images/ensemble_icon_transparent.png',
+                    width: MediaQuery.of(context).size.width * 0.5,
+                    fit: BoxFit.contain,
+                  ),
+                  const SizedBox(height: 24),
+                  // Welcome title
+                  Text(
+                    S.of(context)!.welcomeToEnsemble,
+                    style: theme.textTheme.headlineSmall?.copyWith(
+                      color: Colors.white,
+                      fontWeight: FontWeight.bold,
+                    ),
+                    textAlign: TextAlign.center,
+                  ),
+                ],
+              ),
+            ),
+          ),
+
+        // Bottom section: Hint text and Skip button (only show once mini player is visible)
+        if (_isHintModeActive && _miniPlayerHintsReady)
+          Positioned(
+            left: 24,
+            right: 24,
+            // Position so skip button is ~32px above mini player, matching skip-to-miniplayer gap
+            // Use viewPadding to match BottomNavigationBar's height calculation
+            bottom: BottomSpacing.navBarHeight + BottomSpacing.miniPlayerHeight + MediaQuery.of(context).viewPadding.bottom + 32,
+            child: FadeTransition(
+              opacity: CurvedAnimation(
+                parent: _welcomeFadeController,
+                curve: Curves.easeOut,
+              ),
+              child: Column(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  // Hint text
+                  Text(
+                    S.of(context)!.welcomeMessage,
+                    style: theme.textTheme.bodyLarge?.copyWith(
+                      color: Colors.white,
+                      fontSize: 16,
+                      height: 1.4,
+                    ),
+                    textAlign: TextAlign.center,
+                  ),
+                  const SizedBox(height: 32),
+                  // Skip button - same gap above as below to mini player
+                  TextButton(
+                    onPressed: _endHintMode,
+                    child: Text(
+                      S.of(context)!.skip,
+                      style: TextStyle(
+                        color: Colors.white.withOpacity(0.7),
+                        fontSize: 14,
+                      ),
+                    ),
+                  ),
+                ],
+              ),
+            ),
+          ),
+
+        // Player reveal overlay - renders BELOW mini player so cards slide behind it
+        if (_isRevealVisible)
+          PlayerRevealOverlay(
+            key: _revealKey,
+            onDismiss: _hidePlayerReveal,
+            // Use viewPadding to match BottomNavigationBar's height calculation
+            miniPlayerBottom: BottomSpacing.navBarHeight + MediaQuery.of(context).viewPadding.bottom + 12,
+            miniPlayerHeight: 64,
+            showOnboardingHints: _isOnboardingReveal,
+          ),
+
+        // Global player overlay - renders ON TOP so cards slide behind it
         // Use Selector instead of Consumer to avoid rebuilds during animation
-        Selector<MusicAssistantProvider, ({bool isConnected, bool hasPlayer})>(
+        Selector<MusicAssistantProvider, ({bool isConnected, bool hasPlayer, bool hasTrack})>(
           selector: (_, provider) => (
             isConnected: provider.isConnected,
             hasPlayer: provider.selectedPlayer != null,
+            hasTrack: provider.currentTrack != null,
           ),
           builder: (context, state, child) {
             // Only show player if connected and has a selected player
             if (!state.isConnected || !state.hasPlayer) {
               return const SizedBox.shrink();
             }
-            return AnimatedBuilder(
-              animation: _slideAnimation,
-              child: ExpandablePlayer(key: globalPlayerKey, slideOffset: 0),
-              builder: (context, staticChild) {
-                // Only slideOffset changes during animation, player widget stays same
-                return ExpandablePlayer(
-                  key: globalPlayerKey,
-                  slideOffset: _slideAnimation.value,
+
+            // Combine slide, bounce, and hint animations with ValueListenableBuilders
+            // This prevents full widget tree rebuilds - only ExpandablePlayer updates
+            return ValueListenableBuilder<double>(
+              valueListenable: _bounceOffsetNotifier,
+              builder: (context, bounceOffset, _) {
+                return ValueListenableBuilder<double>(
+                  valueListenable: _hintOpacityNotifier,
+                  builder: (context, hintOpacity, _) {
+                    return AnimatedBuilder(
+                      animation: _slideAnimation,
+                      builder: (context, _) {
+                        return ExpandablePlayer(
+                          key: globalPlayerKey,
+                          slideOffset: _slideAnimation.value,
+                          bounceOffset: bounceOffset,
+                          onRevealPlayers: _showPlayerReveal,
+                          isDeviceRevealVisible: _isRevealVisible,
+                          isHintVisible: hintOpacity > 0,
+                        );
+                      },
+                    );
+                  },
                 );
               },
             );
           },
         ),
       ],
+      ),
     );
   }
 }

lib/widgets/letter_scrollbar.dart

@@ -0,0 +1,255 @@
+import 'package:flutter/material.dart';
+
+/// A scrollbar that shows a letter popup when dragging, for fast navigation
+/// through alphabetically sorted lists.
+class LetterScrollbar extends StatefulWidget {
+  /// The scrollable child widget (ListView, GridView, etc.)
+  final Widget child;
+
+  /// 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
+  final List<String> items;
+
+  /// 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;
+
+  const LetterScrollbar({
+    super.key,
+    required this.child,
+    required this.controller,
+    required this.items,
+    this.onScrollToIndex,
+    this.onDragStateChanged,
+  });
+
+  @override
+  State<LetterScrollbar> createState() => _LetterScrollbarState();
+}
+
+class _LetterScrollbarState extends State<LetterScrollbar> {
+  bool _isDragging = false;
+  String _currentLetter = '';
+  double _dragPosition = 0;
+  double _scrollFraction = 0;
+
+  @override
+  void initState() {
+    super.initState();
+    widget.controller.addListener(_onScrollChanged);
+  }
+
+  @override
+  void dispose() {
+    widget.controller.removeListener(_onScrollChanged);
+    super.dispose();
+  }
+
+  void _onScrollChanged() {
+    if (!_isDragging && widget.controller.hasClients) {
+      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;
+          });
+        }
+      }
+    }
+  }
+
+  // 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;
+        }
+      }
+    }
+    return map;
+  }
+
+  String _getLetterAtPosition(double position, double maxHeight) {
+    if (widget.items.isEmpty || maxHeight <= 0) 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 item = widget.items[index];
+      if (item.isNotEmpty) {
+        return item[0].toUpperCase();
+      }
+    }
+    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);
+  }
+
+  void _handleDragUpdate(DragUpdateDetails details) {
+    setState(() {
+      _dragPosition = details.localPosition.dy;
+    });
+    _updateLetterAndScroll(details.localPosition.dy);
+  }
+
+  void _handleDragEnd(DragEndDetails details) {
+    setState(() {
+      _isDragging = false;
+    });
+    widget.onDragStateChanged?.call(false);
+  }
+
+  void _updateLetterAndScroll(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);
+      }
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Stack(
+      children: [
+        // The scrollable content
+        widget.child,
+
+        // The draggable scrollbar area (right edge) - wider grab area
+        Positioned(
+          right: 0,
+          top: 0,
+          bottom: 0,
+          width: 32, // Wider grab area
+          child: GestureDetector(
+            onVerticalDragStart: _handleDragStart,
+            onVerticalDragUpdate: _handleDragUpdate,
+            onVerticalDragEnd: _handleDragEnd,
+            onTapDown: (details) {
+              _handleDragStart(DragStartDetails(
+                localPosition: details.localPosition,
+                globalPosition: details.globalPosition,
+              ));
+            },
+            onTapUp: (_) {
+              setState(() {
+                _isDragging = false;
+              });
+              widget.onDragStateChanged?.call(false);
+            },
+            behavior: HitTestBehavior.translucent,
+            child: LayoutBuilder(
+              builder: (context, constraints) {
+                final trackHeight = constraints.maxHeight;
+                final thumbHeight = _isDragging ? 60.0 : 40.0;
+                final availableTrack = trackHeight - thumbHeight;
+                final thumbTop = availableTrack * _scrollFraction;
+
+                return Stack(
+                  children: [
+                    // Thumb that tracks scroll position - use AnimatedPositioned for smooth motion
+                    AnimatedPositioned(
+                      duration: const Duration(milliseconds: 50),
+                      curve: Curves.linear,
+                      top: thumbTop,
+                      right: 4,
+                      child: AnimatedContainer(
+                        duration: const Duration(milliseconds: 100),
+                        width: _isDragging ? 6 : 4,
+                        height: thumbHeight,
+                        decoration: BoxDecoration(
+                          color: _isDragging
+                              ? colorScheme.primary
+                              : colorScheme.onSurface.withOpacity(0.3),
+                          borderRadius: BorderRadius.circular(3),
+                        ),
+                      ),
+                    ),
+                  ],
+                );
+              },
+            ),
+          ),
+        ),
+
+        // The letter popup bubble
+        if (_isDragging && _currentLetter.isNotEmpty)
+          Positioned(
+            right: 48,
+            top: _dragPosition - 28,
+            child: Material(
+              elevation: 4,
+              color: colorScheme.primaryContainer,
+              borderRadius: BorderRadius.circular(8),
+              child: Container(
+                width: 56,
+                height: 56,
+                alignment: Alignment.center,
+                child: Text(
+                  _currentLetter,
+                  style: TextStyle(
+                    color: colorScheme.onPrimaryContainer,
+                    fontSize: 28,
+                    fontWeight: FontWeight.bold,
+                  ),
+                ),
+              ),
+            ),
+          ),
+      ],
+    );
+  }
+}

lib/widgets/player/chapters_panel.dart

@@ -0,0 +1,179 @@
+import 'package:flutter/material.dart';
+import '../../providers/music_assistant_provider.dart';
+import '../../models/media_item.dart' show Audiobook, Chapter;
+import '../../theme/design_tokens.dart';
+import '../common/empty_state.dart';
+import '../../l10n/app_localizations.dart';
+
+/// Panel that displays audiobook chapters for navigation
+class ChaptersPanel extends StatelessWidget {
+  final MusicAssistantProvider maProvider;
+  final Audiobook? audiobook;
+  final Color textColor;
+  final Color primaryColor;
+  final Color backgroundColor;
+  final double topPadding;
+  final VoidCallback onClose;
+
+  const ChaptersPanel({
+    super.key,
+    required this.maProvider,
+    required this.audiobook,
+    required this.textColor,
+    required this.primaryColor,
+    required this.backgroundColor,
+    required this.topPadding,
+    required this.onClose,
+  });
+
+  String _formatDuration(int seconds) {
+    final duration = Duration(seconds: seconds);
+    final hours = duration.inHours;
+    final minutes = duration.inMinutes % 60;
+    final secs = duration.inSeconds % 60;
+
+    if (hours > 0) {
+      return '${hours}:${minutes.toString().padLeft(2, '0')}:${secs.toString().padLeft(2, '0')}';
+    }
+    return '${minutes}:${secs.toString().padLeft(2, '0')}';
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final chapters = audiobook?.chapters ?? [];
+    final currentChapterIndex = maProvider.getCurrentChapterIndex();
+
+    return Container(
+      color: backgroundColor,
+      child: Column(
+        children: [
+          // Header
+          Container(
+            padding: EdgeInsets.only(top: topPadding + 4, left: 4, right: 16),
+            child: Row(
+              children: [
+                IconButton(
+                  icon: Icon(Icons.arrow_back_rounded, color: textColor, size: IconSizes.md),
+                  onPressed: onClose,
+                  padding: Spacing.paddingAll12,
+                ),
+                const Spacer(),
+                Text(
+                  S.of(context)!.chapters,
+                  style: TextStyle(
+                    color: textColor,
+                    fontSize: 18,
+                    fontWeight: FontWeight.w600,
+                  ),
+                ),
+                const Spacer(),
+                // Placeholder for symmetry
+                const SizedBox(width: 48),
+              ],
+            ),
+          ),
+
+          // Chapters list
+          Expanded(
+            child: chapters.isEmpty
+                ? _buildEmptyState(context)
+                : _buildChaptersList(chapters, currentChapterIndex),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildEmptyState(BuildContext context) {
+    return EmptyState.custom(
+      context: context,
+      icon: Icons.bookmark_outline_rounded,
+      title: S.of(context)!.noChapters,
+      subtitle: S.of(context)!.noChapterInfo,
+    );
+  }
+
+  Widget _buildChaptersList(List<Chapter> chapters, int currentChapterIndex) {
+    return ListView.builder(
+      padding: Spacing.paddingH8,
+      cacheExtent: 500,
+      addAutomaticKeepAlives: false,
+      addRepaintBoundaries: false,
+      itemCount: chapters.length,
+      itemBuilder: (context, index) {
+        final chapter = chapters[index];
+        final isCurrentChapter = index == currentChapterIndex;
+        final isPastChapter = index < currentChapterIndex;
+
+        return RepaintBoundary(
+          child: Opacity(
+            opacity: isPastChapter ? 0.5 : 1.0,
+            child: Container(
+              margin: EdgeInsets.symmetric(vertical: Spacing.xxs),
+              decoration: BoxDecoration(
+                color: isCurrentChapter ? primaryColor.withOpacity(0.15) : Colors.transparent,
+                borderRadius: BorderRadius.circular(Radii.md),
+              ),
+              child: ListTile(
+                dense: true,
+                leading: Container(
+                  width: 44,
+                  height: 44,
+                  decoration: BoxDecoration(
+                    color: isCurrentChapter
+                        ? primaryColor.withOpacity(0.2)
+                        : textColor.withOpacity(0.1),
+                    borderRadius: BorderRadius.circular(Radii.sm),
+                  ),
+                  child: Center(
+                    child: Text(
+                      '${index + 1}',
+                      style: TextStyle(
+                        color: isCurrentChapter ? primaryColor : textColor.withOpacity(0.6),
+                        fontSize: 14,
+                        fontWeight: FontWeight.w600,
+                      ),
+                    ),
+                  ),
+                ),
+                title: Text(
+                  chapter.title,
+                  style: TextStyle(
+                    color: isCurrentChapter ? primaryColor : textColor,
+                    fontSize: 14,
+                    fontWeight: isCurrentChapter ? FontWeight.w600 : FontWeight.normal,
+                  ),
+                  maxLines: 2,
+                  overflow: TextOverflow.ellipsis,
+                ),
+                subtitle: Text(
+                        _formatDuration(chapter.positionMs ~/ 1000),
+                        style: TextStyle(
+                          color: textColor.withOpacity(0.5),
+                          fontSize: 12,
+                        ),
+                      ),
+                trailing: isCurrentChapter
+                    ? Icon(Icons.play_arrow_rounded, color: primaryColor, size: 20)
+                    : null,
+                onTap: () => _seekToChapter(index),
+              ),
+            ),
+          ),
+        );
+      },
+    );
+  }
+
+  void _seekToChapter(int chapterIndex) {
+    final player = maProvider.selectedPlayer;
+    if (player == null || audiobook == null) return;
+
+    final chapters = audiobook!.chapters;
+    if (chapters == null || chapterIndex >= chapters.length) return;
+
+    final chapter = chapters[chapterIndex];
+    // Seek to the chapter's start position (positionMs is in milliseconds)
+    maProvider.seek(player.playerId, (chapter.positionMs / 1000).round());
+  }
+}

lib/widgets/player/device_selector_bar.dart

@@ -1,5 +1,6 @@
 import 'package:flutter/material.dart';
-import '../../theme/design_tokens.dart';
+import '../../l10n/app_localizations.dart';
+import 'mini_player_content.dart';
 
 /// A compact device selector bar shown when no track is playing
 class DeviceSelectorBar extends StatelessWidget {
@@ -15,6 +16,7 @@ class DeviceSelectorBar extends StatelessWidget {
   final GestureDragStartCallback? onHorizontalDragStart;
   final GestureDragUpdateCallback? onHorizontalDragUpdate;
   final GestureDragEndCallback? onHorizontalDragEnd;
+  final VoidCallback? onPowerToggle;
 
   const DeviceSelectorBar({
     super.key,
@@ -30,10 +32,13 @@ class DeviceSelectorBar extends StatelessWidget {
     this.onHorizontalDragStart,
     this.onHorizontalDragUpdate,
     this.onHorizontalDragEnd,
+    this.onPowerToggle,
   });
 
   @override
   Widget build(BuildContext context) {
+    final swipeHint = hasMultiplePlayers ? S.of(context)!.swipeToSwitchDevice : null;
+
     return GestureDetector(
       onHorizontalDragStart: hasMultiplePlayers ? onHorizontalDragStart : null,
       onHorizontalDragUpdate: hasMultiplePlayers ? onHorizontalDragUpdate : null,
@@ -52,50 +57,21 @@ class DeviceSelectorBar extends StatelessWidget {
               children: [
                 // Peek player content (shows when dragging)
                 if (slideOffset.abs() > 0.01 && peekPlayer != null)
-                  _buildPeekContent(),
+                  _buildPeekContent(context, swipeHint),
 
                 // Current player content
-                Transform.translate(
-                  offset: Offset(slideOffset * width, 0),
-                  child: Padding(
-                    padding: Spacing.paddingH16,
-                    child: Row(
-                      children: [
-                        Icon(
-                          _getPlayerIcon(selectedPlayer.name),
-                          color: textColor,
-                          size: IconSizes.md,
-                        ),
-                        Spacing.hGap12,
-                        Expanded(
-                          child: Column(
-                            mainAxisAlignment: MainAxisAlignment.center,
-                            crossAxisAlignment: CrossAxisAlignment.start,
-                            children: [
-                              Text(
-                                selectedPlayer.name,
-                                style: TextStyle(
-                                  color: textColor,
-                                  fontSize: 16,
-                                  fontWeight: FontWeight.w500,
-                                ),
-                                maxLines: 1,
-                                overflow: TextOverflow.ellipsis,
-                              ),
-                              if (hasMultiplePlayers)
-                                Text(
-                                  'Swipe to switch device',
-                                  style: TextStyle(
-                                    color: textColor.withOpacity(0.6),
-                                    fontSize: 12,
-                                  ),
-                                ),
-                            ],
-                          ),
-                        ),
-                      ],
-                    ),
-                  ),
+                MiniPlayerContent(
+                  primaryText: selectedPlayer.name,
+                  secondaryText: swipeHint,
+                  imageUrl: null,
+                  playerName: selectedPlayer.name,
+                  backgroundColor: backgroundColor,
+                  textColor: textColor,
+                  width: width,
+                  slideOffset: slideOffset,
+                  isHint: swipeHint != null,
+                  onPowerToggle: onPowerToggle,
+                  isPoweredOn: selectedPlayer.powered,
                 ),
               ],
             ),
@@ -106,7 +82,7 @@ class DeviceSelectorBar extends StatelessWidget {
   }
 
   /// Build peek player content that slides in from the edge
-  Widget _buildPeekContent() {
+  Widget _buildPeekContent(BuildContext context, String? swipeHint) {
     final isFromRight = slideOffset < 0;
     final peekProgress = slideOffset.abs();
 
@@ -117,61 +93,17 @@ class DeviceSelectorBar extends StatelessWidget {
 
     return Transform.translate(
       offset: Offset(peekBaseOffset, 0),
-      child: Padding(
-        padding: Spacing.paddingH16,
-        child: Row(
-          children: [
-            Icon(
-              _getPlayerIcon(peekPlayer.name),
-              color: textColor,
-              size: IconSizes.md,
-            ),
-            Spacing.hGap12,
-            Expanded(
-              child: Column(
-                mainAxisAlignment: MainAxisAlignment.center,
-                crossAxisAlignment: CrossAxisAlignment.start,
-                children: [
-                  Text(
-                    peekPlayer.name,
-                    style: TextStyle(
-                      color: textColor,
-                      fontSize: 16,
-                      fontWeight: FontWeight.w500,
-                    ),
-                    maxLines: 1,
-                    overflow: TextOverflow.ellipsis,
-                  ),
-                  if (hasMultiplePlayers)
-                    Text(
-                      'Swipe to switch device',
-                      style: TextStyle(
-                        color: textColor.withOpacity(0.6),
-                        fontSize: 12,
-                      ),
-                    ),
-                ],
-              ),
-            ),
-          ],
-        ),
+      child: MiniPlayerContent(
+        primaryText: peekPlayer.name,
+        secondaryText: swipeHint,
+        imageUrl: null,
+        playerName: peekPlayer.name,
+        backgroundColor: backgroundColor,
+        textColor: textColor,
+        width: width,
+        slideOffset: 0, // No additional slide - Transform handles positioning
+        isHint: swipeHint != null,
       ),
     );
   }
-
-  /// Get appropriate icon for player based on name
-  IconData _getPlayerIcon(String playerName) {
-    final nameLower = playerName.toLowerCase();
-    if (nameLower.contains('phone') || nameLower.contains('ensemble')) {
-      return Icons.phone_android_rounded;
-    } else if (nameLower.contains('group')) {
-      return Icons.speaker_group_rounded;
-    } else if (nameLower.contains('tv') || nameLower.contains('television')) {
-      return Icons.tv_rounded;
-    } else if (nameLower.contains('cast') || nameLower.contains('chromecast')) {
-      return Icons.cast_rounded;
-    } else {
-      return Icons.speaker_rounded;
-    }
-  }
 }

lib/widgets/player/mini_player_content.dart

@@ -0,0 +1,290 @@
+import 'package:flutter/material.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+
+/// Shared constants for mini player layout
+class MiniPlayerLayout {
+  static const double height = 72.0;
+  static const double artSize = 72.0;
+  static const double textLeftOffset = 10.0; // Gap between art and text
+  static const double textLeft = artSize + textLeftOffset; // 82px
+  // 3-line layout: track, artist, player
+  static const double primaryTop = 9.0;
+  static const double secondaryTop = 26.0;
+  static const double tertiaryTop = 46.0;
+  // 2-line layout (evenly spaced): player name, hint
+  // Height 72 / 3 = 24px spacing. Line 1 center at 24, Line 2 center at 48
+  static const double primaryTop2Line = 14.0; // 24 - (18/2) = 15, adjusted to 14
+  static const double secondaryTop2Line = 40.0; // raised slightly from 42
+  static const double textRightPadding = 12.0;
+  static const double powerButtonSize = 40.0; // Power button tap area
+  static const double iconSize = 28.0;
+  static const double iconOpacity = 0.4;
+  static const double secondaryTextOpacity = 0.6;
+  static const double primaryFontSize = 16.0; // 3-line playing mode
+  static const double primaryFontSize2Line = 18.0; // larger for 2-line off mode
+  static const double secondaryFontSize = 14.0;
+  static const double tertiaryFontSize = 14.0;
+  static const FontWeight primaryFontWeight = FontWeight.w500;
+}
+
+/// Unified mini player content widget used by:
+/// - DeviceSelectorBar (non-playing state)
+/// - ExpandablePlayer collapsed state (playing state)
+/// - Peek content during swipe gestures
+class MiniPlayerContent extends StatelessWidget {
+  /// Primary text line (track name or device name)
+  final String primaryText;
+
+  /// Secondary text line (artist name or "Swipe to switch device")
+  /// If null, primary text will be vertically centered
+  final String? secondaryText;
+
+  /// Tertiary text line (player name when playing)
+  /// If provided, uses 3-line layout; if null, uses centered 2-line layout
+  final String? tertiaryText;
+
+  /// Album art URL - if null, shows device icon
+  final String? imageUrl;
+
+  /// Player name for icon selection when no image
+  final String playerName;
+
+  /// Background color for the content area
+  final Color backgroundColor;
+
+  /// Text color
+  final Color textColor;
+
+  /// Width of the content area
+  final double width;
+
+  /// Horizontal slide offset for swipe animation (-1 to 1)
+  final double slideOffset;
+
+  /// Whether secondary text is a hint (shows lightbulb icon)
+  final bool isHint;
+
+  /// Whether to show the progress bar overlay (for playing state)
+  final bool showProgress;
+
+  /// Progress value 0.0 to 1.0 (only used if showProgress is true)
+  final double progress;
+
+  /// Callback for power button tap (only shown in 2-line mode when provided)
+  final VoidCallback? onPowerToggle;
+
+  /// Whether the player is currently powered on
+  final bool isPoweredOn;
+
+  const MiniPlayerContent({
+    super.key,
+    required this.primaryText,
+    this.secondaryText,
+    this.tertiaryText,
+    this.imageUrl,
+    required this.playerName,
+    required this.backgroundColor,
+    required this.textColor,
+    required this.width,
+    this.slideOffset = 0.0,
+    this.isHint = false,
+    this.showProgress = false,
+    this.progress = 0.0,
+    this.onPowerToggle,
+    this.isPoweredOn = true,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final hasSecondaryLine = secondaryText != null && secondaryText!.isNotEmpty;
+    final hasTertiaryLine = tertiaryText != null && tertiaryText!.isNotEmpty;
+    final is2LineMode = !hasTertiaryLine;
+    final showPowerButton = is2LineMode && onPowerToggle != null;
+    final slidePixels = slideOffset * width;
+
+    // Use 3-line layout when tertiary exists, 2-line centered otherwise
+    final primaryTop = hasTertiaryLine ? MiniPlayerLayout.primaryTop : MiniPlayerLayout.primaryTop2Line;
+    final secondaryTop = hasTertiaryLine ? MiniPlayerLayout.secondaryTop : MiniPlayerLayout.secondaryTop2Line;
+
+    // Calculate right padding (extra space for power button in 2-line mode)
+    final rightPadding = showPowerButton
+        ? MiniPlayerLayout.powerButtonSize + 8.0
+        : MiniPlayerLayout.textRightPadding;
+
+    // Darkened background for icon area (matches DeviceSelectorBar)
+    final iconAreaBackground = Color.lerp(backgroundColor, Colors.black, 0.15)!;
+
+    // Font size for primary text (larger in 2-line mode)
+    final primaryFontSize = is2LineMode
+        ? MiniPlayerLayout.primaryFontSize2Line
+        : MiniPlayerLayout.primaryFontSize;
+
+    return SizedBox(
+      width: width,
+      height: MiniPlayerLayout.height,
+      child: Stack(
+        clipBehavior: Clip.hardEdge,
+        children: [
+          // Progress bar background (only for playing state)
+          if (showProgress && progress > 0)
+            Positioned(
+              left: MiniPlayerLayout.artSize + slidePixels,
+              top: 0,
+              bottom: 0,
+              width: (width - MiniPlayerLayout.artSize) * progress,
+              child: Container(color: backgroundColor),
+            ),
+
+          // Art / Icon area - centered vertically
+          Positioned(
+            left: slidePixels,
+            top: (MiniPlayerLayout.height - MiniPlayerLayout.artSize) / 2,
+            child: SizedBox(
+              width: MiniPlayerLayout.artSize,
+              height: MiniPlayerLayout.artSize,
+              child: imageUrl != null
+                  ? CachedNetworkImage(
+                      imageUrl: imageUrl!,
+                      fit: BoxFit.cover,
+                      memCacheWidth: 256,
+                      memCacheHeight: 256,
+                      fadeInDuration: Duration.zero,
+                      fadeOutDuration: Duration.zero,
+                      placeholder: (_, __) => _buildIconArea(iconAreaBackground),
+                      errorWidget: (_, __, ___) => _buildIconArea(iconAreaBackground),
+                    )
+                  : _buildIconArea(iconAreaBackground),
+            ),
+          ),
+
+          // Primary text line
+          Positioned(
+            left: MiniPlayerLayout.textLeft + slidePixels,
+            top: hasSecondaryLine
+                ? primaryTop
+                : (MiniPlayerLayout.height - primaryFontSize) / 2,
+            right: rightPadding - slidePixels,
+            child: Text(
+              primaryText,
+              style: TextStyle(
+                color: textColor,
+                fontSize: primaryFontSize,
+                fontWeight: MiniPlayerLayout.primaryFontWeight,
+              ),
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+            ),
+          ),
+
+          // Secondary text line (with optional hint icon)
+          if (hasSecondaryLine)
+            Positioned(
+              left: MiniPlayerLayout.textLeft + slidePixels,
+              top: secondaryTop,
+              right: rightPadding - slidePixels,
+              child: isHint
+                  ? Row(
+                      mainAxisSize: MainAxisSize.min,
+                      children: [
+                        Icon(
+                          Icons.lightbulb_outline,
+                          size: 14,
+                          color: textColor.withOpacity(MiniPlayerLayout.secondaryTextOpacity),
+                        ),
+                        const SizedBox(width: 4),
+                        Flexible(
+                          child: Text(
+                            secondaryText!,
+                            style: TextStyle(
+                              color: textColor.withOpacity(MiniPlayerLayout.secondaryTextOpacity),
+                              fontSize: MiniPlayerLayout.secondaryFontSize,
+                            ),
+                            maxLines: 1,
+                            overflow: TextOverflow.ellipsis,
+                          ),
+                        ),
+                      ],
+                    )
+                  : Text(
+                      secondaryText!,
+                      style: TextStyle(
+                        color: textColor.withOpacity(MiniPlayerLayout.secondaryTextOpacity),
+                        fontSize: MiniPlayerLayout.secondaryFontSize,
+                      ),
+                      maxLines: 1,
+                      overflow: TextOverflow.ellipsis,
+                    ),
+            ),
+
+          // Tertiary text line (player name, only for 3-line layout)
+          if (hasTertiaryLine)
+            Positioned(
+              left: MiniPlayerLayout.textLeft + slidePixels,
+              top: MiniPlayerLayout.tertiaryTop,
+              right: MiniPlayerLayout.textRightPadding - slidePixels,
+              child: Text(
+                tertiaryText!,
+                style: TextStyle(
+                  color: textColor,
+                  fontSize: MiniPlayerLayout.tertiaryFontSize,
+                ),
+                maxLines: 1,
+                overflow: TextOverflow.ellipsis,
+              ),
+            ),
+
+          // Power button (only for 2-line mode when callback provided)
+          // Matches PlayerCard power button style
+          if (showPowerButton)
+            Positioned(
+              right: 8.0 - slidePixels,
+              top: 0,
+              bottom: 0,
+              child: Center(
+                child: IconButton(
+                  onPressed: onPowerToggle,
+                  icon: Icon(
+                    Icons.power_settings_new_rounded,
+                    color: isPoweredOn ? textColor : textColor.withOpacity(0.5),
+                    size: 20,
+                  ),
+                  padding: EdgeInsets.zero,
+                  constraints: const BoxConstraints(),
+                ),
+              ),
+            ),
+        ],
+      ),
+    );
+  }
+
+  /// Build the icon area with device-appropriate icon
+  Widget _buildIconArea(Color background) {
+    return Container(
+      color: background,
+      child: Center(
+        child: Icon(
+          _getPlayerIcon(playerName),
+          color: textColor.withOpacity(MiniPlayerLayout.iconOpacity),
+          size: MiniPlayerLayout.iconSize,
+        ),
+      ),
+    );
+  }
+
+  /// Get appropriate icon based on player name
+  static IconData _getPlayerIcon(String playerName) {
+    final nameLower = playerName.toLowerCase();
+    if (nameLower.contains('phone') || nameLower.contains('ensemble') || nameLower.contains('mobile')) {
+      return Icons.phone_android_rounded;
+    } else if (nameLower.contains('group') || nameLower.contains('sync') || nameLower.contains('all')) {
+      return Icons.speaker_group_rounded;
+    } else if (nameLower.contains('tv') || nameLower.contains('television')) {
+      return Icons.tv_rounded;
+    } else if (nameLower.contains('cast') || nameLower.contains('chromecast')) {
+      return Icons.cast_rounded;
+    } else {
+      return Icons.speaker_rounded;
+    }
+  }
+}

lib/widgets/player/player_card.dart

@@ -0,0 +1,525 @@
+import 'dart:async';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import '../../providers/music_assistant_provider.dart';
+import '../../theme/design_tokens.dart';
+import '../../l10n/app_localizations.dart';
+import '../../services/debug_logger.dart';
+import '../../services/settings_service.dart';
+
+final _volumeLogger = DebugLogger();
+
+/// A player card that matches the mini player's visual style.
+/// Used in the player reveal overlay when swiping down or tapping the device button.
+/// Supports horizontal swipe to adjust volume with a two-tone overlay.
+class PlayerCard extends StatefulWidget {
+  final dynamic player;
+  final dynamic trackInfo;
+  final String? albumArtUrl;
+  final bool isSelected;
+  final bool isPlaying;
+  final bool isGrouped;
+  final Color backgroundColor;
+  final Color textColor;
+  final VoidCallback onTap;
+  final VoidCallback? onLongPress;
+  final VoidCallback? onPlayPause;
+  final VoidCallback? onSkipNext;
+  final VoidCallback? onPower;
+  final ValueChanged<double>? onVolumeChange;
+  final ValueChanged<bool>? onPrecisionModeChanged;
+
+  // Pastel yellow for grouped players
+  static const Color groupBorderColor = Color(0xFFFFF59D);
+
+  // Precision mode settings
+  static const int precisionTriggerMs = 800; // Hold still for 800ms to enter precision mode
+  static const double precisionStillnessThreshold = 5.0; // Max pixels of movement considered "still"
+  static const double precisionSensitivity = 0.1; // 10x more precise (full swipe = 10% change)
+
+  // PERF Phase 4: Pre-cached BoxShadow to avoid allocation per frame
+  static const BoxShadow cardShadow = BoxShadow(
+    color: Color(0x33000000), // 20% black
+    blurRadius: 8,
+    offset: Offset(0, 2),
+  );
+
+  const PlayerCard({
+    super.key,
+    required this.player,
+    this.trackInfo,
+    this.albumArtUrl,
+    required this.isSelected,
+    required this.isPlaying,
+    this.isGrouped = false,
+    required this.backgroundColor,
+    required this.textColor,
+    required this.onTap,
+    this.onLongPress,
+    this.onPlayPause,
+    this.onSkipNext,
+    this.onPower,
+    this.onVolumeChange,
+    this.onPrecisionModeChanged,
+  });
+
+  @override
+  State<PlayerCard> createState() => _PlayerCardState();
+}
+
+class _PlayerCardState extends State<PlayerCard> {
+  bool _isDraggingVolume = false;
+  double _dragVolumeLevel = 0.0;
+  double _cardWidth = 0.0;
+  int _lastVolumeUpdateTime = 0;
+  int _lastDragEndTime = 0; // Track when last drag ended for consecutive swipes
+  bool _hasLocalVolumeOverride = false; // True if we've set volume locally
+  static const int _volumeThrottleMs = 150; // Only send volume updates every 150ms
+  static const int _precisionThrottleMs = 50; // Faster updates in precision mode
+  static const int _consecutiveSwipeWindowMs = 5000; // 5 seconds - extended window for consecutive swipes
+
+  // Precision mode state
+  bool _inPrecisionMode = false;
+  Timer? _precisionTimer;
+  Offset? _lastDragPosition;
+  double _lastLocalX = 0.0; // Last local X position during drag (for precision mode)
+  bool _precisionModeEnabled = true; // From settings
+  double _precisionZoomCenter = 0.0; // Volume level when precision mode started
+  double _precisionStartX = 0.0; // Finger X position when precision mode started
+
+  @override
+  void initState() {
+    super.initState();
+    _loadPrecisionModeSetting();
+  }
+
+  Future<void> _loadPrecisionModeSetting() async {
+    final enabled = await SettingsService.getVolumePrecisionMode();
+    if (mounted) {
+      setState(() {
+        _precisionModeEnabled = enabled;
+      });
+    }
+  }
+
+  @override
+  void dispose() {
+    _precisionTimer?.cancel();
+    super.dispose();
+  }
+
+  void _enterPrecisionMode() {
+    if (_inPrecisionMode) return;
+    HapticFeedback.mediumImpact(); // Vibrate to indicate precision mode
+    setState(() {
+      _inPrecisionMode = true;
+      _precisionZoomCenter = _dragVolumeLevel; // Capture current volume as zoom center
+      _precisionStartX = _lastLocalX; // Capture finger position at entry
+    });
+    widget.onPrecisionModeChanged?.call(true);
+    _volumeLogger.debug(
+      'PRECISION_MODE [${widget.player.name}]: ENTERED at ${(_precisionZoomCenter * 100).round()}%',
+      context: 'Volume',
+    );
+  }
+
+  void _exitPrecisionMode() {
+    _precisionTimer?.cancel();
+    _precisionTimer = null;
+    if (!_inPrecisionMode) return;
+    setState(() {
+      _inPrecisionMode = false;
+    });
+    widget.onPrecisionModeChanged?.call(false);
+    _volumeLogger.debug(
+      'PRECISION_MODE [${widget.player.name}]: EXITED',
+      context: 'Volume',
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    // Match mini player dimensions
+    const double cardHeight = Dimensions.miniPlayerHeight;
+    const double artSize = cardHeight;
+    const double borderRadius = Radii.xl; // 16px - same as mini player
+
+    // Colors for volume overlay (same as mini player progress bar)
+    final filledColor = widget.backgroundColor;
+    final unfilledColor = Color.lerp(widget.backgroundColor, Colors.black, 0.3)!;
+
+    // RepaintBoundary isolates this card's repaint from parent transform animations
+    // This improves performance during the staggered reveal animation
+    return RepaintBoundary(
+      child: LayoutBuilder(
+      builder: (context, constraints) {
+        _cardWidth = constraints.maxWidth;
+
+        return GestureDetector(
+          onTap: _isDraggingVolume ? null : widget.onTap,
+          onLongPress: _isDraggingVolume ? null : widget.onLongPress,
+          onHorizontalDragStart: _onDragStart,
+          onHorizontalDragUpdate: _onDragUpdate,
+          onHorizontalDragEnd: _onDragEnd,
+          onHorizontalDragCancel: _onDragCancel,
+          // Use Stack to render border ON TOP of content, preventing album art clipping
+          child: Stack(
+            children: [
+              // Main card content (hidden when dragging volume)
+              if (!_isDraggingVolume)
+                _buildCardContent(cardHeight, artSize, borderRadius),
+
+              // Volume overlay (shown when dragging)
+              if (_isDraggingVolume)
+                Container(
+                  height: cardHeight,
+                  decoration: BoxDecoration(
+                    color: unfilledColor,
+                    borderRadius: BorderRadius.circular(borderRadius),
+                    // PERF Phase 4: Use pre-cached static BoxShadow
+                    boxShadow: const [PlayerCard.cardShadow],
+                  ),
+                  clipBehavior: Clip.antiAlias,
+                  child: Align(
+                    alignment: Alignment.centerLeft,
+                    child: FractionallySizedBox(
+                      widthFactor: _dragVolumeLevel.clamp(0.0, 1.0),
+                      heightFactor: 1.0,
+                      child: Container(
+                        decoration: BoxDecoration(
+                          color: filledColor,
+                          borderRadius: BorderRadius.only(
+                            topLeft: Radius.circular(borderRadius),
+                            bottomLeft: Radius.circular(borderRadius),
+                          ),
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+
+              // Border overlay - renders ON TOP to prevent clipping by album art
+              if (widget.isGrouped)
+                Positioned.fill(
+                  child: Container(
+                    decoration: BoxDecoration(
+                      borderRadius: BorderRadius.circular(borderRadius),
+                      border: Border.all(color: PlayerCard.groupBorderColor, width: 1.5),
+                    ),
+                  ),
+                ),
+            ],
+          ),
+        );
+      },
+      ),
+    );
+  }
+
+  Widget _buildCardContent(double cardHeight, double artSize, double borderRadius) {
+    return Container(
+      height: cardHeight,
+      decoration: BoxDecoration(
+        color: widget.backgroundColor,
+        borderRadius: BorderRadius.circular(borderRadius),
+        // PERF Phase 4: Use pre-cached static BoxShadow
+        boxShadow: const [PlayerCard.cardShadow],
+      ),
+      clipBehavior: Clip.antiAlias,
+      child: Row(
+        children: [
+          // Album art or speaker icon - same size for consistent text alignment
+          SizedBox(
+            width: artSize,
+            height: artSize,
+            child: widget.albumArtUrl != null
+                ? CachedNetworkImage(
+                    imageUrl: widget.albumArtUrl!,
+                    fit: BoxFit.cover,
+                    memCacheWidth: 128,
+                    memCacheHeight: 128,
+                    fadeInDuration: Duration.zero,
+                    fadeOutDuration: Duration.zero,
+                    placeholder: (_, __) => _buildSpeakerIcon(),
+                    errorWidget: (_, __, ___) => _buildSpeakerIcon(),
+                  )
+                : _buildSpeakerIcon(),
+          ),
+
+          // Player info
+          Expanded(
+            child: Padding(
+              padding: const EdgeInsets.symmetric(horizontal: 12),
+              child: Column(
+                mainAxisAlignment: MainAxisAlignment.center,
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  // Player name
+                  Row(
+                    children: [
+                      // Status indicator
+                      Container(
+                        width: 8,
+                        height: 8,
+                        margin: const EdgeInsets.only(right: 8),
+                        decoration: BoxDecoration(
+                          shape: BoxShape.circle,
+                          color: _getStatusColor(),
+                        ),
+                      ),
+                      Expanded(
+                        child: Text(
+                          widget.player.name,
+                          style: TextStyle(
+                            color: widget.textColor,
+                            fontSize: 16,
+                            fontWeight: FontWeight.w500,
+                            fontFamily: 'Roboto',
+                            decoration: TextDecoration.none,
+                          ),
+                          maxLines: 1,
+                          overflow: TextOverflow.ellipsis,
+                        ),
+                      ),
+                    ],
+                  ),
+                  const SizedBox(height: 2),
+                  // Track name or status
+                  Text(
+                    _getSubtitle(context),
+                    style: TextStyle(
+                      color: widget.textColor.withOpacity(0.6),
+                      fontSize: 14,
+                      fontFamily: 'Roboto',
+                      decoration: TextDecoration.none,
+                    ),
+                    maxLines: 1,
+                    overflow: TextOverflow.ellipsis,
+                  ),
+                ],
+              ),
+            ),
+          ),
+
+          // Transport controls - compact sizing to align with mini player
+          // Play/Pause and Next only shown when powered with content
+          if (widget.player.available && widget.player.powered && widget.trackInfo != null) ...[
+            // Play/Pause - slight nudge right
+            // Touch target increased to 44dp for accessibility (icon remains 28)
+            Transform.translate(
+              offset: const Offset(3, 0),
+              child: SizedBox(
+                width: 44,
+                height: 44,
+                child: IconButton(
+                  icon: Icon(
+                    widget.isPlaying ? Icons.pause_rounded : Icons.play_arrow_rounded,
+                    color: widget.textColor,
+                    size: 28,
+                  ),
+                  onPressed: widget.onPlayPause,
+                  padding: EdgeInsets.zero,
+                ),
+              ),
+            ),
+            // Skip next - nudged right to close gap with power
+            Transform.translate(
+              offset: const Offset(6, 0),
+              child: IconButton(
+                icon: Icon(
+                  Icons.skip_next_rounded,
+                  color: widget.textColor,
+                  size: 28,
+                ),
+                onPressed: widget.onSkipNext,
+                padding: EdgeInsets.zero,
+                constraints: const BoxConstraints(),
+              ),
+            ),
+          ],
+          // Power button - smallest
+          if (widget.player.available)
+            IconButton(
+              icon: Icon(
+                Icons.power_settings_new_rounded,
+                color: widget.player.powered ? widget.textColor : widget.textColor.withOpacity(0.5),
+                size: 20,
+              ),
+              onPressed: widget.onPower,
+              padding: EdgeInsets.zero,
+              constraints: const BoxConstraints(),
+            ),
+
+          const SizedBox(width: 4),
+        ],
+      ),
+    );
+  }
+
+  void _onDragStart(DragStartDetails details) {
+    // For consecutive swipes, use local volume (API may not have updated player state yet)
+    final now = DateTime.now().millisecondsSinceEpoch;
+    final timeSinceLastDrag = now - _lastDragEndTime;
+    final isWithinWindow = timeSinceLastDrag < _consecutiveSwipeWindowMs;
+
+    // Use local volume if:
+    // 1. We have a local override (we've swiped before) AND
+    // 2. We're within the consecutive swipe window (5 seconds)
+    // Otherwise, read fresh from player state
+    final useLocalVolume = _hasLocalVolumeOverride && isWithinWindow;
+
+    final playerVolume = (widget.player.volumeLevel ?? 0).toDouble() / 100.0;
+    final startVolume = useLocalVolume
+        ? _dragVolumeLevel // Continue from where last swipe ended
+        : playerVolume; // Fresh from player
+
+    _volumeLogger.debug(
+      'DRAG_START [${widget.player.name}]: '
+      'useLocal=$useLocalVolume, hasOverride=$_hasLocalVolumeOverride, '
+      'inWindow=$isWithinWindow (${timeSinceLastDrag}ms ago), '
+      'localVol=${(_dragVolumeLevel * 100).round()}%, '
+      'playerVol=${(playerVolume * 100).round()}%, '
+      'startVol=${(startVolume * 100).round()}%',
+      context: 'Volume',
+    );
+
+    setState(() {
+      _isDraggingVolume = true;
+      _dragVolumeLevel = startVolume;
+    });
+    _lastDragPosition = details.globalPosition;
+    HapticFeedback.lightImpact();
+  }
+
+  void _onDragUpdate(DragUpdateDetails details) {
+    if (!_isDraggingVolume || _cardWidth <= 0) return;
+
+    // Track local X position for precision mode
+    _lastLocalX = details.localPosition.dx;
+
+    // Check for stillness to trigger precision mode (only if enabled in settings)
+    final currentPosition = details.globalPosition;
+    if (_precisionModeEnabled && _lastDragPosition != null) {
+      final movement = (currentPosition - _lastDragPosition!).distance;
+
+      if (movement < PlayerCard.precisionStillnessThreshold) {
+        // Finger is still - start precision timer if not already running
+        if (_precisionTimer == null && !_inPrecisionMode) {
+          _precisionTimer = Timer(
+            Duration(milliseconds: PlayerCard.precisionTriggerMs),
+            _enterPrecisionMode,
+          );
+        }
+      } else {
+        // Finger moved - cancel timer (but don't exit precision mode if already in it)
+        _precisionTimer?.cancel();
+        _precisionTimer = null;
+      }
+    }
+    _lastDragPosition = currentPosition;
+
+    double newVolume;
+
+    if (_inPrecisionMode) {
+      // PRECISION MODE: Movement from entry point maps to zoomed range
+      // Full card width of movement = precisionSensitivity (10%) change
+      // e.g., at 40% center: moving full card right = 50%, full card left = 30%
+      final offsetX = details.localPosition.dx - _precisionStartX;
+      final normalizedOffset = offsetX / _cardWidth; // -1.0 to +1.0 range
+      final volumeChange = normalizedOffset * PlayerCard.precisionSensitivity;
+      newVolume = (_precisionZoomCenter + volumeChange).clamp(0.0, 1.0);
+    } else {
+      // NORMAL MODE: Delta-based movement (full card width = 100%)
+      final dragDelta = details.delta.dx;
+      final volumeDelta = dragDelta / _cardWidth;
+      newVolume = (_dragVolumeLevel + volumeDelta).clamp(0.0, 1.0);
+    }
+
+    // Always update visual
+    if ((newVolume - _dragVolumeLevel).abs() > 0.001) {
+      setState(() {
+        _dragVolumeLevel = newVolume;
+      });
+
+      // Throttle API calls to prevent flooding (faster in precision mode)
+      final now = DateTime.now().millisecondsSinceEpoch;
+      final throttleMs = _inPrecisionMode ? _precisionThrottleMs : _volumeThrottleMs;
+      if (now - _lastVolumeUpdateTime >= throttleMs) {
+        _lastVolumeUpdateTime = now;
+        widget.onVolumeChange?.call(newVolume);
+      }
+    }
+  }
+
+  void _onDragEnd(DragEndDetails details) {
+    // Send final volume on release
+    _volumeLogger.debug(
+      'DRAG_END [${widget.player.name}]: '
+      'finalVol=${(_dragVolumeLevel * 100).round()}%, '
+      'precisionMode=$_inPrecisionMode',
+      context: 'Volume',
+    );
+    widget.onVolumeChange?.call(_dragVolumeLevel);
+    _lastDragEndTime = DateTime.now().millisecondsSinceEpoch; // Track for consecutive swipes
+    _hasLocalVolumeOverride = true; // Mark that we have a local volume value
+    _exitPrecisionMode();
+    _lastDragPosition = null;
+    setState(() {
+      _isDraggingVolume = false;
+    });
+    HapticFeedback.lightImpact();
+  }
+
+  void _onDragCancel() {
+    _exitPrecisionMode();
+    _lastDragPosition = null;
+    setState(() {
+      _isDraggingVolume = false;
+    });
+  }
+
+  Widget _buildSpeakerIcon() {
+    // Darker shade of the card background to match album art square
+    final iconBgColor = Color.lerp(widget.backgroundColor, Colors.black, 0.15)!;
+    return Container(
+      color: iconBgColor,
+      child: Center(
+        child: Icon(
+          Icons.speaker_rounded,
+          color: widget.textColor.withOpacity(0.4),
+          size: 28,
+        ),
+      ),
+    );
+  }
+
+  Color _getStatusColor() {
+    if (!widget.player.available) {
+      return Colors.grey.withOpacity(0.5);
+    }
+    if (!widget.player.powered) {
+      return Colors.grey;
+    }
+    if (widget.isPlaying) {
+      return Colors.green;
+    }
+    if (widget.trackInfo != null) {
+      return Colors.orange; // Has content but paused
+    }
+    return Colors.grey.shade400; // Idle
+  }
+
+  String _getSubtitle(BuildContext context) {
+    if (!widget.player.available) {
+      return S.of(context)!.playerStateUnavailable;
+    }
+    if (!widget.player.powered) {
+      return S.of(context)!.playerStateOff;
+    }
+    if (widget.trackInfo != null) {
+      return widget.trackInfo.name ?? S.of(context)!.playerStateIdle;
+    }
+    return S.of(context)!.playerStateIdle;
+  }
+}

lib/widgets/player/player_controls.dart

@@ -55,24 +55,29 @@ class PlayerControls extends StatelessWidget {
       mainAxisAlignment: isExpanded ? MainAxisAlignment.center : MainAxisAlignment.end,
       children: [
         // Shuffle (expanded only)
-        if (isExpanded)
-          Opacity(
-            opacity: expandedElementsOpacity,
-            child: _buildSecondaryButton(
-              icon: Icons.shuffle_rounded,
-              color: shuffle == true ? primaryColor : textColor.withOpacity(0.5),
-              onPressed: isLoadingQueue ? null : onToggleShuffle,
-            ),
+        // GPU PERF: Use color alpha instead of Opacity to avoid saveLayer
+        if (isExpanded && expandedElementsOpacity > 0.1)
+          _buildSecondaryButton(
+            icon: Icons.shuffle_rounded,
+            // Fix: compute final opacity once to avoid multiplicative opacity bug
+            color: shuffle == true
+                ? primaryColor.withOpacity(expandedElementsOpacity)
+                : textColor.withOpacity(0.5 * expandedElementsOpacity),
+            onPressed: isLoadingQueue ? null : onToggleShuffle,
           ),
         if (isExpanded) SizedBox(width: _lerpDouble(0, 20, t)),
 
         // Previous
-        _buildControlButton(
-          icon: Icons.skip_previous_rounded,
-          color: textColor,
-          size: skipButtonSize,
-          onPressed: onPrevious,
-          useAnimation: isExpanded,
+        Semantics(
+          button: true,
+          label: 'Previous track',
+          child: _buildControlButton(
+            icon: Icons.skip_previous_rounded,
+            color: textColor,
+            size: skipButtonSize,
+            onPressed: onPrevious,
+            useAnimation: isExpanded,
+          ),
         ),
         SizedBox(width: _lerpDouble(0, 20, t)),
 
@@ -81,26 +86,29 @@ class PlayerControls extends StatelessWidget {
         SizedBox(width: _lerpDouble(0, 20, t)),
 
         // Next
-        _buildControlButton(
-          icon: Icons.skip_next_rounded,
-          color: textColor,
-          size: skipButtonSize,
-          onPressed: onNext,
-          useAnimation: isExpanded,
+        Semantics(
+          button: true,
+          label: 'Next track',
+          child: _buildControlButton(
+            icon: Icons.skip_next_rounded,
+            color: textColor,
+            size: skipButtonSize,
+            onPressed: onNext,
+            useAnimation: isExpanded,
+          ),
         ),
 
         // Repeat (expanded only)
+        // GPU PERF: Use color alpha instead of Opacity to avoid saveLayer
         if (isExpanded) SizedBox(width: _lerpDouble(0, 20, t)),
-        if (isExpanded)
-          Opacity(
-            opacity: expandedElementsOpacity,
-            child: _buildSecondaryButton(
-              icon: repeatMode == 'one' ? Icons.repeat_one_rounded : Icons.repeat_rounded,
-              color: repeatMode != null && repeatMode != 'off'
-                  ? primaryColor
-                  : textColor.withOpacity(0.5),
-              onPressed: isLoadingQueue ? null : onCycleRepeat,
-            ),
+        if (isExpanded && expandedElementsOpacity > 0.1)
+          _buildSecondaryButton(
+            icon: repeatMode == 'one' ? Icons.repeat_one_rounded : Icons.repeat_rounded,
+            // Fix: compute final opacity once to avoid multiplicative opacity bug
+            color: (repeatMode != null && repeatMode != 'off')
+                ? primaryColor.withOpacity(expandedElementsOpacity)
+                : textColor.withOpacity(0.5 * expandedElementsOpacity),
+            onPressed: isLoadingQueue ? null : onCycleRepeat,
           ),
       ],
     );
@@ -153,21 +161,26 @@ class PlayerControls extends StatelessWidget {
     final bgColor = Color.lerp(Colors.transparent, primaryColor, progress);
     final iconColor = Color.lerp(textColor, backgroundColor, progress);
 
-    return GestureDetector(
-      onLongPress: onStop,
-      child: Container(
-        width: playButtonContainerSize,
-        height: playButtonContainerSize,
-        decoration: BoxDecoration(
-          color: bgColor,
-          shape: BoxShape.circle,
-        ),
-        child: IconButton(
-          icon: Icon(isPlaying ? Icons.pause_rounded : Icons.play_arrow_rounded),
-          color: iconColor,
-          iconSize: playButtonSize,
-          onPressed: onPlayPause,
-          padding: EdgeInsets.zero,
+    return Semantics(
+      button: true,
+      label: isPlaying ? 'Pause' : 'Play',
+      hint: 'Long press to stop',
+      child: GestureDetector(
+        onLongPress: onStop,
+        child: Container(
+          width: playButtonContainerSize,
+          height: playButtonContainerSize,
+          decoration: BoxDecoration(
+            color: bgColor,
+            shape: BoxShape.circle,
+          ),
+          child: IconButton(
+            icon: Icon(isPlaying ? Icons.pause_rounded : Icons.play_arrow_rounded),
+            color: iconColor,
+            iconSize: playButtonSize,
+            onPressed: onPlayPause,
+            padding: EdgeInsets.zero,
+          ),
         ),
       ),
     );

lib/widgets/player/player_reveal_overlay.dart

@@ -0,0 +1,534 @@
+import 'dart:async';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:provider/provider.dart';
+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';
+import 'player_card.dart';
+
+/// Overlay that reveals all available players with a staggered slide-up animation.
+/// Triggered by swiping down on the mini player or tapping the device button.
+class PlayerRevealOverlay extends StatefulWidget {
+  final VoidCallback onDismiss;
+  final double miniPlayerBottom; // Bottom position of mini player
+  final double miniPlayerHeight;
+  final bool showOnboardingHints; // Show additional hints for first-time users
+
+  const PlayerRevealOverlay({
+    super.key,
+    required this.onDismiss,
+    required this.miniPlayerBottom,
+    required this.miniPlayerHeight,
+    this.showOnboardingHints = false,
+  });
+
+  @override
+  State<PlayerRevealOverlay> createState() => PlayerRevealOverlayState();
+}
+
+class PlayerRevealOverlayState extends State<PlayerRevealOverlay>
+    with TickerProviderStateMixin {
+  late AnimationController _revealController;
+  late Animation<double> _revealAnimation;
+  late Animation<double> _backdropAnimation;
+
+  Timer? _refreshTimer;
+
+  // Track vertical drag for dismissal
+  double _dragOffset = 0;
+  bool _isDragging = false;
+
+  // Scroll controller for when player list overflows
+  final ScrollController _scrollController = ScrollController();
+  bool _isScrollable = false;
+
+  // Cache extracted colors per player for per-device accent colors
+  final Map<String, ColorScheme?> _playerColors = {};
+
+  // Hint system
+  bool _showHints = true;
+
+  // PERF: Pre-cached static BoxShadow to avoid allocation per frame
+  static const BoxShadow _cardShadow = BoxShadow(
+    color: Color(0x33000000), // 20% black
+    blurRadius: 8,
+    offset: Offset(0, 2),
+  );
+
+  @override
+  void initState() {
+    super.initState();
+
+    // Load hint settings
+    SettingsService.getShowHints().then((value) {
+      if (mounted) setState(() => _showHints = value);
+    });
+
+    _revealController = AnimationController(
+      vsync: this,
+    );
+
+    // Quick smooth animation with subtle overshoot
+    _revealAnimation = CurvedAnimation(
+      parent: _revealController,
+      curve: Curves.easeOutCubic,
+      reverseCurve: Curves.easeInCubic,
+    );
+
+    _backdropAnimation = CurvedAnimation(
+      parent: _revealController,
+      curve: const Interval(0.0, 0.4, curve: Curves.easeOut),
+    );
+
+    // Preload all player track info and extract colors
+    _preloadColorsForPlayers();
+
+    // Start reveal animation
+    _revealController.duration = const Duration(milliseconds: 200);
+    _revealController.forward();
+
+    // Auto-refresh player data
+    _refreshTimer = Timer.periodic(Timings.playerPollingInterval, (_) {
+      if (mounted) {
+        final provider = context.read<MusicAssistantProvider>();
+        provider.refreshPlayers();
+        provider.preloadAllPlayerTracks().then((_) => _preloadColorsForPlayers());
+      }
+    });
+  }
+
+  /// Extract accent colors from album art for each player
+  Future<void> _preloadColorsForPlayers() async {
+    final maProvider = context.read<MusicAssistantProvider>();
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+
+    await maProvider.preloadAllPlayerTracks();
+
+    final players = maProvider.availablePlayers;
+    for (final player in players) {
+      if (_playerColors.containsKey(player.playerId)) continue;
+
+      final track = maProvider.getCachedTrackForPlayer(player.playerId);
+      if (track == null) continue;
+
+      final imageUrl = maProvider.getImageUrl(track, size: 128);
+      if (imageUrl == null) continue;
+
+      try {
+        final imageProvider = NetworkImage(imageUrl);
+        final schemes = await PaletteHelper.extractColorSchemes(imageProvider);
+        if (mounted && schemes != null) {
+          final colorScheme = isDark ? schemes.$2 : schemes.$1;
+          setState(() {
+            _playerColors[player.playerId] = colorScheme;
+          });
+        }
+      } catch (_) {
+        // Ignore color extraction errors
+      }
+    }
+  }
+
+  @override
+  void dispose() {
+    _revealController.dispose();
+    _refreshTimer?.cancel();
+    _scrollController.dispose();
+    super.dispose();
+  }
+
+  /// Animate reveal (called from parent)
+  void reveal() {
+    _revealController.duration = const Duration(milliseconds: 200);
+    _revealController.forward();
+  }
+
+  /// Animate dismissal and call callback when done
+  void dismiss() {
+    // 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) {
+        bounceFired = true;
+        GlobalPlayerOverlay.triggerBounce();
+      }
+    }
+
+    _revealController.duration = const Duration(milliseconds: 150);
+    _revealController.addListener(checkBounce);
+    _revealController.reverse().then((_) {
+      _revealController.removeListener(checkBounce);
+      widget.onDismiss();
+    });
+  }
+
+  /// Check if scroll is at top (or not scrollable)
+  bool get _isAtTop {
+    if (!_isScrollable) return true;
+    if (!_scrollController.hasClients) return true;
+    return _scrollController.offset <= 0;
+  }
+
+  void _handleVerticalDragUpdate(DragUpdateDetails details) {
+    final delta = details.primaryDelta ?? 0;
+
+    // If scrollable and not at top, let scroll handle it
+    if (_isScrollable && !_isAtTop) {
+      // Scroll the list
+      if (_scrollController.hasClients) {
+        final newOffset = _scrollController.offset - delta;
+        _scrollController.jumpTo(newOffset.clamp(0.0, _scrollController.position.maxScrollExtent));
+      }
+      return;
+    }
+
+    // At top: check if trying to scroll down (view more) or dismiss
+    if (_isScrollable && delta < 0 && _scrollController.hasClients) {
+      // Swiping up (delta negative) = scroll down to see more players
+      final newOffset = _scrollController.offset - delta;
+      _scrollController.jumpTo(newOffset.clamp(0.0, _scrollController.position.maxScrollExtent));
+      return;
+    }
+
+    // Only process dismiss gesture when swiping DOWN (positive delta = finger moving down)
+    // Ignore swipe up when not scrollable - cards should stay fixed
+    if (delta <= 0) return;
+
+    // Swiping down = dismiss gesture
+    setState(() {
+      _isDragging = true;
+      _dragOffset += delta;
+    });
+  }
+
+  void _handleVerticalDragEnd(DragEndDetails details) {
+    final velocity = details.primaryVelocity ?? 0;
+
+    // If not dragging (was scrolling), don't dismiss
+    if (!_isDragging) return;
+
+    // Dismiss if dragged down enough or with enough velocity
+    if (_dragOffset > 100 || 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;
+      });
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final themeProvider = context.watch<ThemeProvider>();
+    final colorScheme = Theme.of(context).colorScheme;
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+
+    // PERF Phase 4: Pre-compute hint colors outside animation loop
+    final hintColor = colorScheme.onSurface.withOpacity(0.7);
+
+    // Back gesture is handled at GlobalPlayerOverlay level
+    return Consumer<MusicAssistantProvider>(
+      builder: (context, maProvider, child) {
+        final allPlayers = maProvider.availablePlayers;
+        final selectedPlayer = maProvider.selectedPlayer;
+        final currentTrack = maProvider.currentTrack;
+
+        // Filter out the selected player - it's already shown in the mini player
+        final players = allPlayers
+            .where((p) => p.playerId != selectedPlayer?.playerId)
+            .toList();
+
+        // Default card colors - used when player doesn't have extracted colors
+        final defaultBgColor = colorScheme.primaryContainer;
+        final defaultTextColor = colorScheme.onPrimaryContainer;
+
+        // Calculate total stack height for animation
+        const cardHeight = 64.0;
+        const cardSpacing = 12.0;
+        final totalStackHeight = players.length * cardHeight + (players.length - 1) * cardSpacing;
+
+        // Calculate max available height (80% of screen minus mini player area)
+        final screenHeight = MediaQuery.of(context).size.height;
+        final statusBarHeight = MediaQuery.of(context).padding.top;
+        final bottomPadding = widget.miniPlayerBottom + widget.miniPlayerHeight + 20;
+        final maxListHeight = (screenHeight - statusBarHeight - bottomPadding) * 0.8;
+
+        // Determine if scrolling is needed
+        final needsScroll = totalStackHeight > maxListHeight;
+        // Update scrollable state (used by gesture handlers)
+        WidgetsBinding.instance.addPostFrameCallback((_) {
+          if (_isScrollable != needsScroll) {
+            _isScrollable = needsScroll;
+          }
+        });
+
+        // PERF Phase 4: Pre-compute player card data OUTSIDE AnimatedBuilder
+        // This avoids re-gathering player data every animation frame
+        final playerDataList = players.map((player) {
+          final isPlaying = player.state == 'playing';
+          final playerTrack = maProvider.getCachedTrackForPlayer(player.playerId);
+          String? albumArtUrl;
+          if (playerTrack != null && player.available && player.powered) {
+            albumArtUrl = maProvider.getImageUrl(playerTrack, size: 128);
+          }
+          final playerColorScheme = _playerColors[player.playerId];
+          final cardBgColor = playerColorScheme?.primaryContainer ?? defaultBgColor;
+          final cardTextColor = playerColorScheme?.onPrimaryContainer ?? defaultTextColor;
+          final isGrouped = maProvider.isPlayerManuallySynced(player.playerId);
+
+          return _PlayerCardData(
+            player: player,
+            playerTrack: playerTrack,
+            albumArtUrl: albumArtUrl,
+            isPlaying: isPlaying,
+            isGrouped: isGrouped,
+            cardBgColor: cardBgColor,
+            cardTextColor: cardTextColor,
+          );
+        }).toList();
+
+        return AnimatedBuilder(
+          animation: _revealAnimation,
+          builder: (context, child) {
+            final t = _revealAnimation.value;
+
+            return Stack(
+              children: [
+                // Backdrop - tap to dismiss (darkness handled by GlobalPlayerOverlay)
+                Positioned.fill(
+                  child: GestureDetector(
+                    onTap: dismiss,
+                    behavior: HitTestBehavior.opaque,
+                    child: const SizedBox.expand(),
+                  ),
+                ),
+
+                // Player cards - positioned above mini player
+                Positioned(
+                  left: 12,
+                  right: 12,
+                  bottom: widget.miniPlayerBottom + widget.miniPlayerHeight + 8 - _dragOffset,
+                  child: GestureDetector(
+                    onVerticalDragUpdate: _handleVerticalDragUpdate,
+                    onVerticalDragEnd: _handleVerticalDragEnd,
+                    child: Column(
+                      mainAxisSize: MainAxisSize.min,
+                      children: [
+                        // Hint above player list - different for onboarding vs regular use
+                        // Onboarding: show first-time hint (how to select)
+                        // Regular: show sync hint (tap and hold to sync)
+                        if (players.isNotEmpty && (_showHints || widget.showOnboardingHints))
+                          Builder(
+                            builder: (context) {
+                              // Calculate slide offset to match the topmost card
+                              const baseOffset = 80.0;
+                              final hintDistanceToTravel = baseOffset + (players.length * (cardHeight + cardSpacing));
+                              final hintSlideOffset = hintDistanceToTravel * (1.0 - t);
+
+                              // Show different hint for onboarding vs regular use
+                              final isOnboarding = widget.showOnboardingHints;
+
+                              // PERF Phase 4: Use pre-computed hintColor
+                              Widget buildHintRow(IconData icon, String text) {
+                                return Row(
+                                  mainAxisSize: MainAxisSize.min,
+                                  children: [
+                                    Icon(
+                                      icon,
+                                      size: 18,
+                                      color: hintColor,
+                                    ),
+                                    const SizedBox(width: 6),
+                                    Text(
+                                      text,
+                                      style: TextStyle(
+                                        color: hintColor,
+                                        fontSize: 16,
+                                        fontWeight: FontWeight.w500,
+                                      ),
+                                    ),
+                                  ],
+                                );
+                              }
+
+                              return Transform.translate(
+                                offset: Offset(0, hintSlideOffset),
+                                child: Padding(
+                                  padding: const EdgeInsets.only(bottom: 12),
+                                  child: Material(
+                                    type: MaterialType.transparency,
+                                    child: isOnboarding
+                                        ? buildHintRow(Icons.touch_app_outlined, S.of(context)!.selectPlayerHint)
+                                        : Column(
+                                            mainAxisSize: MainAxisSize.min,
+                                            children: [
+                                              buildHintRow(Icons.lightbulb_outline, S.of(context)!.holdToSync),
+                                              const SizedBox(height: 4),
+                                              buildHintRow(Icons.lightbulb_outline, S.of(context)!.swipeToAdjustVolume),
+                                            ],
+                                          ),
+                                  ),
+                                ),
+                              );
+                            },
+                          ),
+                        // Build player cards - scrollable when overflow, otherwise static
+                        // Using ListView.builder for many players: only builds visible items
+                        // This significantly improves animation performance with 10+ players
+                        // PERF Phase 4: Use pre-computed playerDataList
+                        if (needsScroll)
+                          ConstrainedBox(
+                            constraints: BoxConstraints(maxHeight: maxListHeight),
+                            child: ListView.builder(
+                              controller: _scrollController,
+                              physics: const ClampingScrollPhysics(),
+                              itemCount: playerDataList.length,
+                              // Fixed height per item for optimal scroll performance
+                              itemExtent: cardHeight + cardSpacing,
+                              itemBuilder: (context, index) {
+                                final data = playerDataList[index];
+
+                                // Animation: slide from behind mini player
+                                // Only calculate for items that will be built (visible ones)
+                                const baseOffset = 80.0;
+                                final reverseIndex = playerDataList.length - 1 - index;
+                                final distanceToTravel = baseOffset + (reverseIndex * (cardHeight + cardSpacing));
+                                final slideOffset = distanceToTravel * (1.0 - t);
+
+                                return Transform.translate(
+                                  offset: Offset(0, slideOffset),
+                                  child: Padding(
+                                    padding: const EdgeInsets.only(bottom: cardSpacing),
+                                    child: PlayerCard(
+                                      player: data.player,
+                                      trackInfo: data.playerTrack,
+                                      albumArtUrl: data.albumArtUrl,
+                                      isSelected: false,
+                                      isPlaying: data.isPlaying,
+                                      isGrouped: data.isGrouped,
+                                      backgroundColor: data.cardBgColor,
+                                      textColor: data.cardTextColor,
+                                      onTap: () {
+                                        HapticFeedback.mediumImpact();
+                                        maProvider.selectPlayer(data.player);
+                                        dismiss();
+                                      },
+                                      onLongPress: () {
+                                        HapticFeedback.mediumImpact();
+                                        maProvider.togglePlayerSync(data.player.playerId);
+                                      },
+                                      onPlayPause: () {
+                                        if (data.isPlaying) {
+                                          maProvider.pausePlayer(data.player.playerId);
+                                        } else {
+                                          maProvider.resumePlayer(data.player.playerId);
+                                        }
+                                      },
+                                      onSkipNext: () => maProvider.nextTrack(data.player.playerId),
+                                      onPower: () => maProvider.togglePower(data.player.playerId),
+                                      onVolumeChange: (volume) => maProvider.setVolume(data.player.playerId, (volume * 100).round()),
+                                    ),
+                                  ),
+                                );
+                              },
+                            ),
+                          )
+                        else
+                        // Non-scrollable list for when players fit
+                        // PERF Phase 4: Use pre-computed playerDataList
+                        ...List.generate(playerDataList.length, (index) {
+                          final data = playerDataList[index];
+
+                          // Animation: all cards start hidden behind mini player
+                          // and fan out to their final positions with spring physics
+                          const baseOffset = 80.0;
+                          final reverseIndex = playerDataList.length - 1 - index;
+                          final distanceToTravel = baseOffset + (reverseIndex * (cardHeight + cardSpacing));
+
+                          // Use the elastic animation value directly (already has bounce)
+                          final slideOffset = distanceToTravel * (1.0 - t);
+
+                          return Transform.translate(
+                            offset: Offset(0, slideOffset),
+                            child: Padding(
+                              padding: const EdgeInsets.only(bottom: 12),
+                              child: PlayerCard(
+                                player: data.player,
+                                trackInfo: data.playerTrack,
+                                albumArtUrl: data.albumArtUrl,
+                                isSelected: false,
+                                isPlaying: data.isPlaying,
+                                isGrouped: data.isGrouped,
+                                backgroundColor: data.cardBgColor,
+                                textColor: data.cardTextColor,
+                                onTap: () {
+                                  HapticFeedback.mediumImpact();
+                                  maProvider.selectPlayer(data.player);
+                                  dismiss();
+                                },
+                                onLongPress: () {
+                                  HapticFeedback.mediumImpact();
+                                  maProvider.togglePlayerSync(data.player.playerId);
+                                },
+                                onPlayPause: () {
+                                  if (data.isPlaying) {
+                                    maProvider.pausePlayer(data.player.playerId);
+                                  } else {
+                                    maProvider.resumePlayer(data.player.playerId);
+                                  }
+                                },
+                                onSkipNext: () => maProvider.nextTrack(data.player.playerId),
+                                onPower: () => maProvider.togglePower(data.player.playerId),
+                                onVolumeChange: (volume) => maProvider.setVolume(data.player.playerId, (volume * 100).round()),
+                              ),
+                            ),
+                          );
+                        }),
+                      ],
+                    ),
+                  ),
+                ),
+              ],
+            );
+          },
+        );
+      },
+    );
+  }
+}
+
+/// PERF Phase 4: Pre-computed player card data to avoid gathering per animation frame
+class _PlayerCardData {
+  final dynamic player;
+  final dynamic playerTrack;
+  final String? albumArtUrl;
+  final bool isPlaying;
+  final bool isGrouped;
+  final Color cardBgColor;
+  final Color cardTextColor;
+
+  const _PlayerCardData({
+    required this.player,
+    required this.playerTrack,
+    required this.albumArtUrl,
+    required this.isPlaying,
+    required this.isGrouped,
+    required this.cardBgColor,
+    required this.cardTextColor,
+  });
+}

lib/widgets/player/player_widgets.dart

@@ -1,6 +1,7 @@
 /// Player widget components extracted from expandable_player.dart
 library player_widgets;
 
+export 'chapters_panel.dart';
 export 'device_selector_bar.dart';
 export 'player_controls.dart';
 export 'queue_panel.dart';

lib/widgets/player/queue_panel.dart

@@ -1,12 +1,19 @@
+import 'dart:async';
+
 import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
 import 'package:cached_network_image/cached_network_image.dart';
 import '../../providers/music_assistant_provider.dart';
 import '../../models/player.dart';
 import '../../theme/design_tokens.dart';
 import '../common/empty_state.dart';
 
-/// Panel that displays the current playback queue
-class QueuePanel extends StatelessWidget {
+/// Panel that displays the current playback queue with drag-to-reorder
+/// and swipe-left-to-delete functionality.
+///
+/// Uses custom AnimatedList implementation instead of great_list_view
+/// to avoid grey screen bugs (ReorderableListView) and drag duplication bugs (great_list_view).
+class QueuePanel extends StatefulWidget {
   final MusicAssistantProvider maProvider;
   final PlayerQueue? queue;
   final bool isLoading;
@@ -16,6 +23,10 @@ class QueuePanel extends StatelessWidget {
   final double topPadding;
   final VoidCallback onClose;
   final VoidCallback onRefresh;
+  final ValueChanged<bool>? onDraggingChanged;
+  final VoidCallback? onSwipeStart;
+  final ValueChanged<double>? onSwipeUpdate; // dx delta from start
+  final void Function(double velocity, double totalDx)? onSwipeEnd; // velocity and total displacement
 
   const QueuePanel({
     super.key,
@@ -28,146 +39,713 @@ class QueuePanel extends StatelessWidget {
     required this.topPadding,
     required this.onClose,
     required this.onRefresh,
+    this.onDraggingChanged,
+    this.onSwipeStart,
+    this.onSwipeUpdate,
+    this.onSwipeEnd,
   });
 
   @override
-  Widget build(BuildContext context) {
-    return Container(
-      color: backgroundColor,
-      child: Column(
-        children: [
-          // Header
-          Container(
-            padding: EdgeInsets.only(top: topPadding + 4, left: 4, right: 16),
-            child: Row(
-              children: [
-                IconButton(
-                  icon: Icon(Icons.arrow_back_rounded, color: textColor, size: IconSizes.md),
-                  onPressed: onClose,
-                  padding: Spacing.paddingAll12,
-                ),
-                const Spacer(),
-                Text(
-                  'Queue',
-                  style: TextStyle(
-                    color: textColor,
-                    fontSize: 18,
-                    fontWeight: FontWeight.w600,
-                  ),
-                ),
-                const Spacer(),
-                IconButton(
-                  icon: Icon(Icons.refresh_rounded, color: textColor.withOpacity(0.7), size: IconSizes.sm),
-                  onPressed: onRefresh,
-                  padding: Spacing.paddingAll12,
-                ),
-              ],
-            ),
-          ),
+  State<QueuePanel> createState() => _QueuePanelState();
+}
 
-          // Queue content
-          Expanded(
-            child: isLoading
-                ? Center(child: CircularProgressIndicator(color: primaryColor))
-                : queue == null || queue!.items.isEmpty
-                    ? _buildEmptyState()
-                    : _buildQueueList(),
-          ),
-        ],
+class _QueuePanelState extends State<QueuePanel> {
+  List<QueueItem> _items = [];
+  final GlobalKey _stackKey = GlobalKey();
+
+  // Drag state
+  int? _dragIndex;
+  int? _dragStartIndex;
+  double _dragY = 0; // Y position of dragged item relative to Stack
+  double _dragStartY = 0; // Y position when drag started (global)
+  double _dragOffsetInItem = 0; // Offset of touch point within item
+  QueueItem? _dragItem;
+  double _itemHeight = 64.0;
+  bool _pendingReorder = false; // True while waiting for API confirmation
+  Timer? _pendingReorderTimer;
+
+  // Optimistic update for tap-to-skip
+  int? _optimisticCurrentIndex;
+
+  // Swipe-to-close tracking (raw pointer events to bypass gesture arena)
+  Offset? _swipeStart;
+  Offset? _swipeLast;
+  int? _swipeLastTime; // milliseconds since epoch
+  bool _isSwiping = false;
+  bool _swipeLocked = false; // Lock direction once established
+  static const _swipeMinDistance = 8.0; // Min distance to start tracking (reduced for responsiveness)
+  static const _edgeDeadZone = 48.0; // Dead zone for Android back gesture (increased)
+
+  // Track last touch start position for edge detection in Dismissible
+  // Static so it persists across widget rebuilds
+  static double? _lastPointerDownX;
+  static double? _lastScreenWidth;
+
+  // Velocity tracking with multiple samples for smoother calculation
+  final List<_VelocitySample> _velocitySamples = [];
+  static const _maxVelocitySamples = 5;
+
+
+  @override
+  void initState() {
+    super.initState();
+    _items = List.from(widget.queue?.items ?? []);
+  }
+
+  @override
+  void didUpdateWidget(QueuePanel oldWidget) {
+    super.didUpdateWidget(oldWidget);
+
+    // Clear optimistic state when server catches up
+    if (_optimisticCurrentIndex != null) {
+      final serverIndex = widget.queue?.currentIndex;
+      if (serverIndex == _optimisticCurrentIndex) {
+        // Server caught up - clear optimistic state
+        _optimisticCurrentIndex = null;
+      }
+    }
+
+    // Don't update items while dragging or waiting for reorder confirmation
+    if (_dragIndex != null || _pendingReorder) return;
+
+    final newItems = widget.queue?.items ?? [];
+
+    // Only sync when player changes or item count changes (additions/deletions)
+    // Don't sync on order changes - trust our local order after user reorders
+    // This prevents stale server state from overwriting recent local changes
+    final playerChanged = widget.queue?.playerId != oldWidget.queue?.playerId;
+    final countChanged = newItems.length != _items.length;
+
+    if (playerChanged || countChanged) {
+      setState(() {
+        _items = List.from(newItems);
+      });
+    }
+  }
+
+  @override
+  void dispose() {
+    _pendingReorderTimer?.cancel();
+    super.dispose();
+  }
+
+  String _formatDuration(Duration? duration) {
+    if (duration == null) return '';
+    final totalSeconds = duration.inSeconds;
+    final minutes = totalSeconds ~/ 60;
+    final seconds = totalSeconds % 60;
+    return '$minutes:${seconds.toString().padLeft(2, '0')}';
+  }
+
+  void _handleDelete(QueueItem item, int index) async {
+    // Remove from local list - Dismissible handles the animation
+    setState(() {
+      _items.removeAt(index);
+    });
+
+    // Call API
+    final playerId = widget.queue?.playerId;
+    if (playerId != null) {
+      widget.maProvider.api?.queueCommandDeleteItem(playerId, item.queueItemId);
+    }
+  }
+
+  void _handleClearQueue() async {
+    final playerId = widget.queue?.playerId;
+    if (playerId == null) return;
+
+    // Optimistic update - clear local list
+    setState(() {
+      _items.clear();
+    });
+
+    // Call API
+    try {
+      await widget.maProvider.api?.queueCommandClear(playerId);
+    } catch (e) {
+      debugPrint('QueuePanel: Error clearing queue: $e');
+      // Refresh to restore if failed
+      widget.onRefresh();
+    }
+  }
+
+  void _resetSwipeState() {
+    _swipeStart = null;
+    _swipeLast = null;
+    _swipeLastTime = null;
+    _isSwiping = false;
+    _swipeLocked = false;
+    _velocitySamples.clear();
+    // NOTE: Don't reset _lastPointerDownX - it's needed by confirmDismiss
+    // which may be called after pointer up
+  }
+
+  /// Check if x position is in the edge dead zone (Android back gesture area)
+  static bool _isInEdgeZone(double x, double screenWidth) {
+    return x < _edgeDeadZone || x > screenWidth - _edgeDeadZone;
+  }
+
+  /// Check if last touch started in edge zone (for Dismissible to check)
+  static bool get lastTouchWasInEdgeZone {
+    if (_lastPointerDownX == null || _lastScreenWidth == null) return false;
+    return _isInEdgeZone(_lastPointerDownX!, _lastScreenWidth!);
+  }
+
+  /// Build an invisible edge absorber that blocks horizontal drags from triggering Dismissible
+  Widget _buildEdgeAbsorber({required bool left}) {
+    return Positioned(
+      left: left ? 0 : null,
+      right: left ? null : 0,
+      top: 0,
+      bottom: 0,
+      width: _edgeDeadZone,
+      child: GestureDetector(
+        behavior: HitTestBehavior.translucent,
+        onHorizontalDragStart: (_) {}, // Absorb horizontal drags
+        onHorizontalDragUpdate: (_) {},
+        onHorizontalDragEnd: (_) {},
       ),
     );
   }
 
-  Widget _buildEmptyState() {
-    return EmptyState.queue();
+  void _addVelocitySample(Offset position, int timeMs) {
+    _velocitySamples.add(_VelocitySample(position, timeMs));
+    if (_velocitySamples.length > _maxVelocitySamples) {
+      _velocitySamples.removeAt(0);
+    }
+  }
+
+  double _calculateAverageVelocity() {
+    if (_velocitySamples.length < 2) return 0.0;
+
+    // Use weighted average of recent samples (more recent = higher weight)
+    double totalVelocity = 0.0;
+    double totalWeight = 0.0;
+
+    for (int i = 1; i < _velocitySamples.length; i++) {
+      final prev = _velocitySamples[i - 1];
+      final curr = _velocitySamples[i];
+      final dt = curr.timeMs - prev.timeMs;
+      if (dt > 0 && dt < 100) { // Only use samples within 100ms
+        final dx = curr.position.dx - prev.position.dx;
+        final velocity = (dx / dt) * 1000; // px/s
+        final weight = i.toDouble(); // Later samples get higher weight
+        totalVelocity += velocity * weight;
+        totalWeight += weight;
+      }
+    }
+
+    return totalWeight > 0 ? totalVelocity / totalWeight : 0.0;
+  }
+
+  void _startDrag(int index, BuildContext itemContext, Offset globalPosition) {
+    if (_dragIndex != null) return;
+
+    // Clear any pending swipe state to prevent conflicts
+    _resetSwipeState();
+
+    final RenderBox itemBox = itemContext.findRenderObject() as RenderBox;
+    final Offset itemGlobalPos = itemBox.localToGlobal(Offset.zero);
+    _itemHeight = itemBox.size.height;
+
+    // Get Stack's global position for proper coordinate conversion
+    final stackBox = _stackKey.currentContext?.findRenderObject() as RenderBox?;
+    final stackGlobalPos = stackBox?.localToGlobal(Offset.zero) ?? Offset.zero;
+
+    // Calculate initial position relative to Stack
+    _dragY = itemGlobalPos.dy - stackGlobalPos.dy;
+    _dragStartY = globalPosition.dy;
+    // Remember where in the item the touch started (for smooth following)
+    _dragOffsetInItem = globalPosition.dy - itemGlobalPos.dy;
+
+    setState(() {
+      _dragIndex = index;
+      _dragStartIndex = index;
+      _dragItem = _items[index];
+    });
+
+    // Haptic feedback on drag start
+    HapticFeedback.mediumImpact();
+
+    // Notify parent that drag started
+    widget.onDraggingChanged?.call(true);
+  }
+
+  void _updateDragPointer(Offset globalPosition) {
+    if (_dragIndex == null) return;
+
+    // Get Stack's global position
+    final stackBox = _stackKey.currentContext?.findRenderObject() as RenderBox?;
+    final stackGlobalPos = stackBox?.localToGlobal(Offset.zero) ?? Offset.zero;
+
+    // Calculate overlay position relative to Stack, accounting for touch offset
+    _dragY = globalPosition.dy - stackGlobalPos.dy - _dragOffsetInItem;
+
+    // Calculate which index we're hovering over based on movement from start
+    final totalOffset = globalPosition.dy - _dragStartY;
+    final indexOffset = (totalOffset / _itemHeight).round();
+    final targetIndex = (_dragStartIndex! + indexOffset).clamp(0, _items.length - 1);
+
+    if (targetIndex != _dragIndex) {
+      // Reorder items in the list
+      setState(() {
+        final item = _items.removeAt(_dragIndex!);
+        _items.insert(targetIndex, item);
+        _dragIndex = targetIndex;
+      });
+      // Haptic feedback on each reorder
+      HapticFeedback.selectionClick();
+    } else {
+      // Just update position
+      setState(() {});
+    }
+  }
+
+  void _endDrag() async {
+    if (_dragIndex == null || _dragStartIndex == null) return;
+
+    final newIndex = _dragIndex!;
+    final originalIndex = _dragStartIndex!;
+    final item = _items[newIndex];
+    final positionChanged = originalIndex != newIndex;
+
+    // Cancel any existing timer to prevent stacking
+    _pendingReorderTimer?.cancel();
+
+    setState(() {
+      _dragIndex = null;
+      _dragStartIndex = null;
+      _dragItem = null;
+      // Block didUpdateWidget while waiting for server confirmation
+      if (positionChanged) _pendingReorder = true;
+    });
+
+    // Haptic feedback on drop
+    HapticFeedback.lightImpact();
+
+    // Notify parent that drag ended
+    widget.onDraggingChanged?.call(false);
+
+    // Call API if position changed
+    if (positionChanged) {
+      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');
+        } catch (e) {
+          debugPrint('QueuePanel: Move API error: $e');
+        }
+      } else {
+        debugPrint('QueuePanel: playerId is null, cannot move');
+      }
+      // Allow updates again after a delay for server state to propagate
+      _pendingReorderTimer = Timer(const Duration(milliseconds: 2000), () {
+        if (mounted) {
+          setState(() {
+            _pendingReorder = false;
+          });
+        }
+      });
+    }
+  }
+
+  void _cancelDrag() {
+    if (_dragStartIndex == null) return;
+
+    // Restore original position
+    if (_dragIndex != null && _dragIndex != _dragStartIndex) {
+      setState(() {
+        final item = _items.removeAt(_dragIndex!);
+        _items.insert(_dragStartIndex!, item);
+      });
+    }
+
+    setState(() {
+      _dragIndex = null;
+      _dragStartIndex = null;
+      _dragItem = null;
+    });
+
+    // Notify parent that drag ended
+    widget.onDraggingChanged?.call(false);
+  }
+
+  void _handleTapToSkip(QueueItem item, int index, bool isCurrentItem) async {
+    if (isCurrentItem) return;
+
+    final playerId = widget.queue?.playerId;
+    if (playerId == null) return;
+
+    // Optimistic update: immediately show tapped track as current
+    setState(() {
+      _optimisticCurrentIndex = index;
+    });
+
+    // Call API
+    try {
+      await widget.maProvider.api?.queueCommandPlayIndex(playerId, item.queueItemId);
+    } catch (e) {
+      debugPrint('QueuePanel: Error playing index: $e');
+    }
+
+    // Clear optimistic state after delay - server state will take over
+    await Future.delayed(const Duration(milliseconds: 1500));
+    if (mounted) {
+      setState(() {
+        _optimisticCurrentIndex = null;
+      });
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    // Use Listener for raw pointer events to bypass gesture arena
+    // This allows swipe-to-close to work even over ListView/Dismissible
+    return Listener(
+      onPointerDown: (event) {
+        // Store touch position for edge detection (used by Dismissible confirmDismiss)
+        // Use static variables so they persist across rebuilds
+        _lastPointerDownX = event.position.dx;
+        _lastScreenWidth = MediaQuery.of(context).size.width;
+
+        // Check if touch started in edge zone (Android back gesture area)
+        final startedInEdgeZone = _isInEdgeZone(event.position.dx, _lastScreenWidth!);
+
+        // Don't track swipe while dragging a queue item
+        if (_dragIndex == null && !startedInEdgeZone) {
+          _swipeStart = event.position;
+          _swipeLast = event.position;
+          _swipeLastTime = DateTime.now().millisecondsSinceEpoch;
+          _isSwiping = false;
+          _swipeLocked = false;
+          _velocitySamples.clear();
+          _addVelocitySample(event.position, _swipeLastTime!);
+        } else if (startedInEdgeZone) {
+          // Clear swipe state for edge touches
+          _swipeStart = null;
+        }
+      },
+      onPointerMove: (event) {
+        // Ignore swipes from edge zone (let Android back gesture handle it)
+        if (_swipeStart == null || _dragIndex != null) return;
+
+        final dx = event.position.dx - _swipeStart!.dx;
+        final dy = (event.position.dy - _swipeStart!.dy).abs();
+        final now = DateTime.now().millisecondsSinceEpoch;
+
+        // Track all move events for velocity calculation
+        _addVelocitySample(event.position, now);
+        _swipeLast = event.position;
+        _swipeLastTime = now;
+
+        // Once direction is locked, maintain it (prevents accidental cancellation)
+        if (_swipeLocked && _isSwiping) {
+          widget.onSwipeUpdate?.call(dx.clamp(0.0, double.infinity));
+          return;
+        }
+
+        // Check if this is a horizontal swipe (reduced tolerance: dx > dy * 1.2)
+        final isHorizontal = dx.abs() > _swipeMinDistance && dx.abs() > dy * 1.2;
+
+        if (isHorizontal && dx > 0) {
+          // Horizontal swipe right - close gesture
+          if (!_isSwiping) {
+            _isSwiping = true;
+            _swipeLocked = true; // Lock direction once swipe starts
+            widget.onSwipeStart?.call();
+          }
+          widget.onSwipeUpdate?.call(dx);
+        } else if (!_swipeLocked && dx.abs() > _swipeMinDistance) {
+          // Direction established as vertical - don't start swipe
+          _swipeLocked = true; // Lock as non-swipe
+        }
+      },
+      onPointerUp: (event) {
+        if (_isSwiping && _swipeStart != null) {
+          final velocity = _calculateAverageVelocity();
+          final totalDx = event.position.dx - _swipeStart!.dx;
+          widget.onSwipeEnd?.call(velocity, totalDx);
+        }
+        _resetSwipeState();
+      },
+      onPointerCancel: (_) {
+        if (_isSwiping) {
+          widget.onSwipeEnd?.call(0, 0); // Cancel - no action
+        }
+        _resetSwipeState();
+      },
+      child: Container(
+        color: widget.backgroundColor,
+        child: 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: widget.onClose,
+                    padding: Spacing.paddingAll12,
+                  ),
+                  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(
+              child: widget.isLoading
+                  ? Center(child: CircularProgressIndicator(color: widget.primaryColor))
+                  : widget.queue == null || _items.isEmpty
+                      ? EmptyState.queue(context: context)
+                      : Listener(
+                          // Capture pointer events anywhere while dragging
+                          onPointerMove: (event) {
+                            if (_dragIndex != null) {
+                              _updateDragPointer(event.position);
+                            }
+                          },
+                          onPointerUp: (event) {
+                            if (_dragIndex != null) {
+                              _endDrag();
+                            }
+                          },
+                          onPointerCancel: (event) {
+                            if (_dragIndex != null) {
+                              _cancelDrag();
+                            }
+                          },
+                          child: Stack(
+                            key: _stackKey,
+                            children: [
+                              _buildQueueList(),
+                              // Dragged item overlay
+                              if (_dragIndex != null && _dragItem != null)
+                                Positioned(
+                                  left: 8,
+                                  right: 8,
+                                  top: _dragY,
+                                  child: Material(
+                                    elevation: 8,
+                                    borderRadius: BorderRadius.circular(8),
+                                    child: _buildQueueItemContent(_dragItem!, _dragIndex!, false, false),
+                                  ),
+                                ),
+                              // Edge gesture absorbers - block horizontal drags from screen edges
+                              // This prevents Android back gesture from triggering Dismissible
+                              _buildEdgeAbsorber(left: true),
+                              _buildEdgeAbsorber(left: false),
+                            ],
+                          ),
+                        ),
+            ),
+          ],
+        ),
+      ),
+    );
   }
 
   Widget _buildQueueList() {
-    final currentIndex = queue!.currentIndex ?? 0;
-    final items = queue!.items;
+    // Use optimistic index if set, otherwise use server state
+    final currentIndex = _optimisticCurrentIndex ?? widget.queue!.currentIndex ?? 0;
 
     return ListView.builder(
+      key: const PageStorageKey('queue_list'),
       padding: Spacing.paddingH8,
-      cacheExtent: 500,
-      addAutomaticKeepAlives: false, // Items don't need individual keep-alive
-      addRepaintBoundaries: false, // We add RepaintBoundary manually
-      itemCount: items.length,
+      // Disable scrolling while dragging to prevent gesture conflict
+      physics: _dragIndex != null
+          ? const NeverScrollableScrollPhysics()
+          : const AlwaysScrollableScrollPhysics(),
+      itemCount: _items.length,
       itemBuilder: (context, index) {
-        final item = items[index];
+        final item = _items[index];
         final isCurrentItem = index == currentIndex;
         final isPastItem = index < currentIndex;
-        final imageUrl = maProvider.api?.getImageUrl(item.track, size: 80);
+        final isDragging = _dragIndex == index;
 
-        return RepaintBoundary(
-          child: Opacity(
-          opacity: isPastItem ? 0.5 : 1.0,
-          child: Container(
-            margin: EdgeInsets.symmetric(vertical: Spacing.xxs),
-            decoration: BoxDecoration(
-              color: isCurrentItem ? primaryColor.withOpacity(0.15) : Colors.transparent,
-              borderRadius: BorderRadius.circular(Radii.md),
-            ),
-            child: ListTile(
-              dense: true,
-              leading: ClipRRect(
-                borderRadius: BorderRadius.circular(Radii.sm),
-                child: SizedBox(
-                  width: 44,
-                  height: 44,
-                  child: imageUrl != null
-                      ? CachedNetworkImage(
-                          imageUrl: imageUrl,
-                          fit: BoxFit.cover,
-                          placeholder: (context, url) => Container(
-                            color: textColor.withOpacity(0.1),
-                            child: Icon(Icons.music_note, color: textColor.withOpacity(0.3), size: 20),
-                          ),
-                          errorWidget: (context, url, error) => Container(
-                            color: textColor.withOpacity(0.1),
-                            child: Icon(Icons.music_note, color: textColor.withOpacity(0.3), size: 20),
-                          ),
-                        )
-                      : Container(
-                          color: textColor.withOpacity(0.1),
-                          child: Icon(Icons.music_note, color: textColor.withOpacity(0.3), size: 20),
-                        ),
-                ),
-              ),
-              title: Text(
-                item.track.name,
-                style: TextStyle(
-                  color: isCurrentItem ? primaryColor : textColor,
-                  fontSize: 14,
-                  fontWeight: isCurrentItem ? FontWeight.w600 : FontWeight.normal,
-                ),
-                maxLines: 1,
-                overflow: TextOverflow.ellipsis,
-              ),
-              subtitle: item.track.artists != null && item.track.artists!.isNotEmpty
-                  ? Text(
-                      item.track.artists!.first.name,
-                      style: TextStyle(
-                        color: textColor.withOpacity(0.6),
-                        fontSize: 12,
-                      ),
-                      maxLines: 1,
-                      overflow: TextOverflow.ellipsis,
-                    )
-                  : null,
-              trailing: isCurrentItem
-                  ? Icon(Icons.play_arrow_rounded, color: primaryColor, size: 20)
-                  : null,
-              onTap: () {
-                // TODO: Jump to this track in queue
-                // Music Assistant API doesn't currently expose a skip_to_index or play_queue_item endpoint
-                // Would need to add API method like skipToQueueIndex(queueId, index) if MA supports it
-                // Alternative: Could use multiple next() calls but that's inefficient and unreliable
-              },
-            ),
-          ),
-          ),
+        return Opacity(
+          opacity: isDragging ? 0.3 : 1.0,
+          child: _buildDismissibleItem(item, index, isCurrentItem, isPastItem),
         );
       },
     );
   }
+
+  Widget _buildDismissibleItem(QueueItem item, int index, bool isCurrentItem, bool isPastItem) {
+    return Dismissible(
+      key: ValueKey(item.queueItemId),
+      direction: DismissDirection.endToStart,
+      background: Container(
+        alignment: Alignment.centerRight,
+        padding: const EdgeInsets.only(right: 20),
+        decoration: BoxDecoration(
+          color: Colors.red.shade700,
+          borderRadius: BorderRadius.zero,
+        ),
+        child: const Icon(Icons.delete_outline, color: Colors.white, size: 24),
+      ),
+      confirmDismiss: (direction) async {
+        // Block dismissal if swipe started from screen edge (Android back gesture)
+        if (lastTouchWasInEdgeZone) return false;
+        // Don't allow dismissing the currently playing item
+        return !isCurrentItem;
+      },
+      onDismissed: (direction) => _handleDelete(item, index),
+      child: _buildQueueItemWithDragHandle(item, index, isCurrentItem, isPastItem),
+    );
+  }
+
+  Widget _buildQueueItemWithDragHandle(QueueItem item, int index, bool isCurrentItem, bool isPastItem) {
+    return Builder(
+      builder: (itemContext) => _buildQueueItemContent(
+        item,
+        index,
+        isCurrentItem,
+        isPastItem,
+        dragHandle: isCurrentItem
+            ? SizedBox(
+                width: 48,
+                height: 48,
+                child: Center(
+                  child: Icon(Icons.play_arrow_rounded, color: widget.primaryColor, size: 20),
+                ),
+              )
+            : SizedBox(
+                width: 48,
+                height: 48,
+                child: Listener(
+                  behavior: HitTestBehavior.opaque,
+                  onPointerDown: (event) {
+                    _startDrag(index, itemContext, event.position);
+                  },
+                  // Move/up/cancel handled by parent Listener on Stack
+                  child: Center(
+                    child: Icon(Icons.drag_handle, color: widget.textColor.withOpacity(0.3), size: 20),
+                  ),
+                ),
+              ),
+      ),
+    );
+  }
+
+  Widget _buildQueueItemContent(QueueItem item, int index, bool isCurrentItem, bool isPastItem, {Widget? dragHandle}) {
+    final imageUrl = widget.maProvider.api?.getImageUrl(item.track, size: 80);
+    final duration = _formatDuration(item.track.duration);
+
+    return RepaintBoundary(
+      child: Opacity(
+        opacity: isPastItem ? 0.5 : 1.0,
+        child: Container(
+          margin: isCurrentItem ? const EdgeInsets.symmetric(horizontal: 8, vertical: 2) : EdgeInsets.zero,
+          decoration: BoxDecoration(
+            color: isCurrentItem ? widget.primaryColor.withOpacity(0.15) : widget.backgroundColor,
+            borderRadius: isCurrentItem ? BorderRadius.circular(12) : BorderRadius.zero,
+          ),
+          child: ListTile(
+            dense: true,
+            // Compensate for current item's 8px margin on both sides
+            // Left:  Non-current: 8+0+16=24px, Current: 8+8+8=24px
+            // Right: Non-current: 8+0+8+14=30px, Current: 8+8+0+14=30px
+            contentPadding: EdgeInsets.only(
+              left: isCurrentItem ? 8 : 16,
+              right: isCurrentItem ? 0 : 8,
+            ),
+            leading: ClipRRect(
+              borderRadius: BorderRadius.circular(Radii.sm),
+              child: SizedBox(
+                width: 44,
+                height: 44,
+                child: imageUrl != null
+                    ? CachedNetworkImage(
+                        imageUrl: imageUrl,
+                        fit: BoxFit.cover,
+                        memCacheWidth: 176,
+                        memCacheHeight: 176,
+                        fadeInDuration: Duration.zero,
+                        fadeOutDuration: Duration.zero,
+                        placeholder: (context, url) => Container(
+                          color: widget.textColor.withOpacity(0.1),
+                          child: Icon(Icons.music_note, color: widget.textColor.withOpacity(0.3), size: 20),
+                        ),
+                        errorWidget: (context, url, error) => Container(
+                          color: widget.textColor.withOpacity(0.1),
+                          child: Icon(Icons.music_note, color: widget.textColor.withOpacity(0.3), size: 20),
+                        ),
+                      )
+                    : Container(
+                        color: widget.textColor.withOpacity(0.1),
+                        child: Icon(Icons.music_note, color: widget.textColor.withOpacity(0.3), size: 20),
+                      ),
+              ),
+            ),
+            title: Text(
+              item.track.name,
+              style: TextStyle(
+                color: isCurrentItem ? widget.primaryColor : widget.textColor,
+                fontSize: 14,
+                fontWeight: isCurrentItem ? FontWeight.w600 : FontWeight.normal,
+              ),
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+            ),
+            subtitle: item.track.artists != null && item.track.artists!.isNotEmpty
+                ? Text(
+                    item.track.artists!.first.name,
+                    style: TextStyle(
+                      color: widget.textColor.withOpacity(0.6),
+                      fontSize: 12,
+                    ),
+                    maxLines: 1,
+                    overflow: TextOverflow.ellipsis,
+                  )
+                : null,
+            trailing: Row(
+              mainAxisSize: MainAxisSize.min,
+              children: [
+                if (duration.isNotEmpty)
+                  Text(
+                    duration,
+                    style: TextStyle(
+                      color: widget.textColor.withOpacity(0.5),
+                      fontSize: 12,
+                    ),
+                  ),
+                dragHandle ?? Icon(Icons.drag_handle, color: widget.textColor.withOpacity(0.3), size: 20),
+              ],
+            ),
+            onTap: () => _handleTapToSkip(item, index, isCurrentItem),
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+/// Helper class for velocity tracking samples
+class _VelocitySample {
+  final Offset position;
+  final int timeMs;
+
+  _VelocitySample(this.position, this.timeMs);
 }

lib/widgets/player_picker_sheet.dart

@@ -0,0 +1,226 @@
+import 'package:flutter/material.dart';
+import '../models/player.dart';
+import '../l10n/app_localizations.dart';
+
+/// A themed bottom sheet for selecting a player.
+///
+/// Supports adaptive theming - pass [adaptiveColorScheme] to use colors
+/// extracted from album art, matching the detail screen backgrounds.
+class PlayerPickerSheet extends StatelessWidget {
+  final String title;
+  final List<Player> players;
+  final Player? selectedPlayer;
+  final ColorScheme? adaptiveColorScheme;
+  final Future<void> Function(Player player) onPlayerSelected;
+
+  const PlayerPickerSheet({
+    super.key,
+    required this.title,
+    required this.players,
+    this.selectedPlayer,
+    this.adaptiveColorScheme,
+    required this.onPlayerSelected,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final themeColorScheme = Theme.of(context).colorScheme;
+    final colorScheme = adaptiveColorScheme ?? themeColorScheme;
+
+    // Use surface container for slightly elevated look, or adaptive surface
+    final backgroundColor = adaptiveColorScheme?.surface ?? themeColorScheme.surfaceContainerHigh;
+    final onBackgroundColor = adaptiveColorScheme?.onSurface ?? themeColorScheme.onSurface;
+
+    return Container(
+      decoration: BoxDecoration(
+        color: backgroundColor,
+        borderRadius: const BorderRadius.vertical(top: Radius.circular(20)),
+      ),
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          // Drag handle
+          Padding(
+            padding: const EdgeInsets.only(top: 12, bottom: 8),
+            child: Container(
+              width: 32,
+              height: 4,
+              decoration: BoxDecoration(
+                color: onBackgroundColor.withOpacity(0.3),
+                borderRadius: BorderRadius.circular(2),
+              ),
+            ),
+          ),
+
+          // Title
+          Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 8),
+            child: Text(
+              title,
+              style: Theme.of(context).textTheme.titleLarge?.copyWith(
+                color: onBackgroundColor,
+              ),
+              textAlign: TextAlign.center,
+            ),
+          ),
+
+          const SizedBox(height: 8),
+
+          // Player list
+          if (players.isEmpty)
+            Padding(
+              padding: const EdgeInsets.all(32.0),
+              child: Text(
+                S.of(context)!.noPlayersAvailable,
+                style: TextStyle(color: onBackgroundColor.withOpacity(0.6)),
+              ),
+            )
+          else
+            Flexible(
+              child: ListView.builder(
+                shrinkWrap: true,
+                padding: const EdgeInsets.symmetric(horizontal: 8),
+                itemCount: players.length,
+                itemBuilder: (context, index) {
+                  final player = players[index];
+                  final isSelected = selectedPlayer?.playerId == player.playerId;
+
+                  return _PlayerTile(
+                    player: player,
+                    isSelected: isSelected,
+                    colorScheme: colorScheme,
+                    onBackgroundColor: onBackgroundColor,
+                    onTap: () => onPlayerSelected(player),
+                  );
+                },
+              ),
+            ),
+
+          SizedBox(height: MediaQuery.of(context).padding.bottom + 70),
+        ],
+      ),
+    );
+  }
+}
+
+class _PlayerTile extends StatelessWidget {
+  final Player player;
+  final bool isSelected;
+  final ColorScheme colorScheme;
+  final Color onBackgroundColor;
+  final VoidCallback onTap;
+
+  const _PlayerTile({
+    required this.player,
+    required this.isSelected,
+    required this.colorScheme,
+    required this.onBackgroundColor,
+    required this.onTap,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    // Status color based on player state
+    Color statusColor;
+    if (!player.available) {
+      statusColor = Colors.grey.withOpacity(0.5);
+    } else if (!player.powered) {
+      statusColor = Colors.grey;
+    } else if (player.state == 'playing') {
+      statusColor = Colors.green;
+    } else {
+      statusColor = Colors.orange; // Idle/paused but powered
+    }
+
+    return Padding(
+      padding: const EdgeInsets.symmetric(vertical: 2),
+      child: Material(
+        color: isSelected
+            ? colorScheme.primaryContainer.withOpacity(0.3)
+            : Colors.transparent,
+        borderRadius: BorderRadius.circular(12),
+        child: InkWell(
+          onTap: onTap,
+          borderRadius: BorderRadius.circular(12),
+          child: Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+            child: Row(
+              children: [
+                // Status indicator
+                Container(
+                  width: 8,
+                  height: 8,
+                  decoration: BoxDecoration(
+                    shape: BoxShape.circle,
+                    color: statusColor,
+                  ),
+                ),
+                const SizedBox(width: 12),
+
+                // Speaker icon
+                Icon(
+                  Icons.speaker_rounded,
+                  color: isSelected
+                      ? colorScheme.primary
+                      : onBackgroundColor.withOpacity(0.7),
+                  size: 24,
+                ),
+                const SizedBox(width: 12),
+
+                // Player name
+                Expanded(
+                  child: Text(
+                    player.name,
+                    style: TextStyle(
+                      color: isSelected
+                          ? colorScheme.primary
+                          : onBackgroundColor,
+                      fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
+                      fontSize: 16,
+                    ),
+                  ),
+                ),
+
+                // Selected checkmark
+                if (isSelected)
+                  Icon(
+                    Icons.check_circle_rounded,
+                    color: colorScheme.primary,
+                    size: 20,
+                  ),
+              ],
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+/// Shows the player picker bottom sheet with adaptive theming.
+///
+/// Returns the selected player, or null if dismissed.
+Future<void> showPlayerPickerSheet({
+  required BuildContext context,
+  required String title,
+  required List<Player> players,
+  Player? selectedPlayer,
+  ColorScheme? adaptiveColorScheme,
+  required Future<void> Function(Player player) onPlayerSelected,
+}) {
+  return showModalBottomSheet(
+    context: context,
+    backgroundColor: Colors.transparent,
+    isScrollControlled: true,
+    builder: (context) => PlayerPickerSheet(
+      title: title,
+      players: players,
+      selectedPlayer: selectedPlayer,
+      adaptiveColorScheme: adaptiveColorScheme,
+      onPlayerSelected: (player) async {
+        Navigator.pop(context);
+        await onPlayerSelected(player);
+      },
+    ),
+  );
+}

lib/widgets/player_selector.dart

@@ -1,9 +1,11 @@
 import 'dart:async';
 import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
 import 'package:material_design_icons_flutter/material_design_icons_flutter.dart';
 import 'package:provider/provider.dart';
 import 'package:cached_network_image/cached_network_image.dart';
 import '../constants/timings.dart';
+import '../l10n/app_localizations.dart';
 import '../providers/music_assistant_provider.dart';
 import 'global_player_overlay.dart'; // For isPlayerExpanded and collapsePlayer
 
@@ -17,40 +19,61 @@ class PlayerSelector extends StatelessWidget {
     final availablePlayers = maProvider.availablePlayers;
     final colorScheme = Theme.of(context).colorScheme;
 
+    // Count players that are currently playing MA content (excluding selected player)
+    // User already sees if selected player is playing, badge shows "other" activity
+    // Exclude external sources (Spotify Connect, TV optical, etc.) - they're not playing MA content
+    final selectedPlayerId = selectedPlayer?.playerId;
+    final playingCount = availablePlayers
+        .where((p) => p.state == 'playing' && p.playerId != selectedPlayerId && !p.isExternalSource)
+        .length;
+
     return Padding(
       padding: const EdgeInsets.symmetric(horizontal: 8.0),
-      child: Material(
-        color: colorScheme.primaryContainer,
-        borderRadius: BorderRadius.circular(8),
-        child: InkWell(
-          onTap: () => _showPlayerSelector(context, maProvider, availablePlayers),
+      child: Badge(
+        isLabelVisible: playingCount > 0,
+        backgroundColor: colorScheme.tertiary,
+        textColor: colorScheme.onTertiary,
+        label: Text(
+          playingCount.toString(),
+          style: TextStyle(
+            fontWeight: FontWeight.w900,
+            fontSize: 11,
+            color: colorScheme.onTertiary,
+          ),
+        ),
+        child: Material(
+          color: colorScheme.primaryContainer,
           borderRadius: BorderRadius.circular(8),
-          child: Padding(
-            padding: const EdgeInsets.symmetric(horizontal: 12.0, vertical: 8.0),
-            child: Row(
-              mainAxisSize: MainAxisSize.min,
-              children: [
-                if (selectedPlayer != null) ...[
-                  ConstrainedBox(
-                    constraints: const BoxConstraints(maxWidth: 120),
-                    child: Text(
-                      selectedPlayer.name,
-                      style: TextStyle(
-                        color: colorScheme.onPrimaryContainer,
-                        fontWeight: FontWeight.w600,
+          child: InkWell(
+            onTap: () => _showPlayerSelector(context, maProvider, availablePlayers),
+            borderRadius: BorderRadius.circular(8),
+            child: Padding(
+              padding: const EdgeInsets.symmetric(horizontal: 12.0, vertical: 8.0),
+              child: Row(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  if (selectedPlayer != null) ...[
+                    ConstrainedBox(
+                      constraints: const BoxConstraints(maxWidth: 120),
+                      child: Text(
+                        selectedPlayer.name,
+                        style: TextStyle(
+                          color: colorScheme.onPrimaryContainer,
+                          fontWeight: FontWeight.w600,
+                        ),
+                        maxLines: 1,
+                        overflow: TextOverflow.ellipsis,
                       ),
-                      maxLines: 1,
-                      overflow: TextOverflow.ellipsis,
                     ),
+                    const SizedBox(width: 8),
+                  ],
+                  Icon(
+                    MdiIcons.castAudio,
+                    color: colorScheme.onPrimaryContainer,
+                    size: 20,
                   ),
-                  const SizedBox(width: 8),
                 ],
-                Icon(
-                  MdiIcons.castAudio,
-                  color: colorScheme.onPrimaryContainer,
-                  size: 20,
-                ),
-              ],
+              ),
             ),
           ),
         ),
@@ -63,27 +86,8 @@ class PlayerSelector extends StatelessWidget {
     MusicAssistantProvider provider,
     List players,
   ) {
-    // Collapse player if expanded before showing sheet
-    if (GlobalPlayerOverlay.isPlayerExpanded) {
-      GlobalPlayerOverlay.collapsePlayer();
-    }
-
-    // Slide mini player down out of the way
-    GlobalPlayerOverlay.hidePlayer();
-
-    // Show the bottom sheet
-    showModalBottomSheet(
-      context: context,
-      backgroundColor: Colors.transparent,
-      isScrollControlled: true,
-      isDismissible: true,
-      builder: (context) {
-        return _PlayerSelectorSheet();
-      },
-    ).whenComplete(() {
-      // Slide mini player back up when sheet is dismissed
-      GlobalPlayerOverlay.showPlayer();
-    });
+    // Use the new player reveal animation
+    GlobalPlayerOverlay.showPlayerReveal();
   }
 }
 
@@ -182,7 +186,7 @@ class _PlayerSelectorSheetState extends State<_PlayerSelectorSheet> {
                       child: currentPlayers.isEmpty
                           ? Center(
                               child: Text(
-                                'No players available',
+                                S.of(context)!.noPlayersAvailable,
                                 style: TextStyle(color: colorScheme.onSurface.withOpacity(0.54)),
                               ),
                             )
@@ -199,23 +203,34 @@ class _PlayerSelectorSheetState extends State<_PlayerSelectorSheet> {
                               // but still have track info - treat as "has content" for display
                               final isIdle = player.state == 'idle';
 
+                              // Check for external source (optical, Spotify, etc.)
+                              final isExternalSource = player.isExternalSource;
+
                               // Get track info - use current track for selected player, cache for others
-                              final playerTrack = isSelected
-                                  ? currentTrack
-                                  : maProvider.getCachedTrackForPlayer(player.playerId);
+                              // Skip track info for external sources
+                              final playerTrack = isExternalSource
+                                  ? null
+                                  : (isSelected
+                                      ? currentTrack
+                                      : maProvider.getCachedTrackForPlayer(player.playerId));
 
-                              // Player has content if playing, paused, or idle with cached track
-                              final hasContent = isPlaying || isPaused || (isIdle && playerTrack != null);
+                              // Player has content if playing, paused, or idle with cached track (but not external source)
+                              final hasContent = !isExternalSource && (isPlaying || isPaused || (isIdle && playerTrack != null));
 
-                              // Get album art for any player with content
+                              // Get album art for any player with content (skip for external source)
                               String? albumArtUrl;
-                              if (playerTrack != null && isOn && hasContent) {
+                              if (!isExternalSource && playerTrack != null && isOn && hasContent) {
                                 albumArtUrl = maProvider.getImageUrl(
                                   playerTrack.album ?? playerTrack,
                                   size: 128,
                                 );
                               }
 
+                              // Check if this player is manually synced (not a pre-configured group)
+                              final isGrouped = maProvider.isPlayerManuallySynced(player.playerId);
+                              // Pastel yellow for grouped players
+                              const groupBorderColor = Color(0xFFFFF59D);
+
                               return Padding(
                                 padding: const EdgeInsets.only(bottom: 8),
                                 child: InkWell(
@@ -223,6 +238,23 @@ class _PlayerSelectorSheetState extends State<_PlayerSelectorSheet> {
                                     maProvider.selectPlayer(player);
                                     Navigator.pop(context);
                                   },
+                                  onLongPress: () {
+                                    // Haptic feedback for sync action
+                                    HapticFeedback.mediumImpact();
+
+                                    // Show snackbar for visual feedback
+                                    ScaffoldMessenger.of(context).showSnackBar(
+                                      SnackBar(
+                                        content: Text('Syncing ${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),
                                   child: Container(
                                     height: 72,
@@ -231,6 +263,9 @@ class _PlayerSelectorSheetState extends State<_PlayerSelectorSheet> {
                                           ? colorScheme.primary.withOpacity(0.15)
                                           : colorScheme.surfaceVariant.withOpacity(0.3),
                                       borderRadius: BorderRadius.circular(16),
+                                      border: isGrouped
+                                          ? Border.all(color: groupBorderColor, width: 1.5)
+                                          : null,
                                     ),
                                     child: Row(
                                       children: [
@@ -293,23 +328,27 @@ class _PlayerSelectorSheetState extends State<_PlayerSelectorSheet> {
                                                           ? colorScheme.onSurface.withOpacity(0.24)
                                                           : !isOn
                                                               ? colorScheme.onSurface.withOpacity(0.3)
-                                                              : isPlaying
-                                                                  ? Colors.green
-                                                                  : hasContent
-                                                                      ? Colors.orange // paused or idle with content
-                                                                      : colorScheme.onSurfaceVariant.withOpacity(0.5),
+                                                              : isExternalSource
+                                                                  ? Colors.cyan // external source (optical, Spotify, etc.)
+                                                                  : isPlaying
+                                                                      ? Colors.green
+                                                                      : hasContent
+                                                                          ? Colors.orange // paused or idle with content
+                                                                          : colorScheme.onSurfaceVariant.withOpacity(0.5),
                                                     ),
                                                   ),
                                                   const SizedBox(width: 6),
                                                   Expanded(
                                                     child: Text(
                                                       !player.available
-                                                          ? 'Unavailable'
+                                                          ? S.of(context)!.playerStateUnavailable
                                                           : !isOn
-                                                              ? 'Off'
-                                                              : hasContent && playerTrack != null
-                                                                  ? playerTrack.name
-                                                                  : 'Idle',
+                                                              ? S.of(context)!.playerStateOff
+                                                              : isExternalSource
+                                                                  ? S.of(context)!.playerStateExternalSource
+                                                                  : hasContent && playerTrack != null
+                                                                      ? playerTrack.name
+                                                                      : S.of(context)!.playerStateIdle,
                                                       style: TextStyle(
                                                         color: player.available
                                                             ? colorScheme.onSurfaceVariant
@@ -320,6 +359,35 @@ class _PlayerSelectorSheetState extends State<_PlayerSelectorSheet> {
                                                       overflow: TextOverflow.ellipsis,
                                                     ),
                                                   ),
+                                                  if (isGrouped) ...[
+                                                    const SizedBox(width: 8),
+                                                    Container(
+                                                      padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 2),
+                                                      decoration: BoxDecoration(
+                                                        color: groupBorderColor.withOpacity(0.3),
+                                                        borderRadius: BorderRadius.circular(4),
+                                                      ),
+                                                      child: Row(
+                                                        mainAxisSize: MainAxisSize.min,
+                                                        children: [
+                                                          Icon(
+                                                            Icons.link_rounded,
+                                                            size: 10,
+                                                            color: Colors.amber.shade800,
+                                                          ),
+                                                          const SizedBox(width: 3),
+                                                          Text(
+                                                            'Synced',
+                                                            style: TextStyle(
+                                                              color: Colors.amber.shade800,
+                                                              fontSize: 10,
+                                                              fontWeight: FontWeight.w600,
+                                                            ),
+                                                          ),
+                                                        ],
+                                                      ),
+                                                    ),
+                                                  ],
                                                   if (isSelected) ...[
                                                     const SizedBox(width: 8),
                                                     Container(
@@ -329,7 +397,7 @@ class _PlayerSelectorSheetState extends State<_PlayerSelectorSheet> {
                                                         borderRadius: BorderRadius.circular(4),
                                                       ),
                                                       child: Text(
-                                                        'Selected',
+                                                        S.of(context)!.playerSelected,
                                                         style: TextStyle(
                                                           color: colorScheme.primary,
                                                           fontSize: 10,
@@ -343,8 +411,8 @@ class _PlayerSelectorSheetState extends State<_PlayerSelectorSheet> {
                                             ],
                                           ),
                                         ),
-                                        // Play/Pause button
-                                        if (player.available && isOn)
+                                        // Play/Pause button (hidden for external sources - controls don't work)
+                                        if (player.available && isOn && !isExternalSource)
                                           IconButton(
                                             icon: Icon(
                                               isPlaying ? Icons.pause_rounded : Icons.play_arrow_rounded,